private ArrayDataSchema parseArray(ArrayDeclarationContext array) throws ParseException { ArrayDataSchema schema = new ArrayDataSchema(toDataSchema(array.typeParams.items)); schema.setItemsDeclaredInline(isDeclaredInline(array.typeParams.items)); return schema; }
private void writeArray(ArrayDataSchema schema) throws IOException { write("array["); writeReferenceOrInline(schema.getItems(), schema.isItemsDeclaredInline()); write("]"); }
switch (dataSchema.getType()) { case ARRAY: DataSchema itemsSchema = ((ArrayDataSchema) dataSchema).getItems().getDereferencedDataSchema(); modifiedSchema = new ArrayDataSchema(modifiedItemsSchema);
private ArrayDataSchema parseArray(ArrayDeclarationContext array) throws ParseException { return new ArrayDataSchema(toDataSchema(array.typeParams.items)); }
public ArrayDataSchema(DataSchema items) { super(Type.ARRAY); setItems(items); }
/** * Set the {@link DataSchema} of items in the array. * * @param items is the {@link DataSchema} of items in the array. */ void setItems(DataSchema items) { if (items == null) { _items = DataSchemaConstants.NULL_DATA_SCHEMA; setHasError(); } else { _items = items; } }
return new ArrayDataSchema(typerefDataSchema); return new ArrayDataSchema(itemSchema);
private TSTypeSyntax _itemTypeSyntax() { return createTypeSyntax(_template.getSchema().getItems()); } }
_builder.writeFieldName(ITEMS_KEY); ArrayDataSchema arrayDataSchema = (ArrayDataSchema) schema; encode(arrayDataSchema.getItems(), arrayDataSchema.isItemsDeclaredInline()); encodeProperties(schema); _builder.writeEndObject();
ArrayDataSchema arraySchema = new ArrayDataSchema(itemsSchema); arraySchema.setItemsDeclaredInline(isDeclaredInline(map.get(ITEMS_KEY))); schema = arraySchema; break;
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(); }
computeImports(arraySchema.getItems(), arraySchema.isItemsDeclaredInline(), importsAcc);
@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; }
/** * 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); } } }