Specialize relative leafref types during instantiation

[mdsal.git] / binding / mdsal-binding-generator-util / src / main / java / org / opendaylight / mdsal / binding / model / util / generated / type / builder / AbstractGeneratedType.java

diff --git a/binding/mdsal-binding-generator-util/src/main/java/org/opendaylight/mdsal/binding/model/util/generated/type/builder/AbstractGeneratedType.java b/binding/mdsal-binding-generator-util/src/main/java/org/opendaylight/mdsal/binding/model/util/generated/type/builder/AbstractGeneratedType.java
index 1d31ea274b932cf650d08c6479e80379feeba0df..19771709e0d01c9e904187834e4196dd96cef6b2 100644 (file)
--- a/binding/mdsal-binding-generator-util/src/main/java/org/opendaylight/mdsal/binding/model/util/generated/type/builder/AbstractGeneratedType.java
+++ b/binding/mdsal-binding-generator-util/src/main/java/org/opendaylight/mdsal/binding/model/util/generated/type/builder/AbstractGeneratedType.java
@@ -9,26 +9,32 @@ package org.opendaylight.mdsal.binding.model.util.generated.type.builder;
 
 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.YangSourceDefinition;
 import org.opendaylight.mdsal.binding.model.api.type.builder.AnnotationTypeBuilder;
 import org.opendaylight.mdsal.binding.model.api.type.builder.EnumBuilder;
 import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedPropertyBuilder;
 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 Type parent;
-    private final String comment;
+    private final TypeComment comment;
     private final List<AnnotationType> annotations;
     private final List<Type> implementsTypes;
     private final List<Enumeration> enumerations;
@@ -37,9 +43,10 @@ abstract class AbstractGeneratedType extends AbstractBaseType implements Generat
     private final List<GeneratedType> enclosedTypes;
     private final List<GeneratedProperty> properties;
     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());
@@ -51,15 +58,16 @@ abstract class AbstractGeneratedType extends AbstractBaseType implements Generat
                 builder.getEnclosedTransferObjects());
         this.properties = toUnmodifiableProperties(builder.getProperties());
         this.isAbstract = builder.isAbstract();
+        this.definition = builder.getYangSourceDefinition().orElse(null);
     }
 
-    public AbstractGeneratedType(final Type parent, final String packageName, final String name, final String comment,
+    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);
@@ -70,41 +78,56 @@ abstract class AbstractGeneratedType extends AbstractBaseType implements Generat
         this.enclosedTypes = toUnmodifiableEnclosedTypes(enclosedGenTypeBuilders, enclosedGenTOBuilders);
         this.properties = toUnmodifiableProperties(propertyBuilders);
         this.isAbstract = isAbstract;
+        this.definition = null;
     }
 
     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);
     }
@@ -117,6 +140,14 @@ abstract class AbstractGeneratedType extends AbstractBaseType implements Generat
         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) {
@@ -125,7 +156,8 @@ abstract class AbstractGeneratedType extends AbstractBaseType implements Generat
         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));
@@ -139,7 +171,7 @@ abstract class AbstractGeneratedType extends AbstractBaseType implements Generat
     }
 
     @Override
-    public final String getComment() {
+    public final TypeComment getComment() {
         return this.comment;
     }
 
@@ -183,6 +215,11 @@ abstract class AbstractGeneratedType extends AbstractBaseType implements Generat
         return this.properties;
     }
 
+    @Override
+    public final Optional<YangSourceDefinition> getYangSourceDefinition() {
+        return Optional.ofNullable(definition);
+    }
+
     @Override
     public String toString() {
         final StringBuilder builder = new StringBuilder();