import java.util.ArrayList;
import java.util.Collections;
+import java.util.HashSet;
import java.util.List;
import java.util.Optional;
+import java.util.Set;
+import org.opendaylight.mdsal.binding.model.api.AbstractBaseType;
import org.opendaylight.mdsal.binding.model.api.AnnotationType;
import org.opendaylight.mdsal.binding.model.api.Constant;
import org.opendaylight.mdsal.binding.model.api.Enumeration;
import org.opendaylight.mdsal.binding.model.api.GeneratedProperty;
import org.opendaylight.mdsal.binding.model.api.GeneratedType;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.MethodSignature;
import org.opendaylight.mdsal.binding.model.api.Type;
import org.opendaylight.mdsal.binding.model.api.TypeComment;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTOBuilder;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
import org.opendaylight.mdsal.binding.model.api.type.builder.MethodSignatureBuilder;
-import org.opendaylight.mdsal.binding.model.util.AbstractBaseType;
abstract class AbstractGeneratedType extends AbstractBaseType implements GeneratedType {
private final boolean isAbstract;
private final YangSourceDefinition definition;
- public AbstractGeneratedType(final AbstractGeneratedTypeBuilder<?> builder) {
- super(builder.getPackageName(), builder.getName());
+ AbstractGeneratedType(final AbstractGeneratedTypeBuilder<?> builder) {
+ super(builder.getIdentifier());
this.parent = builder.getParent();
this.comment = builder.getComment();
this.annotations = toUnmodifiableAnnotations(builder.getAnnotations());
this.definition = builder.getYangSourceDefinition().orElse(null);
}
- public AbstractGeneratedType(final Type parent, final String packageName, final String name,
- final TypeComment comment, final List<AnnotationTypeBuilder> annotationBuilders, final boolean isAbstract,
+ AbstractGeneratedType(final Type parent, final JavaTypeName identifier, final TypeComment comment,
+ final List<AnnotationTypeBuilder> annotationBuilders, final boolean isAbstract,
final List<Type> implementsTypes, final List<GeneratedTypeBuilder> enclosedGenTypeBuilders,
final List<GeneratedTOBuilder> enclosedGenTOBuilders, final List<EnumBuilder> enumBuilders,
final List<Constant> constants, final List<MethodSignatureBuilder> methodBuilders,
final List<GeneratedPropertyBuilder> propertyBuilders) {
- super(packageName, name);
+ super(identifier);
this.parent = parent;
this.comment = comment;
this.annotations = toUnmodifiableAnnotations(annotationBuilders);
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);
+ case 0:
+ return Collections.emptyList();
+ case 1:
+ return Collections.singletonList(list.get(0));
+ default:
+ return Collections.unmodifiableList(list);
}
}
- private static List<GeneratedType> toUnmodifiableEnclosedTypes(final List<GeneratedTypeBuilder> enclosedGenTypeBuilders,
+ protected static <T> Set<T> makeUnmodifiable(final Set<T> set) {
+ switch (set.size()) {
+ case 0:
+ return Collections.emptySet();
+ case 1:
+ return Collections.singleton(set.iterator().next());
+ default:
+ return Collections.unmodifiableSet(set);
+ }
+ }
+
+ private static List<GeneratedType> toUnmodifiableEnclosedTypes(
+ final List<GeneratedTypeBuilder> enclosedGenTypeBuilders,
final List<GeneratedTOBuilder> enclosedGenTOBuilders) {
- final ArrayList<GeneratedType> enclosedTypesList = new ArrayList<>(enclosedGenTypeBuilders.size() + enclosedGenTOBuilders.size());
+ 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.build());
}
}
for (final GeneratedTOBuilder builder : enclosedGenTOBuilders) {
if (builder != null) {
- enclosedTypesList.add(builder.toInstance());
+ enclosedTypesList.add(builder.build());
}
}
return makeUnmodifiable(enclosedTypesList);
}
- protected static final List<AnnotationType> toUnmodifiableAnnotations(final List<AnnotationTypeBuilder> annotationBuilders) {
+ 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());
+ annotationList.add(builder.build());
}
return makeUnmodifiable(annotationList);
}
return makeUnmodifiable(methods);
}
+ protected final Set<MethodSignature> toUnmodifiableMethods(final Set<MethodSignatureBuilder> getters) {
+ final Set<MethodSignature> methods = new HashSet<>(getters.size());
+ for (final MethodSignatureBuilder methodBuilder : getters) {
+ methods.add(methodBuilder.toInstance(this));
+ }
+ return makeUnmodifiable(methods);
+ }
+
protected final List<Enumeration> toUnmodifiableEnumerations(final List<EnumBuilder> enumBuilders) {
final List<Enumeration> enums = new ArrayList<>(enumBuilders.size());
for (final EnumBuilder enumBuilder : enumBuilders) {
return makeUnmodifiable(enums);
}
- protected final List<GeneratedProperty> toUnmodifiableProperties(final List<GeneratedPropertyBuilder> methodBuilders) {
+ 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));