protected void writeSchemaName(NamedDataSchema schema) throws IOException { _builder.writeString(_currentNamespace.equals(schema.getNamespace()) ? schema.getName() : schema.getFullName()); }
private Map<String, Object> setProperties( NamedTypeDeclarationContext source, NamedDataSchema target) throws ParseException { Map<String, Object> properties = new HashMap<String, Object>(); properties.putAll(target.getProperties()); if (source.doc != null) { target.setDoc(source.doc.value); } for (PropDeclarationContext prop: source.props) { addPropertiesAtPath(properties, prop); } target.setProperties(properties); return properties; }
public String docString() { return docComment( _dataSchema.getDoc(), _dataSchema.getProperties().get("deprecated") ); }
/** * Return the {@link DataSchema}'s language binding name. * This is the fully qualified name for the generated data model to resolve potential name conflict. * * @return the {@link DataSchema}'s language binding name. */ @Override public String getBindingName() { return (_package == null || _package.isEmpty()) ? getFullName() : _package + "." + getName(); }
public Set<String> modulesRequiredToUse() { Set<String> modules = new HashSet<>(); // Named types get their own files, so you have to import them in order to use them. modules.add(importString(_dataSchema.getName(), _dataSchema.getNamespace())); return modules; } }
@Override public String getUnionMemberKey() { return getFullName(); }
private void renderDataModel(NamedDataSchema schema, DataMap outputMap) throws IOException { final DataMap models = outputMap.getDataMap("models"); final DataMap schemaData = _codec.stringToMap(schema.toString()); models.put(schema.getFullName(), schemaData); }
private ClassTemplateSpec generateNamedSchema(NamedDataSchema schema) { pushCurrentLocation(_schemaResolver.nameToDataSchemaLocations().get(schema.getFullName())); final String className = classNameForNamedSchema(schema); checkForClassNameConflict(className, schema); final ClassTemplateSpec templateClass; switch (schema.getType()) { case RECORD: templateClass = generateRecord((RecordDataSchema) schema); break; case ENUM: templateClass = generateEnum((EnumDataSchema) schema); break; case FIXED: templateClass = generateFixed((FixedDataSchema) schema); break; default: throw unrecognizedSchemaType(null, null, schema); } popCurrentLocation(); return templateClass; }
_builder.writeStringField(TYPE_KEY, schema.getType().toString().toLowerCase(), true); encodeName(schema); final String packageName = schema.getPackage(); if (packageName != null && !_currentPackage.equals(packageName)) _currentPackage = packageName; _builder.writeStringField(DOC_KEY, schema.getDoc(), false); switch(schema.getType()) throw new IllegalStateException("schema type " + schema.getType() + " is not a known NamedDataSchema type"); for (Name name : schema.getAliases())
boolean hasNamespace = StringUtils.isNotBlank(namedSchema.getNamespace()); boolean hasPackage = StringUtils.isNotBlank(namedSchema.getPackage()); if (hasNamespace || hasPackage) writeLine("namespace " + escapeIdentifier(namedSchema.getNamespace())); _namespace = namedSchema.getNamespace(); writeLine("package " + escapeIdentifier(namedSchema.getPackage())); _package = namedSchema.getPackage();
public String typeName() { return TSSyntax.escapeKeyword(this._dataSchema.getName(), EscapeStrategy.MANGLE); }
if (doc != null) namedSchema.setDoc(doc); namedSchema.setPackage(packageName); namedSchema.setAliases(aliasNames);
private ClassTemplateSpec getDereferencedType(CustomInfoSpec customInfo, ClassTemplateSpec fallback) { if (customInfo != null) { DataSchema refSchema = customInfo.getCustomSchema().getDereferencedDataSchema(); return ClassTemplateSpec.createFromDataSchema(refSchema); } else { return fallback; } }
if (!namedSchema.getNamespace().equals(getCurrentNamespace()))
/** * Return a {@link DataMap} representation of the provided {@link NamedDataSchema}. * * @param schema provides the {@link NamedDataSchema}. * @return a {@link DataMap} representation of the provided {@link NamedDataSchema}. */ public static DataMap dataSchemaToDataMap(NamedDataSchema schema) { String inputSchemaAsString = schema.toString(); try { JacksonDataCodec codec = new JacksonDataCodec(); DataMap schemaAsDataMap = codec.stringToMap(inputSchemaAsString); return schemaAsDataMap; } catch (IOException e) { // This should never occur. // UTF-8 encoding should always be valid for getBytes // codec.readMap from JSON generated from a schema should always be successful. throw new IllegalStateException(UNEXPECTED_IOEXCEPTION + inputSchemaAsString, e); } }
public void markEncountered(DataSchema schema) { if (schema instanceof NamedDataSchema) { _alreadyEncountered.add(((NamedDataSchema) schema).getFullName()); } }
/** * Return Java class name for a {@link com.linkedin.data.schema.NamedDataSchema}. * * @param schema provides the {@link com.linkedin.data.schema.NamedDataSchema}. * * @return the fully qualified Java class name for the provided {@link com.linkedin.data.schema.NamedDataSchema}. */ public static String classNameForNamedSchema(NamedDataSchema schema) { final StringBuilder sb = new StringBuilder(); final String namespace = schema.getNamespace(); if (!namespace.isEmpty()) { sb.append(namespace); sb.append('.'); } sb.append(schema.getName()); return sb.toString(); }
private void addRelatedModels(ResourceSchema resourceSchema, DataMap models) throws IOException { Map<String, DataMap> relatedSchemas; synchronized (this) { relatedSchemas = _relatedSchemaCache.get(resourceSchema); if (relatedSchemas == null) { relatedSchemas = new HashMap<String, DataMap>(); final Node<?> node = _relationships.getRelationships(resourceSchema); final Iterator<Node<NamedDataSchema>> schemaItr = node.getAdjacency(NamedDataSchema.class).iterator(); while (schemaItr.hasNext()) { final NamedDataSchema currResource = (NamedDataSchema) schemaItr.next().getObject(); relatedSchemas.put(currResource.getFullName(), _codec.stringToMap(currResource.toString())); } _relatedSchemaCache.put(resourceSchema, relatedSchemas); } } models.putAll(relatedSchemas); }
if (schema instanceof NamedDataSchema) { NamedDataSchema namedSchema = (NamedDataSchema) schema; hasNamespaceOverride = !namedSchema.getNamespace().equals(surroundingNamespace); hasPackageOverride = !StringUtils.isEmpty(namedSchema.getPackage()) && !namedSchema.getPackage().equals(surroundingPackage); if (hasNamespaceOverride || hasPackageOverride) { write("{"); write(namedSchema.getNamespace()); newline(); indent(); _namespace = namedSchema.getNamespace(); write(namedSchema.getPackage()); newline(); indent(); _package = namedSchema.getPackage();
/** * Return the Avro-compatible union member key (discriminator) for the provided {@link DataSchema}. * * The Avro-compatible key does not include the namespace in the key, e.g. the key for * "com.linkedin.foo.Bar" is "Bar". * * @param schema to return the Avro-compatible union member key for. * @return the Avro-compatible union member key for provided {@link DataSchema}. */ public static String avroUnionMemberKey(DataSchema schema) { DataSchema dereferencedSchema = schema.getDereferencedDataSchema(); String name; // Avro union member type discriminator names if (dereferencedSchema instanceof NamedDataSchema) { name = ((NamedDataSchema) dereferencedSchema).getName(); } else { name = dereferencedSchema.getUnionMemberKey(); } return name; }