Bug 735 - Part 1: Update ietf-restconf and ietf-yangtypes to newer versions

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

diff --git a/code-generator/binding-generator-util/src/main/java/org/opendaylight/yangtools/binding/generator/util/generated/type/builder/AbstractGeneratedType.java b/code-generator/binding-generator-util/src/main/java/org/opendaylight/yangtools/binding/generator/util/generated/type/builder/AbstractGeneratedType.java
index 1c0c52ed7f54f9cdd31cb895f75875ffe4918093..eefb847ff63046cb408857387390daea88c75614 100644 (file)
--- a/code-generator/binding-generator-util/src/main/java/org/opendaylight/yangtools/binding/generator/util/generated/type/builder/AbstractGeneratedType.java
+++ b/code-generator/binding-generator-util/src/main/java/org/opendaylight/yangtools/binding/generator/util/generated/type/builder/AbstractGeneratedType.java
@@ -7,14 +7,25 @@
  */
 package org.opendaylight.yangtools.binding.generator.util.generated.type.builder;
 
-import org.opendaylight.yangtools.binding.generator.util.AbstractBaseType;
-import org.opendaylight.yangtools.sal.binding.model.api.*;
-import org.opendaylight.yangtools.sal.binding.model.api.type.builder.*;
-
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
+import org.opendaylight.yangtools.binding.generator.util.AbstractBaseType;
+import org.opendaylight.yangtools.sal.binding.model.api.AnnotationType;
+import org.opendaylight.yangtools.sal.binding.model.api.Constant;
+import org.opendaylight.yangtools.sal.binding.model.api.Enumeration;
+import org.opendaylight.yangtools.sal.binding.model.api.GeneratedProperty;
+import org.opendaylight.yangtools.sal.binding.model.api.GeneratedType;
+import org.opendaylight.yangtools.sal.binding.model.api.MethodSignature;
+import org.opendaylight.yangtools.sal.binding.model.api.Type;
+import org.opendaylight.yangtools.sal.binding.model.api.type.builder.AnnotationTypeBuilder;
+import org.opendaylight.yangtools.sal.binding.model.api.type.builder.EnumBuilder;
+import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedPropertyBuilder;
+import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedTOBuilder;
+import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedTypeBuilder;
+import org.opendaylight.yangtools.sal.binding.model.api.type.builder.MethodSignatureBuilder;
+
 abstract class AbstractGeneratedType extends AbstractBaseType implements GeneratedType {
 
     private final Type parent;
@@ -25,13 +36,30 @@ abstract class AbstractGeneratedType extends AbstractBaseType implements Generat
     private final List<Constant> constants;
     private final List<MethodSignature> methodSignatures;
     private final List<GeneratedType> enclosedTypes;
+    private final List<GeneratedProperty> properties;
     private final boolean isAbstract;
 
+    public AbstractGeneratedType(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.enumerations = toUnmodifiableEnumerations(builder.getEnumerations());
+        this.methodSignatures = toUnmodifiableMethods(builder.getMethodDefinitions());
+        this.enclosedTypes = toUnmodifiableEnclosedTypes(builder.getEnclosedTypes(),
+                builder.getEnclosedTransferObjects());
+        this.properties = toUnmodifiableProperties(builder.getProperties());
+        this.isAbstract = builder.isAbstract();
+    }
+
     public AbstractGeneratedType(final Type parent, final String packageName, final String name, final String 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<Constant> constants, final List<MethodSignatureBuilder> methodBuilders,
+            final List<GeneratedPropertyBuilder> propertyBuilders) {
         super(packageName, name);
         this.parent = parent;
         this.comment = comment;
@@ -41,35 +69,37 @@ abstract class AbstractGeneratedType extends AbstractBaseType implements Generat
         this.enumerations = toUnmodifiableEnumerations(enumBuilders);
         this.methodSignatures = toUnmodifiableMethods(methodBuilders);
         this.enclosedTypes = toUnmodifiableEnclosedTypes(enclosedGenTypeBuilders, enclosedGenTOBuilders);
+        this.properties = toUnmodifiableProperties(propertyBuilders);
         this.isAbstract = isAbstract;
+
     }
 
     private List<GeneratedType> toUnmodifiableEnclosedTypes(final List<GeneratedTypeBuilder> enclosedGenTypeBuilders,
             final List<GeneratedTOBuilder> enclosedGenTOBuilders) {
-        final List<GeneratedType> enclosedTypes = new ArrayList<>();
+        final List<GeneratedType> enclosedTypesList = new ArrayList<>();
         for (final GeneratedTypeBuilder builder : enclosedGenTypeBuilders) {
             if (builder != null) {
-                enclosedTypes.add(builder.toInstance());
+                enclosedTypesList.add(builder.toInstance());
             }
         }
 
         for (final GeneratedTOBuilder builder : enclosedGenTOBuilders) {
             if (builder != null) {
-                enclosedTypes.add(builder.toInstance());
+                enclosedTypesList.add(builder.toInstance());
             }
         }
-        return enclosedTypes;
+        return enclosedTypesList;
     }
 
-    protected List<AnnotationType> toUnmodifiableAnnotations(final List<AnnotationTypeBuilder> annotationBuilders) {
-        final List<AnnotationType> annotations = new ArrayList<>();
+    protected final List<AnnotationType> toUnmodifiableAnnotations(final List<AnnotationTypeBuilder> annotationBuilders) {
+        final List<AnnotationType> annotationList = new ArrayList<>();
         for (final AnnotationTypeBuilder builder : annotationBuilders) {
-            annotations.add(builder.toInstance());
+            annotationList.add(builder.toInstance());
         }
-        return Collections.unmodifiableList(annotations);
+        return Collections.unmodifiableList(annotationList);
     }
 
-    protected List<MethodSignature> toUnmodifiableMethods(List<MethodSignatureBuilder> methodBuilders) {
+    protected final List<MethodSignature> toUnmodifiableMethods(List<MethodSignatureBuilder> methodBuilders) {
         final List<MethodSignature> methods = new ArrayList<>();
         for (final MethodSignatureBuilder methodBuilder : methodBuilders) {
             methods.add(methodBuilder.toInstance(this));
@@ -77,7 +107,7 @@ abstract class AbstractGeneratedType extends AbstractBaseType implements Generat
         return Collections.unmodifiableList(methods);
     }
 
-    protected List<Enumeration> toUnmodifiableEnumerations(List<EnumBuilder> enumBuilders) {
+    protected final List<Enumeration> toUnmodifiableEnumerations(List<EnumBuilder> enumBuilders) {
         final List<Enumeration> enums = new ArrayList<>();
         for (final EnumBuilder enumBuilder : enumBuilders) {
             enums.add(enumBuilder.toInstance(this));
@@ -85,51 +115,64 @@ abstract class AbstractGeneratedType extends AbstractBaseType implements Generat
         return Collections.unmodifiableList(enums);
     }
 
+    protected final List<GeneratedProperty> toUnmodifiableProperties(List<GeneratedPropertyBuilder> methodBuilders) {
+        final List<GeneratedProperty> methods = new ArrayList<>();
+        for (final GeneratedPropertyBuilder methodBuilder : methodBuilders) {
+            methods.add(methodBuilder.toInstance(this));
+        }
+        return Collections.unmodifiableList(methods);
+    }
+
     @Override
-    public Type getParentType() {
+    public final Type getParentType() {
         return parent;
     }
 
     @Override
-    public String getComment() {
+    public final String getComment() {
         return comment;
     }
 
     @Override
-    public List<AnnotationType> getAnnotations() {
+    public final List<AnnotationType> getAnnotations() {
         return annotations;
     }
 
     @Override
-    public boolean isAbstract() {
+    public final boolean isAbstract() {
         return isAbstract;
     }
 
     @Override
-    public List<Type> getImplements() {
+    public final List<Type> getImplements() {
         return implementsTypes;
     }
 
     @Override
-    public List<GeneratedType> getEnclosedTypes() {
+    public final List<GeneratedType> getEnclosedTypes() {
         return enclosedTypes;
     }
 
     @Override
-    public List<Enumeration> getEnumerations() {
+    public final List<Enumeration> getEnumerations() {
         return enumerations;
     }
 
     @Override
-    public List<Constant> getConstantDefinitions() {
+    public final List<Constant> getConstantDefinitions() {
         return constants;
     }
 
     @Override
-    public List<MethodSignature> getMethodDefinitions() {
+    public final List<MethodSignature> getMethodDefinitions() {
         return methodSignatures;
     }
 
+    @Override
+    public final List<GeneratedProperty> getProperties() {
+        return properties;
+    }
+
     @Override
     public String toString() {
         StringBuilder builder = new StringBuilder();