private TSTypeSyntax _valueTypeSyntax() { return createTypeSyntax(_template.getSchema().getValues()); } }
private static String toMapLiteral(DataMap dataMap, MapDataSchema mapSchema) { StringBuilder sb = new StringBuilder(); DataSchema valuesSchema = mapSchema.getValues().getDereferencedDataSchema(); Iterator<Map.Entry<String, Object>> iter = dataMap.entrySet().iterator(); sb.append("["); while (iter.hasNext()) { Map.Entry<String, Object> entry = iter.next(); sb.append("\""); sb.append(escapeString(entry.getKey())); sb.append("\""); sb.append(": "); sb.append(toLiteral(valuesSchema, entry.getValue())); if (iter.hasNext()) { sb.append(", "); } } sb.append("]"); return sb.toString(); } }
protected void recurseMap(DataElement element, MapDataSchema schema, Object object) { DataMap map = (DataMap) object; DataSchema childSchema = schema.getValues(); MutableDataElement childElement = new MutableDataElement(element); for (Map.Entry<String, Object> entry : map.entrySet()) { String key = entry.getKey(); Object value = entry.getValue(); childElement.setValueNameSchema(value, key, childSchema); validate(childElement, childSchema, value); } }
private void writeMap(MapDataSchema schema) throws IOException { write("map[string, "); writeReferenceOrInline(schema.getValues(), schema.isValuesDeclaredInline()); write("]"); }
private ClassAndSchema getMapValueName(MapDataSchema mapSchema, ClassTemplateSpec enclosingClass, String memberName) { CustomInfoSpec customInfo = getImmediateCustomInfo(mapSchema.getValues()); if (customInfo != null) { return new ClassAndSchema(new ClassInfo(customInfo.getCustomSchema().getNamespace(), customInfo.getCustomSchema().getName()), customInfo.getCustomSchema()); } else { return new ClassAndSchema(classNameForUnnamedTraverse(enclosingClass, memberName, mapSchema.getValues()), mapSchema.getValues()); } }
private DataSchema currentSchema() { DataSchema schema; DataSchema mapSchema = _element.getSchema(); if (mapSchema == null) { schema = null; } else { DataSchema dereferencedSchema = mapSchema.getDereferencedDataSchema(); DataSchema.Type deferencedType = dereferencedSchema.getType(); switch (deferencedType) { case RECORD: RecordDataSchema.Field field = ((RecordDataSchema) dereferencedSchema).getField(_currentEntry.getKey()); schema = (field == null ? null : field.getType()); break; case UNION: schema = ((UnionDataSchema) dereferencedSchema).getTypeByMemberKey(_currentEntry.getKey()); break; case MAP: schema = ((MapDataSchema) dereferencedSchema).getValues(); break; default: throw new IllegalStateException("Unknown dereferenced type " + deferencedType + " for DataMap's schema " + mapSchema); } } return schema; }
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); } } }
/** * Constructor. * * @param map is the underlying {@link DataMap} that will be proxied by this {@link WrappingMapTemplate}. * @param schema is the {@link DataSchema} of the map. * @param valueClass is the class of elements returned by this {@link WrappingMapTemplate}. */ protected WrappingMapTemplate(DataMap map, MapDataSchema schema, Class<V> valueClass) throws TemplateOutputCastException { super(map, schema, valueClass, DataMap.class); _constructor = DataTemplateUtil.templateConstructor(valueClass, schema.getValues()); _cache = new DataObjectToObjectCache<V>(data().size()); _entrySet = new EntrySet(); }
dataSchema = ((MapDataSchema) dataSchema).getValues(); break; case ARRAY:
break; case MAP: childSchema = ((MapDataSchema) schema).getValues(); break; case UNION:
@Override public void key(String key) throws IOException { DataSchema newSchema = null; if (_currentSchema != null) { switch (_currentSchema.getType()) { case RECORD: RecordDataSchema recordSchema = (RecordDataSchema) _currentSchema; RecordDataSchema.Field field = recordSchema.getField(key); if (field != null) { newSchema = field.getType(); } break; case UNION: UnionDataSchema unionSchema = (UnionDataSchema) _currentSchema; newSchema = unionSchema.getTypeByMemberKey(key); break; case MAP: MapDataSchema mapSchema = (MapDataSchema) _currentSchema; newSchema = mapSchema.getValues(); break; } } _pendingSchema = newSchema; super.key(key); }
case MAP: DataMap map = (DataMap) value; DataSchema valueDataSchema = ((MapDataSchema) dataSchema).getValues(); Map<String, Object> resultMap = new DataMap(map.size() * 2); for (Map.Entry<String, Object> entry : map.entrySet())
case MAP: MapDataSchema mapDataSchema = (MapDataSchema) schema; traverseChild(DataSchemaConstants.VALUES_KEY, mapDataSchema.getValues()); break; case ARRAY:
recordType(mapSchema.getValues(), foundTypes, typeOrder);
computeImports(mapSchema.getValues(), mapSchema.isValuesDeclaredInline(), importsAcc);
_builder.writeFieldName(VALUES_KEY); MapDataSchema mapDataSchema = (MapDataSchema) schema; encode(mapDataSchema.getValues(), mapDataSchema.isValuesDeclaredInline()); encodeProperties(schema); _builder.writeEndObject();
DataSchema valuesSchema = ((MapDataSchema) dataSchema).getValues().getDereferencedDataSchema();
private CourierMapTemplateSpec generateMap(MapDataSchema schema, ClassTemplateSpec enclosingClass, String memberName) final DataSchema valueSchema = schema.getValues();
for (int i = 0; i < spec.getArraySize(); i++) final Object item = buildData(parentSchemas, ((MapDataSchema) derefSchema).getValues(), fieldName, spec); dataMap.put("mapField_" + _random.nextInt(), item);