@Override public String getUnionMemberKey() { return _referencedType.getUnionMemberKey(); }
/** * Returns the key that will be used for this member while serializing the Union. If an alias * is available for this member, the alias will be returned else the default union member key * of the member's type will be returned. * * @return The union member key for this member */ public String getUnionMemberKey() { return hasAlias() ? _alias : _type.getUnionMemberKey(); }
public String unionMemberKey() { return _member.getSchema().getUnionMemberKey(); }
public static Class<?> getJavaCustomTypeClassFromSchema(DataSchema schema) { final Class<?> bindingClass; final String javaCoercerClassName = getJavaCustomTypeClassNameFromSchema(schema); if(javaCoercerClassName != null) { try { bindingClass = Class.forName(javaCoercerClassName, false, Thread.currentThread().getContextClassLoader()); } catch (ClassNotFoundException e) { throw new IllegalArgumentException("Unable to find java coercer class of " + javaCoercerClassName + " for schema " + schema.getUnionMemberKey()); } } else { bindingClass = null; } return bindingClass; }
/** * Returns the symbol used to access this union member's index in the union's "unpack" return object. * * For example, given union[FortuneCookie], the return object from "unpack" would be { fortuneCookie: union["namespace.FortuneCookie"] as FortuneCookie } */ public String unpackString() { DataSchema schema = _memberSchema(); String unpackNameBase; if (schema instanceof PrimitiveDataSchema) { unpackNameBase = schema.getUnionMemberKey(); } else { unpackNameBase = _memberTypeSyntax().typeName(); } String punctuationEscaped = unpackNameBase.replaceAll("[\\p{Punct}\\p{Space}]", ""); String lowerCased = Character.toLowerCase(punctuationEscaped.charAt(0)) + punctuationEscaped.substring(1); return escapeKeyword(lowerCased, EscapeStrategy.MANGLE); }
/** * 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; }
protected Map.Entry<String, Schema> findUnionMember(DataSchema dataSchema, Schema avroSchema) { AvroOverride avroOverride = getAvroOverride(dataSchema); String key = (avroOverride == null ? dataSchema.getUnionMemberKey() : avroOverride.getAvroSchemaFullName()); List<Schema> members = avroSchema.getTypes(); for (Schema member : members) { String name; switch (member.getType()) { case ENUM: case FIXED: case RECORD: name = member.getFullName(); break; default: name = member.getType().toString().toLowerCase(); } if (name.equals(key)) return new AbstractMap.SimpleEntry<String, Schema>(name, member); } appendMessage("cannot find %1$s in union %2$s", key, avroSchema); return null; }
/** * Returns the union member class name for the given {@link ClassTemplateSpec} as a Typescript * source code string. * * @return a typescript source code string identifying the union member. */ public String unionMemberTypeName() { DataSchema memberSchema = _memberSchema(); Type memberType = _memberSchema().getType(); if (memberSchema.isPrimitive() || memberType == Type.MAP || memberType == Type.ARRAY) { String unionMemberKey = _memberSchema().getUnionMemberKey(); String camelCasedName = Character.toUpperCase(unionMemberKey.charAt(0)) + unionMemberKey.substring(1); return camelCasedName + "Member"; // IntMember, DoubleMember, FixedMember etc } else if (memberSchema instanceof NamedDataSchema) { String className = ((NamedDataSchema) memberSchema).getName(); return className + "Member"; // e.g: FortuneCookieMember } else { throw new IllegalArgumentException("Don't know how to handle schema of type " + memberSchema.getType()); } }
private UnionTemplateSpec generateUnion(UnionDataSchema schema, UnionTemplateSpec unionClass) { for (DataSchema memberType : schema.getTypes()) { final UnionTemplateSpec.Member newMember = new UnionTemplateSpec.Member(); unionClass.getMembers().add(newMember); newMember.setSchema(memberType); if (memberType.getDereferencedType() != DataSchema.Type.NULL) { newMember.setClassTemplateSpec(processSchema(memberType, unionClass, memberType.getUnionMemberKey())); newMember.setDataClass(determineDataClass(memberType, unionClass, memberType.getUnionMemberKey())); } } return unionClass; }
protected void encode(DataSchema schema, boolean originallyInlined) throws IOException { TypeRepresentation representation = selectTypeRepresentation(schema, originallyInlined); markEncountered(schema); if (schema.isPrimitive()) { _builder.writeString(schema.getUnionMemberKey()); } else if (schema instanceof NamedDataSchema) { encodeNamed((NamedDataSchema) schema, representation); } else { encodeUnnamed(schema); } }
return dataSchema.getUnionMemberKey();
if (valueClass != null) resourceSchema.setSchema(DataTemplateUtil.getSchema(valueClass).getUnionMemberKey());
_path.add(schema.getUnionMemberKey());
String key = memberDataSchema.getUnionMemberKey(); dataMap = new DataMap(1); _path.addLast(key);
/*package*/ static String buildDataSchemaType(DataSchema schema) { if (schema instanceof PrimitiveDataSchema || schema instanceof NamedDataSchema) { return schema.getUnionMemberKey(); } JsonBuilder builder = null; try { builder = new JsonBuilder(JsonBuilder.Pretty.SPACES); final SchemaToJsonEncoder encoder = new SchemaToJsonEncoder(builder, AbstractSchemaEncoder.TypeReferenceFormat.MINIMIZE); encoder.encode(schema); return builder.result(); } catch (IOException e) { throw new RestLiInternalException("could not encode schema for '" + schema.toString() + "'", e); } finally { if (builder != null) { builder.closeQuietly(); } } }
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; } }
addMessage(element, "cannot be fixed because DataMap backing %1$s type is read-only", parentElement.getSchema().getUnionMemberKey());
_path.addLast(newer.getUnionMemberKey());