public boolean isEquatable() { if (classSpec instanceof UnionTemplateSpec) { UnionTemplateSpec unionSpec = (UnionTemplateSpec)classSpec; TyperefTemplateSpec typerefSpec = unionSpec.getTyperefClass(); if (typerefSpec == null) return globalConfig.defaults.equatable; return globalConfig.lookupSwiftProperties(typerefSpec).equatable; } else { return swiftProperties.equatable; } }
/** Returns true in the usual case that this isn't some stupid empty union. */ public boolean requiresCompanionModule() { return !this._template.getMembers().isEmpty(); }
@Override public String typeName() { if (_template.getTyperefClass() != null) { // If this union was typerefed then just use the typeref name TSTyperefSyntax refSyntax = TSTyperefSyntaxCreate(_template.getTyperefClass()); return refSyntax.typeName(); } else { // I actually never figured out why this works, so I'm very sorry if you're dealing // with the repercussions here. return escapeKeyword(this._template.getClassName(), EscapeStrategy.MANGLE); } }
public static Map<String, String> getTypedDefinitionMapping(UnionTemplateSpec unionSpec, boolean flat) { String propertyName = flat ? "flatTypedDefinition" : "typedDefinition"; TyperefTemplateSpec typerefClass = unionSpec.getTyperefClass(); DataMap properties = (DataMap)typerefClass.getSchema().getProperties().get(propertyName); HashMap<String, String> results = new HashMap<String, String>(); for (String memberKey: properties.keySet()) { String typeName = properties.getString(memberKey); if (!memberKey.contains(".")) { String namespace = unionSpec.getNamespace(); if (namespace != null) { memberKey = unionSpec.getNamespace() + "." + memberKey; } } results.put(memberKey, typeName); } return results; } }
private ClassTemplateSpec generateUnion(UnionDataSchema schema, TyperefDataSchema typerefDataSchema) { assert typerefDataSchema.getRef() == schema; pushCurrentLocation(_schemaResolver.nameToDataSchemaLocations().get(typerefDataSchema.getFullName())); final UnionTemplateSpec unionClass = new UnionTemplateSpec(schema); unionClass.setNamespace(typerefDataSchema.getNamespace()); unionClass.setClassName(typerefDataSchema.getName()); unionClass.setModifiers(ModifierSpec.PUBLIC); registerClassTemplateSpec(typerefDataSchema, unionClass); final TyperefTemplateSpec typerefInfoClass = new TyperefTemplateSpec(typerefDataSchema); typerefInfoClass.setEnclosingClass(unionClass); typerefInfoClass.setClassName("UnionTyperefInfo"); typerefInfoClass.setModifiers(ModifierSpec.PRIVATE, ModifierSpec.STATIC, ModifierSpec.FINAL); final UnionTemplateSpec result = generateUnion(schema, unionClass); result.setTyperefClass(typerefInfoClass); popCurrentLocation(); return result; }
@Override public Set<String> modulesRequiredToUse() { Set<String> modules = new HashSet<String>(); // enclosed types dont report modules -- their enclosing types will do so for them! if (!_isEnclosedType() && this.typeName() != null) { modules.add(importString(this.typeName(), this._template.getNamespace())); } return modules; }
private boolean _isEnclosedType() { return _template.getEnclosingClass() != null; } }
public TSUnionSyntax(UnionTemplateSpec _template) { this._template = _template; this._schema = _template.getSchema(); }
@Override public String typeNameQualifiedByEnclosedType() { if (_template.getEnclosingClass() != null) { return createTypeSyntax(_template.getEnclosingClass()).typeName() + "." + this.typeName(); } else { return this.typeName(); } }
public String docString() { if (this._template.getTyperefClass() != null) { return new TSNamedTypeSyntax(this._template.getTyperefClass().getSchema()).docString(); } else { return ""; } }
/** Return the syntax for each member */ public List<TSUnionMemberSyntax> members() { List<TSUnionMemberSyntax> memberSyntax = new ArrayList<>(); for (UnionTemplateSpec.Member member : this._template.getMembers()) { memberSyntax.add(new TSUnionMemberSyntax(this, _schema, member)); } return memberSyntax; }
public static boolean isFlatTypedDefinition(UnionTemplateSpec unionSpec) { TyperefTemplateSpec typerefClass = unionSpec.getTyperefClass(); return (typerefClass != null && typerefClass.getSchema().getProperties().containsKey("flatTypedDefinition")); }
public static Set<ClassTemplateSpec> directReferencedTypes(ClassTemplateSpec spec) { Set<ClassTemplateSpec> results = new HashSet<ClassTemplateSpec>(); if (spec instanceof RecordTemplateSpec) { RecordTemplateSpec recordSpec = (RecordTemplateSpec)spec; for (RecordTemplateSpec.Field field: recordSpec.getFields()) { results.add(field.getType()); } } else if (spec instanceof UnionTemplateSpec) { UnionTemplateSpec unionSpec = (UnionTemplateSpec)spec; for (UnionTemplateSpec.Member member: unionSpec.getMembers()) { results.add(member.getClassTemplateSpec()); } } else if (spec instanceof CourierMapTemplateSpec) { CourierMapTemplateSpec mapSpec = (CourierMapTemplateSpec)spec; if (mapSpec.getKeyClass() != null) { results.add(mapSpec.getKeyClass()); } results.add(mapSpec.getValueClass()); } else if (spec instanceof ArrayTemplateSpec) { ArrayTemplateSpec arraySpec = (ArrayTemplateSpec)spec; results.add(arraySpec.getItemClass()); } return results; }
public static boolean isTypedDefinition(UnionTemplateSpec unionSpec) { TyperefTemplateSpec typerefClass = unionSpec.getTyperefClass(); return (typerefClass != null && typerefClass.getSchema().getProperties().containsKey("typedDefinition")); }
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; }