MapDataSchema schema = new MapDataSchema(toDataSchema(valueType)); Map<String, Object> propsToAdd = new HashMap<String, Object>(); schema.setProperties(propsToAdd); schema.setValuesDeclaredInline(isDeclaredInline(valueType)); return schema;
private void writeMap(MapDataSchema schema) throws IOException { write("map[string, "); writeReferenceOrInline(schema.getValues(), schema.isValuesDeclaredInline()); write("]"); }
private MapDataSchema parseMap(MapDeclarationContext map) throws ParseException { TypeAssignmentContext keyType = map.typeParams.key; TypeAssignmentContext valueType = map.typeParams.value; MapDataSchema schema = new MapDataSchema(toDataSchema(valueType)); Map<String, Object> propsToAdd = new HashMap<String, Object>(); if (keyType.typeReference() != null) { String typeName = keyType.typeReference().value; // TODO(jbetz): // Replace with https://github.com/coursera/courier/tree/with-restli-upstream-fixes // once https://github.com/linkedin/rest.li/pull/61 is accepted. if (!typeName.equals("string")) { String qualifiedKeyName = computeFullName(typeName); propsToAdd.put("keys", qualifiedKeyName); } } else if (keyType.typeDeclaration() != null) { DataSchema keySchema = parseType(keyType.typeDeclaration()); String json = SchemaToJsonEncoder.schemaToJson(keySchema, JsonBuilder.Pretty.COMPACT); try { DataMap dataMap = codec.stringToMap(json); propsToAdd.put("keys", dataMap); } catch (IOException e) { startErrorMessage(map) .append("Unexpected error parsing map: ").append(e.getMessage()).append("\n"); } } schema.setProperties(propsToAdd); return schema; }
DataSchema valuesSchema = ((MapDataSchema) dataSchema).getValues().getDereferencedDataSchema(); modifiedSchema = new MapDataSchema(modifiedValuesSchema);
private CourierMapTemplateSpec generateMap(MapDataSchema schema, ClassTemplateSpec enclosingClass, String memberName) final DataSchema valueSchema = schema.getValues(); final Object keysSchemaData = schema.getProperties().get("keys"); DataSchema keySchema; if (keysSchemaData != null)
case MAP: DataSchema valuesSchema = getSchemaData(map, VALUES_KEY); MapDataSchema mapSchema = new MapDataSchema(valuesSchema); mapSchema.setValuesDeclaredInline(isDeclaredInline(map.get(VALUES_KEY))); schema = mapSchema; break;
@Override public RecordDataSchema schema() { synchronized (this) { // Don't use double-checked locking because _schema isn't volatile if (_schema == null) { final StringBuilder errorMessageBuilder = new StringBuilder(10); final Name elementSchemaName = new Name(_valueClass.getSimpleName(), errorMessageBuilder); final MapDataSchema resultsSchema = new MapDataSchema(new RecordDataSchema(elementSchemaName, RecordDataSchema.RecordType.RECORD)); final RecordDataSchema.Field resultsField = new RecordDataSchema.Field(resultsSchema); resultsField.setName(RESULTS, errorMessageBuilder); final MapDataSchema errorsSchema = new MapDataSchema(DataTemplateUtil.getSchema(ErrorResponse.class)); final RecordDataSchema.Field errorsField = new RecordDataSchema.Field(errorsSchema); errorsField.setName(ERRORS, errorMessageBuilder); final Name name = new Name(BATCH_KV_RESPONSE_CLASSNAME, errorMessageBuilder); _schema = new RecordDataSchema(name, RecordDataSchema.RecordType.RECORD); _schema.setFields(Arrays.asList(resultsField, errorsField), errorMessageBuilder); } } return _schema; }
private ClassAndSchema getMapKeyName(MapDataSchema mapSchema, ClassTemplateSpec enclosingClass, String memberName) final Object keysSchemaData = mapSchema.getProperties().get("keys"); if (keysSchemaData != null)
private TSTypeSyntax _valueTypeSyntax() { return createTypeSyntax(_template.getSchema().getValues()); } }
_builder.writeFieldName(VALUES_KEY); MapDataSchema mapDataSchema = (MapDataSchema) schema; encode(mapDataSchema.getValues(), mapDataSchema.isValuesDeclaredInline()); encodeProperties(schema); _builder.writeEndObject();
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(); } }
computeImports(mapSchema.getValues(), mapSchema.isValuesDeclaredInline(), importsAcc);
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 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: