Cleanup GeneratedTypeBuilder/enclosing mechanics

Rather than requiring a Builder to enclose types, use an already-built
type. This allows splitting out the product phases.

Change-Id: I8bcebb1a010272eadd065cff465d16bbc5992043
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>

diff --git a/binding/mdsal-binding-generator-api/src/main/java/org/opendaylight/mdsal/binding/model/api/type/builder/GeneratedTypeBuilderBase.java b/binding/mdsal-binding-generator-api/src/main/java/org/opendaylight/mdsal/binding/model/api/type/builder/GeneratedTypeBuilderBase.java
index 646175b5cc03c0930b3b682e9bc7a4042f68b30c..2fa39c014187e3e72350a2edbad2422c77273490 100644 (file)
--- a/binding/mdsal-binding-generator-api/src/main/java/org/opendaylight/mdsal/binding/model/api/type/builder/GeneratedTypeBuilderBase.java
+++ b/binding/mdsal-binding-generator-api/src/main/java/org/opendaylight/mdsal/binding/model/api/type/builder/GeneratedTypeBuilderBase.java
@@ -11,26 +11,14 @@ import java.util.List;
 import java.util.Optional;
 import org.eclipse.jdt.annotation.NonNull;
 import org.opendaylight.mdsal.binding.model.api.Constant;
