private final List<GeneratedProperty> properties;
private final boolean isAbstract;
- public AbstractGeneratedType(AbstractGeneratedTypeBuilder<?> builder) {
+ public AbstractGeneratedType(final AbstractGeneratedTypeBuilder<?> builder) {
super(builder.getPackageName(), builder.getName());
this.parent = builder.getParent();
this.comment = builder.getComment();
this.annotations = toUnmodifiableAnnotations(builder.getAnnotations());
- this.implementsTypes = Collections.unmodifiableList(builder.getImplementsTypes());
- this.constants = Collections.unmodifiableList(builder.getConstants());
+ this.implementsTypes = makeUnmodifiable(builder.getImplementsTypes());
+ this.constants = makeUnmodifiable(builder.getConstants());
this.enumerations = toUnmodifiableEnumerations(builder.getEnumerations());
this.methodSignatures = toUnmodifiableMethods(builder.getMethodDefinitions());
this.enclosedTypes = toUnmodifiableEnclosedTypes(builder.getEnclosedTypes(),
this.parent = parent;
this.comment = comment;
this.annotations = toUnmodifiableAnnotations(annotationBuilders);
- this.implementsTypes = Collections.unmodifiableList(implementsTypes);
- this.constants = Collections.unmodifiableList(constants);
+ this.implementsTypes = makeUnmodifiable(implementsTypes);
+ this.constants = makeUnmodifiable(constants);
this.enumerations = toUnmodifiableEnumerations(enumBuilders);
this.methodSignatures = toUnmodifiableMethods(methodBuilders);
this.enclosedTypes = toUnmodifiableEnclosedTypes(enclosedGenTypeBuilders, enclosedGenTOBuilders);
this.properties = toUnmodifiableProperties(propertyBuilders);
this.isAbstract = isAbstract;
+ }
+ protected static final <T> List<T> makeUnmodifiable(final List<T> list) {
+ switch (list.size()) {
+ case 0:
+ return Collections.emptyList();
+ case 1:
+ return Collections.singletonList(list.get(0));
+ default:
+ return Collections.unmodifiableList(list);
+ }
}
- private List<GeneratedType> toUnmodifiableEnclosedTypes(final List<GeneratedTypeBuilder> enclosedGenTypeBuilders,
+ private static List<GeneratedType> toUnmodifiableEnclosedTypes(final List<GeneratedTypeBuilder> enclosedGenTypeBuilders,
final List<GeneratedTOBuilder> enclosedGenTOBuilders) {
- final List<GeneratedType> enclosedTypesList = new ArrayList<>();
+ final ArrayList<GeneratedType> enclosedTypesList = new ArrayList<>(enclosedGenTypeBuilders.size() + enclosedGenTOBuilders.size());
for (final GeneratedTypeBuilder builder : enclosedGenTypeBuilders) {
if (builder != null) {
enclosedTypesList.add(builder.toInstance());
enclosedTypesList.add(builder.toInstance());
}
}
- return enclosedTypesList;
+
+ return makeUnmodifiable(enclosedTypesList);
}
- protected final List<AnnotationType> toUnmodifiableAnnotations(final List<AnnotationTypeBuilder> annotationBuilders) {
- final List<AnnotationType> annotationList = new ArrayList<>();
+ protected static final List<AnnotationType> toUnmodifiableAnnotations(final List<AnnotationTypeBuilder> annotationBuilders) {
+ final List<AnnotationType> annotationList = new ArrayList<>(annotationBuilders.size());
for (final AnnotationTypeBuilder builder : annotationBuilders) {
annotationList.add(builder.toInstance());
}
- return Collections.unmodifiableList(annotationList);
+ return makeUnmodifiable(annotationList);
}
- protected final List<MethodSignature> toUnmodifiableMethods(List<MethodSignatureBuilder> methodBuilders) {
- final List<MethodSignature> methods = new ArrayList<>();
+ protected final List<MethodSignature> toUnmodifiableMethods(final List<MethodSignatureBuilder> methodBuilders) {
+ final List<MethodSignature> methods = new ArrayList<>(methodBuilders.size());
for (final MethodSignatureBuilder methodBuilder : methodBuilders) {
methods.add(methodBuilder.toInstance(this));
}
- return Collections.unmodifiableList(methods);
+ return makeUnmodifiable(methods);
}
- protected final List<Enumeration> toUnmodifiableEnumerations(List<EnumBuilder> enumBuilders) {
- final List<Enumeration> enums = new ArrayList<>();
+ protected final List<Enumeration> toUnmodifiableEnumerations(final List<EnumBuilder> enumBuilders) {
+ final List<Enumeration> enums = new ArrayList<>(enumBuilders.size());
for (final EnumBuilder enumBuilder : enumBuilders) {
enums.add(enumBuilder.toInstance(this));
}
- return Collections.unmodifiableList(enums);
+ return makeUnmodifiable(enums);
}
- protected final List<GeneratedProperty> toUnmodifiableProperties(List<GeneratedPropertyBuilder> methodBuilders) {
- final List<GeneratedProperty> methods = new ArrayList<>();
+ protected final List<GeneratedProperty> toUnmodifiableProperties(final List<GeneratedPropertyBuilder> methodBuilders) {
+ final List<GeneratedProperty> methods = new ArrayList<>(methodBuilders.size());
for (final GeneratedPropertyBuilder methodBuilder : methodBuilders) {
methods.add(methodBuilder.toInstance(this));
}
- return Collections.unmodifiableList(methods);
+ return makeUnmodifiable(methods);
}
@Override
GeneratedTOBuilder {
private GeneratedTransferObject extendsType;
- private final List<GeneratedPropertyBuilder> equalsProperties = new ArrayList<>();
- private final List<GeneratedPropertyBuilder> hashProperties = new ArrayList<>();
- private final List<GeneratedPropertyBuilder> toStringProperties = new ArrayList<>();
+ private final ArrayList<GeneratedPropertyBuilder> equalsProperties = new ArrayList<>();
+ private final ArrayList<GeneratedPropertyBuilder> hashProperties = new ArrayList<>();
+ private final ArrayList<GeneratedPropertyBuilder> toStringProperties = new ArrayList<>();
private boolean isTypedef = false;
private boolean isUnionType = false;
private boolean isUnionTypeBuilder = false;
private Restrictions restrictions;
private GeneratedPropertyBuilder SUID;
- public GeneratedTOBuilderImpl(String packageName, String name) {
+ public GeneratedTOBuilderImpl(final String packageName, final String name) {
super(packageName, name);
setAbstract(false);
}
* @return <code>new</code> instance of Method Signature Builder.
*/
@Override
- public MethodSignatureBuilder addMethod(String name) {
+ public MethodSignatureBuilder addMethod(final String name) {
final MethodSignatureBuilder builder = super.addMethod(name);
builder.setAbstract(false);
return builder;
}
@Override
- public GeneratedTOBuilder addEqualsIdentity(GeneratedPropertyBuilder property) {
+ public GeneratedTOBuilder addEqualsIdentity(final GeneratedPropertyBuilder property) {
equalsProperties.add(property);
return this;
}
@Override
- public GeneratedTOBuilder addHashIdentity(GeneratedPropertyBuilder property) {
+ public GeneratedTOBuilder addHashIdentity(final GeneratedPropertyBuilder property) {
hashProperties.add(property);
return this;
}
@Override
- public GeneratedTOBuilder addToStringProperty(GeneratedPropertyBuilder property) {
+ public GeneratedTOBuilder addToStringProperty(final GeneratedPropertyBuilder property) {
toStringProperties.add(property);
return this;
}
}
@Override
- public void setRestrictions(Restrictions restrictions) {
+ public void setRestrictions(final Restrictions restrictions) {
this.restrictions = restrictions;
}
@Override
- public void setSUID(GeneratedPropertyBuilder suid) {
+ public void setSUID(final GeneratedPropertyBuilder suid) {
this.SUID = suid;
}
@Override
public GeneratedTransferObject toInstance() {
+ // FIXME: can we compact the arrays now? It needs to be thread-safe, though
return new GeneratedTransferObjectImpl(this);
}
}
@Override
- public void setTypedef(boolean isTypedef) {
+ public void setTypedef(final boolean isTypedef) {
this.isTypedef = isTypedef;
}
@Override
- public void setIsUnion(boolean isUnion) {
+ public void setIsUnion(final boolean isUnion) {
this.isUnionType = isUnion;
}
@Override
- public void setIsUnionBuilder(boolean isUnionTypeBuilder) {
+ public void setIsUnionBuilder(final boolean isUnionTypeBuilder) {
this.isUnionTypeBuilder = isUnionTypeBuilder;
}
private final Restrictions restrictions;
private final GeneratedProperty SUID;
- public GeneratedTransferObjectImpl(GeneratedTOBuilderImpl builder) {
+ public GeneratedTransferObjectImpl(final GeneratedTOBuilderImpl builder) {
super(builder);
this.extendsType = builder.extendsType;
this.equalsProperties = toUnmodifiableProperties(builder.equalsProperties);
return builder.toString();
}
- public String serializeTypedef(Type type) {
+ public String serializeTypedef(final Type type) {
if (type instanceof ParameterizedType) {
ParameterizedType parameterizedType = (ParameterizedType) type;
StringBuffer sb = new StringBuffer();