private TSTypeSyntax _itemTypeSyntax() { return createTypeSyntax(_template.getSchema().getItems()); } }
private static String toArrayLiteral(DataList dataList, ArrayDataSchema arraySchema) { StringBuilder sb = new StringBuilder(); DataSchema itemsSchema = arraySchema.getItems().getDereferencedDataSchema(); Iterator<Object> iter = dataList.iterator(); sb.append("["); while (iter.hasNext()) { Object element = iter.next(); sb.append(toLiteral(itemsSchema, element)); if (iter.hasNext()) { sb.append(", "); } } sb.append("]"); return sb.toString(); }
@Override public void index(int index) { DataSchema newSchema = null; if (_currentSchema != null && _currentSchema.getType() == DataSchema.Type.ARRAY) { ArrayDataSchema arraySchema = (ArrayDataSchema) _currentSchema; newSchema = arraySchema.getItems(); } _pendingSchema = newSchema; super.index(index); }
private static void registerCoercerForPrimitiveTypeRefArray(ArrayDataSchema schema) { DataSchema elementSchema = schema.getItems(); if (elementSchema instanceof TyperefDataSchema) { TyperefDataSchema typerefSchema = (TyperefDataSchema) elementSchema; if (RestModelConstants.PRIMITIVE_DATA_SCHEMA_TYPE_ALLOWED_TYPES.containsKey(typerefSchema.getDereferencedType())) { if (CustomTypeUtil.getJavaCustomTypeClassNameFromSchema(typerefSchema) != null) { registerCoercer(typerefSchema); } } } }
protected void recurseArray(DataElement element, ArrayDataSchema schema, Object object) { DataList list = (DataList) object; DataSchema childSchema = schema.getItems(); int index = 0; MutableDataElement childElement = new MutableDataElement(element); for (Object value : list) { childElement.setValueNameSchema(value, index, childSchema); validate(childElement, childSchema, value); index++; } }
private DataSchema currentSchema() { DataSchema schema = null; DataSchema listSchema = _element.getSchema(); if (listSchema != null) { DataSchema dereferencedListSchema = listSchema.getDereferencedDataSchema(); if (dereferencedListSchema.getType() == DataSchema.Type.ARRAY) { schema = ((ArrayDataSchema) dereferencedListSchema).getItems(); } } return schema; }
private void writeArray(ArrayDataSchema schema) throws IOException { write("array["); writeReferenceOrInline(schema.getItems(), schema.isItemsDeclaredInline()); write("]"); }
/** * Constructor. * * @param list is the underlying {@link DataList} that will be proxied by this {@link WrappingArrayTemplate}. * @param schema is the {@link DataSchema} of the array. * @param elementClass is the class of elements returned by this {@link WrappingArrayTemplate}. */ protected WrappingArrayTemplate(DataList list, ArrayDataSchema schema, Class<E> elementClass) throws TemplateOutputCastException { super(list, schema, elementClass, DataList.class); _constructor = DataTemplateUtil.templateConstructor(elementClass, schema.getItems()); _cache = new DataObjectToObjectCache<E>(data().size()); }
private static boolean checkParameterHasTyperefSchema(Parameter<?> parameter) { boolean result = false; DataSchema dataSchema = parameter.getDataSchema(); Class<?> dataType = parameter.getType(); if (dataType.isArray()) { if (dataSchema instanceof ArrayDataSchema) { dataSchema = ((ArrayDataSchema) dataSchema).getItems(); } else { throw new ResourceConfigException( "Array typed parameter " + parameter.getName() + " must have an array schema."); } } if (dataSchema instanceof TyperefDataSchema) { result = true; } return result; }
private void visitInlineSchema(VisitContext visitContext, String schemaString) { DataSchema schema = DataTemplateUtil.parseSchema(schemaString, _schemaResolver); if (schema instanceof ArrayDataSchema) { DataSchema itemSchema = ((ArrayDataSchema)schema).getItems(); if (itemSchema instanceof NamedDataSchema) { connectSchemaToResource(visitContext, (NamedDataSchema)itemSchema); } } if (schema instanceof MapDataSchema) { DataSchema valueSchema = ((MapDataSchema)schema).getValues(); if (valueSchema instanceof NamedDataSchema) { connectSchemaToResource(visitContext, (NamedDataSchema)valueSchema); } } }
break; case ARRAY: dataSchema = ((ArrayDataSchema) dataSchema).getItems(); break; case RECORD:
case ARRAY: ArrayDataSchema arrayDataSchema = (ArrayDataSchema) schema; traverseChild(DataSchemaConstants.ITEMS_KEY, arrayDataSchema.getItems()); break; case RECORD:
private String getParameterItems(ParameterSchema param, DataSchemaResolver resolver) { if (param.hasItems()) { _infoMap.addRestSpecInfo(CompatibilityInfo.Type.DEPRECATED, _infoPath, "The \"items\" field"); return param.getItems(GetMode.DEFAULT); } final DataSchema paramDataSchema = RestSpecCodec.textToSchema(param.getType(GetMode.DEFAULT), resolver); if (paramDataSchema instanceof ArrayDataSchema) { // Union member key works because previously only primitive types are allowed for items field return ((ArrayDataSchema) paramDataSchema).getItems().getUnionMemberKey(); } else { _infoMap.addRestSpecInfo("type", CompatibilityInfo.Type.TYPE_ERROR, _infoPath, "expect an array, got " + paramDataSchema.getType()); return null; } }
recordType(arraySchema.getItems(), foundTypes, typeOrder);
private ArrayTemplateSpec generateArray(ArrayDataSchema schema, ClassTemplateSpec enclosingClass, String memberName) { final DataSchema itemSchema = schema.getItems(); final ClassInfo classInfo = classInfoForUnnamed(enclosingClass, memberName, schema); if (classInfo.existingClass != null) { /* When type refs are used as item types inside some unnamed complex schemas like map and array, * the type refs are de-referenced and the underlying real type is used in the generated class. * In those cases the type refs are not processed by the class generation logic, an explicit * schema processing is necessary in order to processSchema the data template classes for those type * refs. */ processSchema(itemSchema, enclosingClass, memberName); return (ArrayTemplateSpec) classInfo.existingClass; } final ArrayTemplateSpec arrayClass = (ArrayTemplateSpec) classInfo.definedClass; registerClassTemplateSpec(schema, arrayClass); arrayClass.setItemClass(processSchema(itemSchema, enclosingClass, memberName)); arrayClass.setItemDataClass(determineDataClass(itemSchema, enclosingClass, memberName)); final CustomInfoSpec customInfo = getImmediateCustomInfo(itemSchema); arrayClass.setCustomInfo(customInfo); return arrayClass; }
private void generateQueryParamBindingMethods(JDefinedClass facadeClass, ParameterSchemaArray parameters, JDefinedClass derivedBuilderClass) { for (ParameterSchema param : parameters) { if ("array".equals(param.getType())) { final JClass paramItemsClass = getJavaBindingType(param.getItems(), facadeClass).valueClass; final JClass paramClass = getCodeModel().ref(Iterable.class).narrow(paramItemsClass); generateQueryParamSetMethod(derivedBuilderClass, param, paramClass, paramItemsClass); generateQueryParamAddMethod(derivedBuilderClass, param, paramItemsClass); } else { final DataSchema typeSchema = RestSpecCodec.textToSchema(param.getType(), _schemaResolver); final JClass paramClass = getJavaBindingType(typeSchema, facadeClass).valueClass; generateQueryParamSetMethod(derivedBuilderClass, param, paramClass, paramClass); // we deprecate the "items" field from ParameterSchema, which generates Iterable<Foo> in the builder // instead, we use the standard way to represent arrays, which generates FooArray // for backwards compatibility, add the method with Iterable<Foo> parameter if (typeSchema instanceof ArrayDataSchema) { final DataSchema itemsSchema = ((ArrayDataSchema) typeSchema).getItems(); final JClass paramItemsClass = getJavaBindingType(itemsSchema, facadeClass).valueClass; final JClass iterableItemsClass = getCodeModel().ref(Iterable.class).narrow(paramItemsClass); generateQueryParamSetMethod(derivedBuilderClass, param, iterableItemsClass, paramItemsClass); generateQueryParamAddMethod(derivedBuilderClass, param, paramItemsClass); } } } }
_builder.writeFieldName(ITEMS_KEY); ArrayDataSchema arrayDataSchema = (ArrayDataSchema) schema; encode(arrayDataSchema.getItems(), arrayDataSchema.isItemsDeclaredInline()); encodeProperties(schema); _builder.writeEndObject();
switch (dataSchema.getType()) { case ARRAY: DataSchema itemsSchema = ((ArrayDataSchema) dataSchema).getItems().getDereferencedDataSchema();
final DataSchema itemsSchema = ((ArrayDataSchema) typeSchema).getItems(); final ClassTemplateSpec itemSpecClass = schemaToTemplateSpec(itemsSchema); final String addMethodName =