How to use

MCollectionType

in

leap.lang.meta

private static MType doResolveType(MetaApi api, MType type) {
  if(type instanceof MUnresolvedTypeRef) {
    return resolveType(api, ((MUnresolvedTypeRef) type).getRefTypeName());
  }
  if(type instanceof MCollectionType) {
    return new MCollectionType(doResolveType(api, type.asCollectionType().getElementType()));
  }
  if(type instanceof MDictionaryType) {
    return new MDictionaryType(type.asDictionaryType().getKeyType(), doResolveType(api, type.asDictionaryType().getValueType()));
  }
  throw new IllegalStateException("Unsupported type '" + type + "'");
}

protected static Validator ofArray(MetaApi api, String name, boolean required, MCollectionType t, @Nullable MetaObjFormatted p) {
  MType elementType = t.getElementType();
  Validator elementValidator = of(api, name + ".items", elementType);
  return new ArrayValidator(name, required, p, elementValidator);
}

protected MCollectionType readCollectionType(JsonObject items, SwaggerExtension ex) {
  return new MCollectionType(readType(items, ex));
}

protected void writeArrayType(WriteContext context, ApiMetadata m, JsonWriter w, MCollectionType ct) {
  w.property(TYPE, ARRAY)
   .property(ITEMS,() -> {
     w.startObject();
     writeType(context, m, w, ct.getElementType());
     w.endObject();
   });
}

return new MCollectionType(elementType);
return new MCollectionType(MObjectType.TYPE);
    throw new IllegalStateException("Invalid array type '" + typeName + "'");
  return new MCollectionType(resolveType(api, elementType));

Class<?> toJavaType(MType type) {
  if(type.isSimpleType()) {
    return type.asSimpleType().getJavaType();
  }
  if(type.isCollectionType()) {
    return Array.newInstance(toJavaType(type.asCollectionType().getElementType()), 0).getClass();
  }
  if(type.isComplexType() || type.isDictionaryType() || type.isTypeRef()) {
    return Map.class;
  }
  if(type.isObjectType()) {
    return Object.class;
  }
  throw new IllegalStateException("Unsupported data type '" + type + "'");
}

return new MCollectionType(root.getMType(declaringType, type.getComponentType(), null, context));
return new MCollectionType(elementType);

/**
 * Returns the referenced type name.
 */
public String getRefTypeName() {
  return type.isCollectionType() ?
      type.asCollectionType().getElementType().asTypeRef().getRefTypeName() :
      type.asTypeRef().getRefTypeName();
}

protected void addQueryResponse(RestdContext ctx, SqlCommand sc, FuncActionBuilder action, MApiOperationBuilder mo) {
  //todo:
  MApiResponseBuilder r = new MApiResponseBuilder();
  r.setStatus(200);
  r.setType(new MCollectionType(MDictionaryType.INSTANCE));
  r.setDescription("Success");
  /*
  MApiHeaderBuilder header = new MApiHeaderBuilder();
  header.setName("X-Total-Count");
  header.setType(MSimpleTypes.BIGINT);
  header.setDescription("The total count of query records.");
  r.addHeader(header);
  */
  mo.addResponse(r);
}

private static boolean hasUnresolvedType(MType type) {
  if(type instanceof MUnresolvedTypeRef) {
    return true;
  }
  if(type.isCollectionType()) {
    return hasUnresolvedType(type.asCollectionType().getElementType());
  }
  if(type.isDictionaryType()) {
    return hasUnresolvedType(type.asDictionaryType().getValueType());
  }
  return false;
}

private MApiResponseBuilder newModelQueryResponse(RestdModel model) {
  MApiResponseBuilder r = new MApiResponseBuilder();
  r.setStatus(200);
  r.setType(new MCollectionType(new MComplexTypeRef(model.getName())));
  r.setDescription("Success");
  MApiHeaderBuilder header = new MApiHeaderBuilder();
  header.setName("X-Total-Count");
  header.setType(MSimpleTypes.BIGINT);
  header.setDescription("The total count of query records.");
  r.addHeader(header);
  return r;
}

