private void computeAddedUnionMembers(UnionDataSchema base, UnionDataSchema changed, List<String> added, List<UnionDataSchema.Member> commonMembers) { for (UnionDataSchema.Member member : changed.getMembers()) { String unionMemberKey = member.getUnionMemberKey(); boolean isMemberNewlyAdded = (base.getTypeByMemberKey(unionMemberKey) == null); if (isMemberNewlyAdded) { added.add(unionMemberKey); } else if (commonMembers != null) { commonMembers.add(member); } } }
/** * Parse a {@link DataList} to obtain a {@link DataSchema}. * * @param list to create {@link DataSchema} from. * @return a {@link UnionDataSchema} obtained from {@link DataList}. */ protected UnionDataSchema dataListToDataSchema(DataList list) { // Union UnionDataSchema schema = new UnionDataSchema(); List<Member> members = parseUnionMembers(schema, list); schema.setMembers(members, startCalleeMessageBuilder()); appendCalleeMessage(list); return schema; }
String avroMemberKey = avroUnionMemberKey(memberType); boolean unique = avroMemberKeys.add(avroMemberKey); if (!unique && !memberHasAlias) setHasError();
private UnionDataSchema parseUnion( UnionDeclarationContext union, boolean withinTypref) throws ParseException { UnionDataSchema schema = new UnionDataSchema(); List<UnionMemberDeclarationContext> members = union.typeParams.members; List<DataSchema> types = new ArrayList<DataSchema>(members.size()); for (UnionMemberDeclarationContext memberDecl: members) { TypeAssignmentContext memberType = memberDecl.member; DataSchema dataSchema = toDataSchema(memberType); if (dataSchema != null) { types.add(dataSchema); } } schema.setTypes(types, errorMessageBuilder()); return schema; }
@Override protected Object translateUnion(List<Object> path, Object value, UnionDataSchema unionDataSchema) { Object result; if (value == Data.NULL) { result = value; } else { // member type is always the 1st member of the union. UnionDataSchema.Member member = unionDataSchema.getMembers().get(0); result = unionDefaultValue(member, value); path.add(member.getUnionMemberKey()); translate(path, value, member.getType()); path.remove(path.size() - 1); } return result; }
private void checkUnion(UnionDataSchema older, UnionDataSchema newer) if (older.areMembersAliased() != newer.areMembersAliased()) newer.areMembersAliased() ? "added" : "removed"); List<UnionDataSchema.Member> commonMembers = new CheckerArrayList<>(newer.getMembers().size()); List<String> newerAdded = new CheckerArrayList<String>(); List<String> olderAdded = new CheckerArrayList<String>(); DataSchema olderSchema = older.getTypeByMemberKey(newerMember.getUnionMemberKey());
UnionDataSchema unionSchema = (UnionDataSchema) fieldSchema; if (unionSchema.contains(NULL_DATA_SCHEMA.getUnionMemberKey())) List<UnionDataSchema.Member> nonNullMembers = unionSchema.getMembers().stream() .filter(member -> member.getType().getType() != NULL_DATA_SCHEMA.getType()) .collect(Collectors.toCollection(ArrayList::new)); unionSchema.setMembers(nonNullMembers, errorMessages);
/** * Returns the {@link DataSchema} for a member identified by its member key returned * from {@link Member#getUnionMemberKey()}. * * @param memberKey Union member key of the member. * @return the {@link DataSchema} if type is a member of the union, else return null. * * @deprecated Replaced by {@link #getTypeByMemberKey(String)}. This method exists only to help during the * migration phase. It will be removed in the later versions and SHOULD NOT be used for any new use cases. */ @Deprecated public DataSchema getType(String memberKey) { return getTypeByMemberKey(memberKey); }
if (unionDataSchema.areMembersAliased()) DataSchema memberDataSchema = unionDataSchema.getTypeByMemberKey(key); Map.Entry<String, Schema> memberAvroEntry = findUnionMember(memberDataSchema, avroSchema); if (memberAvroEntry == null) {
boolean unionWithMembersAliased = fieldSchema.getType() == DataSchema.Type.UNION && ((UnionDataSchema) fieldSchema).areMembersAliased();
private static String toUnionLiteral(DataMap unionMap, UnionDataSchema unionSchema) { Iterator<Map.Entry<String, Object>> iter = unionMap.entrySet().iterator(); if (!iter.hasNext()) { throw new IllegalArgumentException(); } Map.Entry<String, Object> entry = iter.next(); DataSchema memberType = unionSchema.getTypeByName(entry.getKey()); if (memberType == null) { throw new IllegalArgumentException("Unrecognized union member in literal: " + entry.getKey()); } StringBuilder sb = new StringBuilder(); sb.append("."); sb.append(toUnionMemberName(ClassTemplateSpec.createFromDataSchema(memberType))); sb.append("("); sb.append(toLiteral(memberType, entry.getValue())); sb.append(")"); return sb.toString(); }
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; }
private void writeUnion(UnionDataSchema schema) throws IOException { write("union["); for(Iterator<UnionDataSchema.Member> iter = schema.getMembers().iterator(); iter.hasNext();) { UnionDataSchema.Member member = iter.next(); writeReferenceOrInline(member.getType(), member.isDeclaredInline()); if (iter.hasNext()) { write(", "); } } write("]"); }
private static DataSchema unionValueDataSchema(UnionDataSchema unionDataSchema, Object value) { DataSchema schema; if (value == null) { schema = null; } else if (value == Data.NULL) { schema = DataSchemaConstants.NULL_DATA_SCHEMA; } else { DataMap dataMap = (DataMap) value; Map.Entry<String, ?> mapEntry = dataMap.entrySet().iterator().next(); schema = unionDataSchema.getTypeByMemberKey(mapEntry.getKey()); assert(schema != null); } return schema; }
case UNION: UnionDataSchema unionDataSchema = (UnionDataSchema) dereferencedDataSchema; if (unionDataSchema.areMembersAliased())
DataSchema memberDataSchema = unionDataSchema.getTypeByMemberKey(key); if (memberDataSchema == null) if (memberDataSchema != unionDataSchema.getMembers().get(0).getType())
/** * Encode the members of an {@link UnionDataSchema}. * * @param unionDataSchema The union schema whose members needs to be encoded. * @throws IOException if there is an error while encoding. */ protected void encodeUnion(UnionDataSchema unionDataSchema) throws IOException { List<UnionDataSchema.Member> members = unionDataSchema.getMembers(); _builder.writeStartArray(); for (UnionDataSchema.Member member: members) { encodeUnionMember(member); } _builder.writeEndArray(); }
/** * Set a new value into the union. * * This is a wrapping method. The value is a {@link DataTemplate}. * * @param memberSchema provides the {@link DataSchema} of the new value. * @param memberClass provides the expected class of the value. * @param key provides the key that identifies the member value. * @param value provides the value to set. * @param <T> type of the value. * @throws ClassCastException if input value does not match the expected class. * @throws NullUnionUnsupportedOperationException if the union is a null union. */ protected <T extends DataTemplate<?>> void selectWrapped(DataSchema memberSchema, Class<T> memberClass, String key, T value) throws ClassCastException, NullUnionUnsupportedOperationException { checkNotNull(); DataSchema memberType = _schema.getTypeByMemberKey(key); assert(memberType != null); // something is wrong with the generated code if this occurs. if (value.getClass() != memberClass) { throw new ClassCastException("Input " + value + " should be a " + memberClass.getName()); } _map.clear(); _map.put(key, value.data()); _cache = value; }
private UnionDataSchema parseUnion( UnionDeclarationContext union, boolean withinTypref) throws ParseException { UnionDataSchema schema = new UnionDataSchema(); List<UnionMemberDeclarationContext> members = union.typeParams.members; List<UnionDataSchema.Member> unionMembers = new ArrayList<>(members.size()); for (UnionMemberDeclarationContext memberDecl: members) { TypeAssignmentContext memberType = memberDecl.member; DataSchema dataSchema = toDataSchema(memberType); if (dataSchema != null) { UnionDataSchema.Member unionMember = new UnionDataSchema.Member(dataSchema); unionMember.setDeclaredInline(isDeclaredInline(memberDecl.member)); unionMembers.add(unionMember); } } schema.setMembers(unionMembers, errorMessageBuilder()); return schema; }
case UNION: UnionDataSchema unionDataSchema = (UnionDataSchema) dataSchema; if (unionDataSchema.areMembersAliased())