+import org.opendaylight.mdsal.binding.model.api.Enumeration;
+import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
 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.yangtools.yang.model.api.SchemaPath;
 
 public interface GeneratedTypeBuilderBase<T extends GeneratedTypeBuilderBase<T>> extends Type, AnnotableTypeBuilder {
-    /**
-     * Adds new Enclosing Transfer Object into definition of Generated Type and returns <code>new</code> Instance
-     * of Generated TO Builder.<br>
-     * There is no need of specifying of Package Name because enclosing Type is already defined inside Generated Type
-     * with specific package name.<br>
-     * The name of enclosing Type cannot be same as Name of parent type and if there is already defined enclosing type
-     * with the same name, the new enclosing type will simply overwrite the older definition.<br>
-     * If the name of enclosing type is <code>null</code> the method SHOULD throw {@link IllegalArgumentException}.
-     *
-     * @param name Name of Enclosing Type
-     * @return <code>new</code> Instance of Generated Type Builder.
-     */
-    GeneratedTOBuilder addEnclosingTransferObject(String name);
-
     /**
      * Adds new Enclosing Transfer Object <code>genTOBuilder</code> into definition of Generated Type.
      *
@@ -42,9 +30,9 @@ public interface GeneratedTypeBuilderBase<T extends GeneratedTypeBuilderBase<T>>
      * If the parameter <code>genTOBuilder</code> of enclosing type is <code>null</code> the method SHOULD throw
      * {@link IllegalArgumentException}.
      *
-     * @param genTOBuilder Name of Enclosing Type
+     * @param genTO Name of Enclosing Type
      */
-    T addEnclosingTransferObject(GeneratedTOBuilder genTOBuilder);
+    T addEnclosingTransferObject(GeneratedTransferObject genTO);
 
     /**
      * Adds String definition of comment into Method Signature definition.<br>
@@ -95,10 +83,9 @@ public interface GeneratedTypeBuilderBase<T extends GeneratedTypeBuilderBase<T>>
      * Name of Enumeration cannot be <code>null</code>, if it is <code>null</code> the method SHOULD throw
      * {@link IllegalArgumentException}.
      *
-     * @param name Enumeration Name
-     * @return <code>new</code> instance of Enumeration Builder.
+     * @param enumeration Enumeration to add
      */
-    EnumBuilder addEnumeration(String name);
+    void addEnumeration(Enumeration enumeration);
 
     List<MethodSignatureBuilder> getMethodDefinitions();
 

diff --git a/binding/mdsal-binding-generator-impl/src/main/java/org/opendaylight/mdsal/binding/generator/impl/AbstractTypeGenerator.java b/binding/mdsal-binding-generator-impl/src/main/java/org/opendaylight/mdsal/binding/generator/impl/AbstractTypeGenerator.java
index cb50ded0b35fd6f60419763377eea9a4be74d3b9..755a500ce580dd04c95226acf7e5824a0c8b3d96 100644 (file)
--- a/binding/mdsal-binding-generator-impl/src/main/java/org/opendaylight/mdsal/binding/generator/impl/AbstractTypeGenerator.java
+++ b/binding/mdsal-binding-generator-impl/src/main/java/org/opendaylight/mdsal/binding/generator/impl/AbstractTypeGenerator.java
@@ -844,10 +844,13 @@ abstract class AbstractTypeGenerator {
      */
     private Enumeration resolveInnerEnumFromTypeDefinition(final EnumTypeDefinition enumTypeDef, final QName enumName,
             final GeneratedTypeBuilder typeBuilder, final ModuleContext context) {
-        final EnumBuilder enumBuilder = typeBuilder.addEnumeration(BindingMapping.getClassName(enumName));
+        final EnumBuilder enumBuilder = typeProvider.newEnumerationBuilder(typeBuilder.getIdentifier()
+            .createEnclosed(BindingMapping.getClassName(enumName), "$"));
         typeProvider.addEnumDescription(enumBuilder, enumTypeDef);
         enumBuilder.updateEnumPairsFromEnumTypeDef(enumTypeDef);
         final Enumeration ret = enumBuilder.toInstance();
+        typeBuilder.addEnumeration(ret);
+
         context.addTypeToSchema(ret, enumTypeDef);
         context.addInnerTypedefType(enumTypeDef.getPath(), ret);
         return ret;
@@ -1604,11 +1607,7 @@ abstract class AbstractTypeGenerator {
                 // Store the inner type within the union so that we can find the reference for it
                 context.addInnerTypedefType(typeDef.getPath(), returnType);
             } else if (typeDef instanceof BitsTypeDefinition) {
-                GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder((BitsTypeDefinition) typeDef, typeBuilder, leaf,
-                    parentModule);
-                if (genTOBuilder != null) {
-                    returnType = genTOBuilder.build();
-                }
+                returnType = addTOToTypeBuilder((BitsTypeDefinition) typeDef, typeBuilder, leaf, parentModule);
             } else {
                 // It is constrained version of already declared type (inner declared type exists, only for special
                 // cases (Enum, Union, Bits), which were already checked.
@@ -1819,9 +1818,7 @@ abstract class AbstractTypeGenerator {
                 final UnionTypeDefinition unionDef = (UnionTypeDefinition) typeDef;
                 returnType = addTOToTypeBuilder(unionDef, typeBuilder, node, parentModule);
             } else if (typeDef instanceof BitsTypeDefinition) {
-                final GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder((BitsTypeDefinition) typeDef, typeBuilder,
-                        node, parentModule);
-                returnType = genTOBuilder.build();
+                returnType = addTOToTypeBuilder((BitsTypeDefinition) typeDef, typeBuilder, node, parentModule);
             } else {
                 final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(typeDef);
                 returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, node, restrictions, inGrouping);
@@ -2117,12 +2114,12 @@ abstract class AbstractTypeGenerator {
         checkState(!types.isEmpty(), "No GeneratedTOBuilder objects generated from union %s", typeDef);
         final List<GeneratedTOBuilder> genTOBuilders = new ArrayList<>(types);
         final GeneratedTOBuilder resultTOBuilder = types.remove(0);
-        types.forEach(resultTOBuilder::addEnclosingTransferObject);
-        genTOBuilders.forEach(typeBuilder::addEnclosingTransferObject);
+        genTOBuilders.forEach(builder -> typeBuilder.addEnclosingTransferObject(builder.build()));
 
         for (GeneratedTOBuilder builder : types) {
+            final GeneratedTransferObject type = builder.build();
+            resultTOBuilder.addEnclosingTransferObject(type);
             if (builder.isUnion()) {
-                final GeneratedTransferObject type = builder.build();
                 createUnionBuilder(builder, typeBuilder, type, parentModule);
             }
         }
@@ -2142,12 +2139,13 @@ abstract class AbstractTypeGenerator {
      * @param parentModule parent module
      * @return generated TO builder for <code>typeDef</code>
      */
-    private GeneratedTOBuilder addTOToTypeBuilder(final BitsTypeDefinition typeDef,
+    private GeneratedTransferObject addTOToTypeBuilder(final BitsTypeDefinition typeDef,
             final GeneratedTypeBuilder typeBuilder, final DataSchemaNode leaf, final Module parentModule) {
-        final GeneratedTOBuilder genTOBuilder = typeProvider.provideGeneratedTOBuilderForBitsTypeDefinition(
-            allocateNestedType(typeBuilder.getIdentifier(), leaf.getQName()), typeDef, parentModule.getName());
-        typeBuilder.addEnclosingTransferObject(genTOBuilder);
-        return genTOBuilder;
+        final GeneratedTransferObject genTO = typeProvider.provideGeneratedTOBuilderForBitsTypeDefinition(
+            allocateNestedType(typeBuilder.getIdentifier(), leaf.getQName()), typeDef, parentModule.getName())
+            .build();
+        typeBuilder.addEnclosingTransferObject(genTO);
+        return genTO;
     }
 
     /**

diff --git a/binding/mdsal-binding-generator-impl/src/main/java/org/opendaylight/mdsal/binding/yang/types/AbstractTypeProvider.java b/binding/mdsal-binding-generator-impl/src/main/java/org/opendaylight/mdsal/binding/yang/types/AbstractTypeProvider.java
index 47667067a4a41c0130f2d59cde145e489b5e8aa0..e44daaef7f8951272947cfbf2b39565b7460b728 100644 (file)
--- a/binding/mdsal-binding-generator-impl/src/main/java/org/opendaylight/mdsal/binding/yang/types/AbstractTypeProvider.java
+++ b/binding/mdsal-binding-generator-impl/src/main/java/org/opendaylight/mdsal/binding/yang/types/AbstractTypeProvider.java
@@ -665,11 +665,14 @@ public abstract class AbstractTypeProvider implements TypeProvider {
                 "Local Name in EnumTypeDefinition QName cannot be NULL!");
         Preconditions.checkArgument(typeBuilder != null, "Generated Type Builder reference cannot be NULL!");
 
-        final EnumBuilder enumBuilder = typeBuilder.addEnumeration(BindingMapping.getClassName(enumName));
-
+        final EnumBuilder enumBuilder = newEnumerationBuilder(
+            typeBuilder.getIdentifier().createEnclosed(BindingMapping.getClassName(enumName), "$"));
         addEnumDescription(enumBuilder, enumTypeDef);
         enumBuilder.updateEnumPairsFromEnumTypeDef(enumTypeDef);
-        return enumBuilder.toInstance();
+        final Enumeration ret = enumBuilder.toInstance();
+        typeBuilder.addEnumeration(ret);
+
+        return ret;
     }
 
     public abstract void addEnumDescription(EnumBuilder enumBuilder, EnumTypeDefinition enumTypeDef);
@@ -893,7 +896,7 @@ public abstract class AbstractTypeProvider implements TypeProvider {
         Preconditions.checkState(!builders.isEmpty(), "No GeneratedTOBuilder objects generated from union %s", typedef);
 
         final GeneratedTOBuilder resultTOBuilder = builders.remove(0);
-        builders.forEach(resultTOBuilder::addEnclosingTransferObject);
+        builders.forEach(builder -> resultTOBuilder.addEnclosingTransferObject(builder.build()));
         return resultTOBuilder;
     }
 

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 73a1b16bbe1e470ee47cb4aabcc0f53758c46710..cc03fcf0ace88d55eca628a134c08e7312cf2675 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
@@ -50,10 +50,9 @@ abstract class AbstractGeneratedType extends AbstractBaseType implements Generat
         this.annotations = toUnmodifiableAnnotations(builder.getAnnotations());
         this.implementsTypes = makeUnmodifiable(builder.getImplementsTypes());
         this.constants = makeUnmodifiable(builder.getConstants());
-        this.enumerations = toUnmodifiableEnumerations(builder.getEnumerations());
+        this.enumerations = List.copyOf(builder.getEnumerations());
         this.methodSignatures = toUnmodifiableMethods(builder.getMethodDefinitions());
-        this.enclosedTypes = toUnmodifiableEnclosedTypes(builder.getEnclosedTypes(),
-                builder.getEnclosedTransferObjects());
+        this.enclosedTypes = List.copyOf(builder.getEnclosedTransferObjects());
         this.properties = toUnmodifiableProperties(builder.getProperties());
         this.isAbstract = builder.isAbstract();
         this.definition = builder.getYangSourceDefinition().orElse(null);

diff --git a/binding/mdsal-binding-generator-util/src/main/java/org/opendaylight/mdsal/binding/model/util/generated/type/builder/AbstractGeneratedTypeBuilder.java b/binding/mdsal-binding-generator-util/src/main/java/org/opendaylight/mdsal/binding/model/util/generated/type/builder/AbstractGeneratedTypeBuilder.java
index 28ac9a3d1edbb2f76b3437c17a6f1c7b1d9f129a..2ea6933852d24acafd66caea78e585d2c3380fb6 100644 (file)
--- a/binding/mdsal-binding-generator-util/src/main/java/org/opendaylight/mdsal/binding/model/util/generated/type/builder/AbstractGeneratedTypeBuilder.java
+++ b/binding/mdsal-binding-generator-util/src/main/java/org/opendaylight/mdsal/binding/model/util/generated/type/builder/AbstractGeneratedTypeBuilder.java
@@ -16,15 +16,14 @@ import java.util.Optional;
 import org.opendaylight.mdsal.binding.model.api.AbstractBaseType;
 import org.opendaylight.mdsal.binding.model.api.AccessModifier;
 import org.opendaylight.mdsal.binding.model.api.Constant;
+import org.opendaylight.mdsal.binding.model.api.Enumeration;
+import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
 import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
 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.GeneratedTypeBuilderBase;
 import org.opendaylight.mdsal.binding.model.api.type.builder.MethodSignatureBuilder;
 import org.opendaylight.yangtools.util.LazyCollections;
@@ -34,11 +33,10 @@ abstract class AbstractGeneratedTypeBuilder<T extends GeneratedTypeBuilderBase<T
 
     private List<AnnotationTypeBuilder> annotationBuilders = Collections.emptyList();
     private List<Type> implementsTypes = Collections.emptyList();
-    private List<EnumBuilder> enumDefinitions = Collections.emptyList();
+    private List<Enumeration> enumDefinitions = Collections.emptyList();
     private List<Constant> constants = Collections.emptyList();
     private List<MethodSignatureBuilder> methodDefinitions = Collections.emptyList();
-    private final List<GeneratedTypeBuilder> enclosedTypes = Collections.emptyList();
-    private List<GeneratedTOBuilder> enclosedTransferObjects = Collections.emptyList();
+    private List<GeneratedTransferObject> enclosedTransferObjects = Collections.emptyList();
     private List<GeneratedPropertyBuilder> properties = Collections.emptyList();
     private TypeComment comment;
     private boolean isAbstract;
@@ -66,7 +64,7 @@ abstract class AbstractGeneratedTypeBuilder<T extends GeneratedTypeBuilderBase<T
         return this.implementsTypes;
     }
 
-    protected List<EnumBuilder> getEnumerations() {
+    protected List<Enumeration> getEnumerations() {
         return this.enumDefinitions;
     }
 
@@ -79,11 +77,7 @@ abstract class AbstractGeneratedTypeBuilder<T extends GeneratedTypeBuilderBase<T
         return this.methodDefinitions;
     }
 
-    protected List<GeneratedTypeBuilder> getEnclosedTypes() {
-        return this.enclosedTypes;
-    }
-
-    protected List<GeneratedTOBuilder> getEnclosedTransferObjects() {
+    protected List<GeneratedTransferObject> getEnclosedTransferObjects() {
         return this.enclosedTransferObjects;
     }
 
@@ -92,22 +86,11 @@ abstract class AbstractGeneratedTypeBuilder<T extends GeneratedTypeBuilderBase<T
     abstract AbstractEnumerationBuilder newEnumerationBuilder(JavaTypeName identifier);
 
     @Override
-    public GeneratedTOBuilder addEnclosingTransferObject(final String name) {
-        checkArgument(name != null, "Name for Enclosing Generated Transfer Object cannot be null!");
-        final GeneratedTOBuilder builder = new CodegenGeneratedTOBuilder(getIdentifier().createEnclosed(name));
-
-        checkArgument(!enclosedTransferObjects.contains(builder),
+    public T addEnclosingTransferObject(final GeneratedTransferObject genTO) {
+        checkArgument(genTO != null, "Parameter genTO cannot be null!");
+        checkArgument(!enclosedTransferObjects.contains(genTO),
             "This generated type already contains equal enclosing transfer object.");
-        this.enclosedTransferObjects = LazyCollections.lazyAdd(this.enclosedTransferObjects, builder);
-        return builder;
-    }
-
-    @Override
-    public T addEnclosingTransferObject(final GeneratedTOBuilder genTOBuilder) {
-        checkArgument(genTOBuilder != null, "Parameter genTOBuilder cannot be null!");
-        checkArgument(!enclosedTransferObjects.contains(genTOBuilder),
-            "This generated type already contains equal enclosing transfer object.");
-        this.enclosedTransferObjects = LazyCollections.lazyAdd(this.enclosedTransferObjects, genTOBuilder);
+        this.enclosedTransferObjects = LazyCollections.lazyAdd(this.enclosedTransferObjects, genTO);
         return thisInstance();
     }
 
@@ -164,17 +147,15 @@ abstract class AbstractGeneratedTypeBuilder<T extends GeneratedTypeBuilderBase<T
     }
 
     @Override
-    public EnumBuilder addEnumeration(final String name) {
-        checkArgument(name != null, "Name of enumeration cannot be null!");
+    public void addEnumeration(final Enumeration enumeration) {
+        checkArgument(enumeration != null, "Enumeration cannot be null!");
 
         // This enumeration may be generated from a leaf, which may end up colliding with its enclosing type
         // hierarchy. If that is the case, we use a single '$' suffix to disambiguate -- that cannot come from the user
         // and hence is marking our namespace
-        final EnumBuilder builder = newEnumerationBuilder(getIdentifier().createEnclosed(name, "$"));
-        checkArgument(!enumDefinitions.contains(builder),
-            "Generated type %s already contains an enumeration for %s", this, builder);
-        this.enumDefinitions = LazyCollections.lazyAdd(this.enumDefinitions, builder);
-        return builder;
+        checkArgument(!enumDefinitions.contains(enumeration),
+            "Generated type %s already contains an enumeration for %s", this, enumeration);
+        this.enumDefinitions = LazyCollections.lazyAdd(this.enumDefinitions, enumeration);
     }
 
     @Override

diff --git a/binding/mdsal-binding-generator-util/src/main/java/org/opendaylight/mdsal/binding/model/util/generated/type/builder/CodegenGeneratedTypeBuilder.java b/binding/mdsal-binding-generator-util/src/main/java/org/opendaylight/mdsal/binding/model/util/generated/type/builder/CodegenGeneratedTypeBuilder.java
index 30d1c9969b93cf044e8ec6f4b055a19cacda1ed1..41b2cfcc04fac0de94f3e2385abad771f340c8ed 100644 (file)
--- a/binding/mdsal-binding-generator-util/src/main/java/org/opendaylight/mdsal/binding/model/util/generated/type/builder/CodegenGeneratedTypeBuilder.java
+++ b/binding/mdsal-binding-generator-util/src/main/java/org/opendaylight/mdsal/binding/model/util/generated/type/builder/CodegenGeneratedTypeBuilder.java
@@ -64,8 +64,6 @@ public final class CodegenGeneratedTypeBuilder extends AbstractGeneratedTypeBuil
         builder.append(getAnnotations());
         builder.append(", implements=");
         builder.append(getImplementsTypes());
-        builder.append(", enclosedTypes=");
-        builder.append(getEnclosedTypes());
         builder.append(", constants=");
         builder.append(getConstants());
         builder.append(", enumerations=");

diff --git a/binding/mdsal-binding-generator-util/src/main/java/org/opendaylight/mdsal/binding/model/util/generated/type/builder/RuntimeGeneratedTypeBuilder.java b/binding/mdsal-binding-generator-util/src/main/java/org/opendaylight/mdsal/binding/model/util/generated/type/builder/RuntimeGeneratedTypeBuilder.java
index fe89dbf022934c112adfdb5244ca1efaff0d7a8f..a221122a10c1e18c63a76a26b04c56d1f5f0446f 100644 (file)
--- a/binding/mdsal-binding-generator-util/src/main/java/org/opendaylight/mdsal/binding/model/util/generated/type/builder/RuntimeGeneratedTypeBuilder.java
+++ b/binding/mdsal-binding-generator-util/src/main/java/org/opendaylight/mdsal/binding/model/util/generated/type/builder/RuntimeGeneratedTypeBuilder.java
@@ -69,8 +69,6 @@ public final class RuntimeGeneratedTypeBuilder extends AbstractGeneratedTypeBuil
         builder.append(getAnnotations());
         builder.append(", implements=");
         builder.append(getImplementsTypes());
-        builder.append(", enclosedTypes=");
-        builder.append(getEnclosedTypes());
         builder.append(", constants=");
         builder.append(getConstants());
         builder.append(", enumerations=");

diff --git a/binding/mdsal-binding-generator-util/src/test/java/org/opendaylight/mdsal/binding/model/util/BindingGeneratorUtilTest.java b/binding/mdsal-binding-generator-util/src/test/java/org/opendaylight/mdsal/binding/model/util/BindingGeneratorUtilTest.java
index 556020dba4ff2d2aec3e946169bdd2877837d75d..25f8bae33d3cd508235ef1f402f6abf0634a9484 100644 (file)
--- a/binding/mdsal-binding-generator-util/src/test/java/org/opendaylight/mdsal/binding/model/util/BindingGeneratorUtilTest.java
+++ b/binding/mdsal-binding-generator-util/src/test/java/org/opendaylight/mdsal/binding/model/util/BindingGeneratorUtilTest.java
@@ -28,6 +28,7 @@ import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
 import org.opendaylight.mdsal.binding.model.api.Restrictions;
 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.generated.type.builder.CodegenGeneratedTOBuilder;
 import org.opendaylight.mdsal.binding.model.util.generated.type.builder.CodegenGeneratedTypeBuilder;
 import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
 import org.opendaylight.yangtools.yang.common.QName;
@@ -98,7 +99,8 @@ public class BindingGeneratorUtilTest {
             JavaTypeName.create("org.opendaylight.yangtools.test", "TestType"));
         genTypeBuilder.addMethod("testMethod");
         genTypeBuilder.addAnnotation("org.opendaylight.yangtools.test.annotation", "AnnotationTest");
-        genTypeBuilder.addEnclosingTransferObject("testObject");
+        genTypeBuilder.addEnclosingTransferObject(new CodegenGeneratedTOBuilder(genTypeBuilder.getIdentifier()
+            .createEnclosed("testObject")).build());
         genTypeBuilder.addProperty("newProp");
         GeneratedTypeBuilder genType = new CodegenGeneratedTypeBuilder(
             JavaTypeName.create("org.opendaylight.yangtools.test", "Type2"));

diff --git a/binding/mdsal-binding-generator-util/src/test/java/org/opendaylight/mdsal/binding/model/util/generated/type/builder/AbstractGeneratedTypeBuilderTest.java b/binding/mdsal-binding-generator-util/src/test/java/org/opendaylight/mdsal/binding/model/util/generated/type/builder/AbstractGeneratedTypeBuilderTest.java
index 713c6667ccbd0fc18662e13407e473867f7ac59a..31ad8171362a3fbb655a58c68605b5a399c0e48d 100644 (file)
--- a/binding/mdsal-binding-generator-util/src/test/java/org/opendaylight/mdsal/binding/model/util/generated/type/builder/AbstractGeneratedTypeBuilderTest.java
+++ b/binding/mdsal-binding-generator-util/src/test/java/org/opendaylight/mdsal/binding/model/util/generated/type/builder/AbstractGeneratedTypeBuilderTest.java
@@ -37,18 +37,9 @@ public class AbstractGeneratedTypeBuilderTest {
             JavaTypeName.create("my.package", "MyName"));
 
         generatedTypeBuilder.addEnclosingTransferObject(new CodegenGeneratedTOBuilder(
-            JavaTypeName.create("my.package", "myName")));
+            JavaTypeName.create("my.package", "myName")).build());
         generatedTypeBuilder.addEnclosingTransferObject(new CodegenGeneratedTOBuilder(
-            JavaTypeName.create("my.package", "myName")));
-    }
-
-    @Test(expected = IllegalArgumentException.class)
-    public void addEnclosingTransferObjectArgumentTest2() {
-        CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
-            JavaTypeName.create("my.package", "MyName"));
-
-        generatedTypeBuilder.addEnclosingTransferObject("myName");
-        generatedTypeBuilder.addEnclosingTransferObject("myName");
+            JavaTypeName.create("my.package", "myName")).build());
     }
 
     @Test(expected = IllegalArgumentException.class)
@@ -77,13 +68,4 @@ public class AbstractGeneratedTypeBuilderTest {
         generatedTypeBuilder.addAnnotation("my.package", "myName");
         generatedTypeBuilder.addAnnotation("my.package", "myName");
     }
-
-    @Test(expected = IllegalArgumentException.class)
-    public void addEnumerationIllegalArgumentTest() {
-        CodegenGeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
-            JavaTypeName.create("my.package", "MyName"));
-
-        generatedTypeBuilder.addEnumeration("myName");
-        generatedTypeBuilder.addEnumeration("myName");
-    }
 }

diff --git a/binding/mdsal-binding-generator-util/src/test/java/org/opendaylight/mdsal/binding/model/util/generated/type/builder/GeneratedTypeBuilderTest.java b/binding/mdsal-binding-generator-util/src/test/java/org/opendaylight/mdsal/binding/model/util/generated/type/builder/GeneratedTypeBuilderTest.java
index 649f23f6062d808a6642be2a90e032548b36130a..6c4980e3d9e40dad199af29794d556ec40b43dbd 100644 (file)
--- a/binding/mdsal-binding-generator-util/src/test/java/org/opendaylight/mdsal/binding/model/util/generated/type/builder/GeneratedTypeBuilderTest.java
+++ b/binding/mdsal-binding-generator-util/src/test/java/org/opendaylight/mdsal/binding/model/util/generated/type/builder/GeneratedTypeBuilderTest.java
@@ -18,6 +18,7 @@ import org.junit.Test;
 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.GeneratedTransferObject;
 import org.opendaylight.mdsal.binding.model.api.GeneratedType;
 import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
 import org.opendaylight.mdsal.binding.model.api.MethodSignature;
@@ -202,11 +203,13 @@ public class GeneratedTypeBuilderTest {
         GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
             JavaTypeName.create("my.package", "MyName"));
 
-        EnumBuilder enumBuilder = generatedTypeBuilder.addEnumeration("myEnumName");
-        EnumBuilder enumBuilder2 = generatedTypeBuilder.addEnumeration("myEnumName2");
+        EnumBuilder enumBuilder = new CodegenEnumerationBuilder(generatedTypeBuilder.getIdentifier()
+            .createEnclosed("myEnumName"));
+        EnumBuilder enumBuilder2 = new CodegenEnumerationBuilder(generatedTypeBuilder.getIdentifier()
+            .createEnclosed("myEnumName2"));
 
-        assertNotNull(enumBuilder);
-        assertNotNull(enumBuilder2);
+        generatedTypeBuilder.addEnumeration(enumBuilder.toInstance());
+        generatedTypeBuilder.addEnumeration(enumBuilder2.toInstance());
 
         GeneratedType instance = generatedTypeBuilder.build();
         List<Enumeration> enumerations = instance.getEnumerations();
@@ -244,16 +247,10 @@ public class GeneratedTypeBuilderTest {
         assertFalse(implementTypes.contains(Types.typeForClass(Throwable.class)));
     }
 
-    @Test(expected = IllegalArgumentException.class)
-    public void addEnclosingTransferObjectIllegalArgumentTest() {
-        new CodegenGeneratedTypeBuilder(JavaTypeName.create("my.package", "MyName")).addEnclosingTransferObject(
-            (String) null);
-    }
-
     @Test(expected = IllegalArgumentException.class)
     public void addEnclosingTransferObjectIllegalArgumentTest2() {
         new CodegenGeneratedTypeBuilder(JavaTypeName.create("my.package", "MyName")).addEnclosingTransferObject(
-            (GeneratedTOBuilder) null);
+            (GeneratedTransferObject) null);
     }
 
     @Test
@@ -261,14 +258,16 @@ public class GeneratedTypeBuilderTest {
         GeneratedTypeBuilder generatedTypeBuilder = new CodegenGeneratedTypeBuilder(
             JavaTypeName.create("my.package", "MyName"));
 
-        GeneratedTOBuilder enclosingTransferObject = generatedTypeBuilder.addEnclosingTransferObject("myTOName");
-        GeneratedTOBuilder enclosingTransferObject2 = generatedTypeBuilder.addEnclosingTransferObject("myTOName2");
-        assertEquals(generatedTypeBuilder, generatedTypeBuilder.addEnclosingTransferObject(
-            new CodegenGeneratedTOBuilder(generatedTypeBuilder.getIdentifier().createEnclosed("myTOName3"))));
-
-        assertNotNull(enclosingTransferObject);
-        assertNotNull(enclosingTransferObject2);
+        GeneratedTOBuilder enclosingTransferObject = new CodegenGeneratedTOBuilder(generatedTypeBuilder.getIdentifier()
+            .createEnclosed("myTOName"));
+        GeneratedTOBuilder enclosingTransferObject2 = new CodegenGeneratedTOBuilder(generatedTypeBuilder.getIdentifier()
+            .createEnclosed("myTOName2"));
+        GeneratedTOBuilder enclosingTransferObject3 = new CodegenGeneratedTOBuilder(generatedTypeBuilder.getIdentifier()
+            .createEnclosed("myTOName3"));
 
+        generatedTypeBuilder.addEnclosingTransferObject(enclosingTransferObject.build());
+        generatedTypeBuilder.addEnclosingTransferObject(enclosingTransferObject2.build());
+        generatedTypeBuilder.addEnclosingTransferObject(enclosingTransferObject3.build());
         GeneratedType instance = generatedTypeBuilder.build();
         List<GeneratedType> enclosedTypes = instance.getEnclosedTypes();
 
@@ -276,8 +275,7 @@ public class GeneratedTypeBuilderTest {
 
         assertTrue(enclosedTypes.contains(enclosingTransferObject.build()));
         assertTrue(enclosedTypes.contains(enclosingTransferObject2.build()));
-        assertTrue(enclosedTypes.contains(new CodegenGeneratedTOBuilder(
-            generatedTypeBuilder.getIdentifier().createEnclosed("myTOName3")).build()));
+        assertTrue(enclosedTypes.contains(enclosingTransferObject3.build()));
         assertFalse(enclosedTypes.contains(new CodegenGeneratedTOBuilder(
             generatedTypeBuilder.getIdentifier().createEnclosed("myTOName4")).build()));
     }
@@ -295,7 +293,7 @@ public class GeneratedTypeBuilderTest {
 
         assertEquals(
                 "GeneratedTransferObject [packageName=my.package, name=MyName, comment=My comment.., annotations=[], "
-                        + "implements=[], enclosedTypes=[], constants=[], enumerations=[], properties=, methods=[]]",
+                        + "implements=[], constants=[], enumerations=[], properties=, methods=[]]",
                         generatedTypeBuilder.toString());
 
         GeneratedType instance = generatedTypeBuilder.build();

diff --git a/binding/mdsal-binding-java-api-generator/src/main/java/org/opendaylight/mdsal/binding/java/api/generator/BuilderGenerator.java b/binding/mdsal-binding-java-api-generator/src/main/java/org/opendaylight/mdsal/binding/java/api/generator/BuilderGenerator.java
index e8399a9672e83f143a33ced3fabc7148afd3bbe4..f7f8ca1b117c79cc326dd47d742d3713d0afa65b 100644 (file)
--- a/binding/mdsal-binding-java-api-generator/src/main/java/org/opendaylight/mdsal/binding/java/api/generator/BuilderGenerator.java
+++ b/binding/mdsal-binding-java-api-generator/src/main/java/org/opendaylight/mdsal/binding/java/api/generator/BuilderGenerator.java
@@ -14,8 +14,7 @@ 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.type.builder.GeneratedTOBuilder;
-import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
+import org.opendaylight.mdsal.binding.model.util.generated.type.builder.CodegenGeneratedTOBuilder;
 import org.opendaylight.mdsal.binding.model.util.generated.type.builder.CodegenGeneratedTypeBuilder;
 import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
 import org.opendaylight.yangtools.yang.binding.Augmentable;
@@ -69,15 +68,14 @@ public final class BuilderGenerator implements CodeGenerator {
     @VisibleForTesting
     static BuilderTemplate templateForType(final GeneratedType type) {
         final JavaTypeName origName = type.getIdentifier();
+        final JavaTypeName builderName = origName.createSibling(origName.simpleName() + BuilderTemplate.BUILDER_STR);
 
-        final GeneratedTypeBuilder builderTypeBuilder = new CodegenGeneratedTypeBuilder(
-            origName.createSibling(origName.simpleName() + BuilderTemplate.BUILDER_STR));
-
-        final GeneratedTOBuilder implTypeBuilder = builderTypeBuilder.addEnclosingTransferObject(
-            origName.simpleName() + "Impl");
-        implTypeBuilder.addImplementsType(type);
-
-        return new BuilderTemplate(builderTypeBuilder.build(), type, getKey(type));
+        return new BuilderTemplate(new CodegenGeneratedTypeBuilder(builderName)
+            .addEnclosingTransferObject(new CodegenGeneratedTOBuilder(
+                builderName.createEnclosed(origName.simpleName() + "Impl"))
+                .addImplementsType(type)
+                .build())
+            .build(), type, getKey(type));
     }
 
     private static Type getKey(final GeneratedType type) {