protected boolean isBodyType(MType type) {
  if(type.isComplexType()) {
    return true;
  }
  if(type.isTypeRef()) {
    return true;
  }
  if(type.isDictionaryType()) {
    return true;
  }
  if(type.isCollectionType()) {
    MType elementType = type.asCollectionType().getElementType();
    return isBodyType(elementType);
  }
  return false;
}

p.setExpandable(r.getExpandable());
if(r.isOneToMany() || r.isManyToMany()) {
  p.setType(new MCollectionType(new MComplexTypeRef(r.getTargetEntity())));
}else {
  p.setType(new MComplexTypeRef(r.getTargetEntity()));

  private void onTypeResolved(MType mtype) {
    if (mtype.isComplexType()) {
      MComplexType ct = mtype.asComplexType();

      if (!complexTypes.containsKey(ct.getJavaType())) {
        listener.onComplexTypeResolved(ct.getJavaType(), mtype.asComplexType());
        complexTypes.put(ct.getJavaType(), ct);
      }

      for (MProperty p : ct.getProperties()) {
        onTypeResolved(p.getType());
      }
    } else if (mtype.isCollectionType()) {
      MType elementType = mtype.asCollectionType().getElementType();
      onTypeResolved(elementType);
    }
  }
}

  p.setType(new MCollectionType(new MComplexTypeRef(targetEntity.getEntityName())));
}else{
  p.setType(new MComplexTypeRef(targetEntity.getEntityName()));

private void checkType(MetaApi api, MetaModel model, MetaProperty p, MType type) {
  if (type.isTypeRef()) {
    String name = type.asTypeRef().getRefTypeName();
    if (null == api.getEntity(name) && null == api.getModel(name)) {
      if (Strings.containsIgnoreCase(name, "definitions/")) {
        throw new IllegalStateException("The ref type + '" + name + "' at '" +
            model.getName() + "#" + p.getName() +
            "' not exists, should use '#/definitions/' prefix!");
      } else {
        throw new IllegalStateException("The ref type + '" + name + "' at '" +
            model.getName() + "#" + p.getName() + "' not exists!");
      }
    }
  } else if (type.isCollectionType()) {
    checkType(api, model, p, type.asCollectionType().getElementType());
  }
}

public static String toTypeName(MType type) {
  if(type.isSimpleType()) {
    SwaggerType st = swaggerWriter.convertSimpleType(type.asSimpleType());
    if(null == st) {
      throw new IllegalStateException("Unsupported type '" + type + "'");
    }
    return st.name().toLowerCase();
  }
  if(type.isCollectionType()) {
    MType elementType = type.asCollectionType().getElementType();
    return "array<" + toTypeName(elementType) + ">";
  }
  if(type.isComplexType()) {
    return type.asComplexType().getName();
  }
  if(type.isTypeRef()) {
    return type.asTypeRef().getRefTypeName();
  }
  if(type.isDictionaryType()) {
    return "map<string," + toTypeName(type.asDictionaryType().getValueType()) + ">";
  }
  if(type.isObjectType()) {
    return "object";
  }
  if(type.isVoidType()) {
    return "";
  }
  throw new IllegalStateException("Unsupported type '" + type + "'");
}

MType elementType = type.asCollectionType().getElementType();
if(elementType.isSimpleType()) {
  arg.setType(Array.newInstance(elementType.asSimpleType().getJavaType(),0).getClass());

@Override
public Object apply(ActionParams params) {
  Map<String,Object> map = params.toMap();
  Object result;
  if(command.getMetadata().isSelect()) {
    //todo: page query, total count
    Query query = dao.createQuery(command).params(map);
    if(null != returnType) {
      if(returnType.isSimpleType()) {
        result = Converts.convert(query.scalarValueOrNull(), returnType.asSimpleType().getJavaType());
      }else if(returnType.isCollectionType() && returnType.asCollectionType().getElementType().isSimpleType()) {
        result = query.scalars().list(returnType.asCollectionType().getElementType().asSimpleType().getJavaType());
      }else {
        result = query.list();
      }
    }else {
      result = query.list();
    }
  }else{
    //todo: the return type must be simple type
    result = dao.executeUpdate(command, map);
    if(null != returnType) {
      result = Converts.convert(result, returnType.asSimpleType().getJavaType());
    }
  }
  return ApiResponse.of(result);
}