Use QName.withModule()

[mdsal.git] / binding / mdsal-binding-generator-impl / src / main / java / org / opendaylight / mdsal / binding / generator / impl / AbstractTypeGenerator.java

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 e7ac3f0602367fe3b2405bccdfda12deca02dca8..970bece0190e935269b6c040ad0a71d65ca1f1e7 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
@@ -520,7 +520,7 @@ abstract class AbstractTypeGenerator {
 
                 addComment(listenerInterface.addMethod("on" + notificationInterface.getName())
                     .setAccessModifier(AccessModifier.PUBLIC).addParameter(notificationInterface, "notification")
-                    .setReturnType(Types.VOID), notification);
+                    .setReturnType(Types.primitiveVoidType()), notification);
             }
         }
 
@@ -569,21 +569,21 @@ abstract class AbstractTypeGenerator {
         if (identity == null) {
             return;
         }
-        final GeneratedTOBuilder newType = typeProvider.newGeneratedTOBuilder(JavaTypeName.create(
+        final GeneratedTypeBuilder newType = typeProvider.newGeneratedTypeBuilder(JavaTypeName.create(
             packageNameForGeneratedType(context.modulePackageName(), identity.getPath()),
             BindingMapping.getClassName(identity.getQName())));
         final Set<IdentitySchemaNode> baseIdentities = identity.getBaseIdentities();
         if (baseIdentities.isEmpty()) {
             final GeneratedTOBuilder gto = typeProvider.newGeneratedTOBuilder(JavaTypeName.create(BaseIdentity.class));
-            newType.setExtendsType(gto.build());
+            newType.addImplementsType(gto.build());
         } else {
-            final IdentitySchemaNode baseIdentity = baseIdentities.iterator().next();
-            final QName qname = baseIdentity.getQName();
-            final GeneratedTransferObject gto = typeProvider.newGeneratedTOBuilder(JavaTypeName.create(
-                BindingMapping.getRootPackageName(qname.getModule()), BindingMapping.getClassName(qname))).build();
-            newType.setExtendsType(gto);
+            for (IdentitySchemaNode baseIdentity : baseIdentities) {
+                final QName qname = baseIdentity.getQName();
+                final GeneratedTransferObject gto = typeProvider.newGeneratedTOBuilder(JavaTypeName.create(
+                    BindingMapping.getRootPackageName(qname.getModule()), BindingMapping.getClassName(qname))).build();
+                newType.addImplementsType(gto);
+            }
         }
-        newType.setAbstract(true);
 
         final Module module = context.module();
         addCodegenInformation(newType, module, identity);
@@ -802,7 +802,7 @@ abstract class AbstractTypeGenerator {
         SchemaNode result = targetGrouping;
         for (final QName node : targetPath.getPathFromRoot()) {
             if (result instanceof DataNodeContainer) {
-                final QName resultNode = QName.create(result.getQName().getModule(), node.getLocalName());
+                final QName resultNode = node.withModule(result.getQName().getModule());
                 result = ((DataNodeContainer) result).getDataChildByName(resultNode);
             } else if (result instanceof ChoiceSchemaNode) {
                 result = findNamedCase((ChoiceSchemaNode) result, node.getLocalName());
@@ -1257,7 +1257,7 @@ abstract class AbstractTypeGenerator {
             final List<PatternConstraint> patternConstraints) {
         if (!patternConstraints.isEmpty()) {
             final StringBuilder field = new StringBuilder().append(TypeConstants.PATTERN_CONSTANT_NAME).append("_")
-                .append(BindingMapping.getPropertyName(leafName).toUpperCase());
+                .append(BindingMapping.getPropertyName(leafName));
             typeBuilder.addConstant(Types.listTypeFor(BaseYangTypes.STRING_TYPE), field.toString(),
                 typeProvider.resolveRegExpressions(patternConstraints));
         }
@@ -1303,10 +1303,13 @@ abstract class AbstractTypeGenerator {
                 }
                 typeProvider.putReferencedType(leaf.getPath(), returnType);
             } else if (typeDef instanceof UnionTypeDefinition) {
-                final UnionTypeDefinition unionDef = (UnionTypeDefinition)typeDef;
-                returnType = addTOToTypeBuilder(unionDef, typeBuilder, leaf, parentModule);
-                // Store the inner type within the union so that we can find the reference for it
-                context.addInnerTypedefType(typeDef.getPath(), returnType);
+                GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder((UnionTypeDefinition) typeDef, typeBuilder, leaf,
+                    parentModule);
+                if (genTOBuilder != null) {
+                    returnType = createReturnTypeForUnion(genTOBuilder, typeDef, typeBuilder, parentModule);
+                    // 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);
@@ -1509,8 +1512,11 @@ abstract class AbstractTypeGenerator {
                 returnType = new ReferencedTypeImpl(enumBuilder.getIdentifier());
                 typeProvider.putReferencedType(node.getPath(), returnType);
             } else if (typeDef instanceof UnionTypeDefinition) {
-                final UnionTypeDefinition unionDef = (UnionTypeDefinition)typeDef;
-                returnType = addTOToTypeBuilder(unionDef, typeBuilder, node, parentModule);
+                final GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder((UnionTypeDefinition)typeDef, typeBuilder,
+                    node, parentModule);
+                if (genTOBuilder != null) {
+                    returnType = createReturnTypeForUnion(genTOBuilder, typeDef, typeBuilder, parentModule);
+                }
             } else if (typeDef instanceof BitsTypeDefinition) {
                 final GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder((BitsTypeDefinition)typeDef, typeBuilder,
                     node, parentModule);
@@ -1531,25 +1537,41 @@ abstract class AbstractTypeGenerator {
         return true;
     }
 
-    private Type createReturnTypeForUnion(final GeneratedTOBuilder genTOBuilder, final UnionTypeDefinition typeDef,
+    private Type createReturnTypeForUnion(final GeneratedTOBuilder genTOBuilder, final TypeDefinition<?> typeDef,
             final GeneratedTypeBuilder typeBuilder, final Module parentModule) {
-        final GeneratedTOBuilder returnTypeBuilder = typeProvider.newGeneratedTOBuilder(genTOBuilder.getIdentifier());
-        returnTypeBuilder.setIsUnion(true);
-        addCodegenInformation(returnTypeBuilder, parentModule, typeDef);
-        returnTypeBuilder.setSchemaPath(typeDef.getPath());
-        returnTypeBuilder.setModuleName(parentModule.getName());
-        final GeneratedTransferObject returnType = returnTypeBuilder.build();
+        final GeneratedTOBuilder returnType = typeProvider.newGeneratedTOBuilder(genTOBuilder.getIdentifier());
+
+        addCodegenInformation(returnType, parentModule, typeDef);
+        returnType.setSchemaPath(typeDef.getPath());
+        returnType.setModuleName(parentModule.getName());
 
         genTOBuilder.setTypedef(true);
         genTOBuilder.setIsUnion(true);
         AbstractTypeProvider.addUnitsToGenTO(genTOBuilder, typeDef.getUnits().orElse(null));
 
-        createUnionBuilder(genTOBuilder, typeBuilder, returnType, parentModule);
-        return returnType;
+
+
+        final GeneratedTOBuilder unionBuilder = createUnionBuilder(genTOBuilder, typeBuilder);
+
+
+        final MethodSignatureBuilder method = unionBuilder.addMethod("getDefaultInstance");
+        method.setReturnType(returnType);
+        method.addParameter(Types.STRING, "defaultValue");
+        method.setAccessModifier(AccessModifier.PUBLIC);
+        method.setStatic(true);
+
+        final Set<Type> types = typeProvider.getAdditionalTypes().get(parentModule);
+        if (types == null) {
+            typeProvider.getAdditionalTypes().put(parentModule,
+                    Sets.newHashSet(unionBuilder.build()));
+        } else {
+            types.add(unionBuilder.build());
+        }
+        return returnType.build();
     }
 
-    private void createUnionBuilder(final GeneratedTOBuilder genTOBuilder, final GeneratedTypeBuilder typeBuilder,
-            final GeneratedTransferObject returnType, final Module parentModule) {
+    private GeneratedTOBuilder createUnionBuilder(final GeneratedTOBuilder genTOBuilder,
+            final GeneratedTypeBuilder typeBuilder) {
         final StringBuilder sb = new StringBuilder();
 
         // Append enclosing path hierarchy without dots
@@ -1573,20 +1595,7 @@ abstract class AbstractTypeGenerator {
         final GeneratedTOBuilder unionBuilder = typeProvider.newGeneratedTOBuilder(
             JavaTypeName.create(typeBuilder.getPackageName(), sb.toString()));
         unionBuilder.setIsUnionBuilder(true);
-
-        final MethodSignatureBuilder method = unionBuilder.addMethod("getDefaultInstance");
-        method.setReturnType(returnType);
-        method.addParameter(Types.STRING, "defaultValue");
-        method.setAccessModifier(AccessModifier.PUBLIC);
-        method.setStatic(true);
-
-        final GeneratedTransferObject unionBuilderType = unionBuilder.build();
-        final Set<Type> types = typeProvider.getAdditionalTypes().get(parentModule);
-        if (types == null) {
-            typeProvider.getAdditionalTypes().put(parentModule, Sets.newHashSet(unionBuilderType));
-        } else {
-            types.add(unionBuilderType);
-        }
+        return unionBuilder;
     }
 
     private GeneratedTypeBuilder addDefaultInterfaceDefinition(final ModuleContext context,
@@ -1600,6 +1609,7 @@ abstract class AbstractTypeGenerator {
         return addDefaultInterfaceDefinition(packageName, schemaNode, childOf, context);
     }
 
+
     /**
      * Instantiates generated type builder with <code>packageName</code> and
      * <code>schemaNode</code>.
@@ -1896,7 +1906,7 @@ abstract class AbstractTypeGenerator {
      *            parent module
      * @return generated TO builder for <code>typeDef</code>
      */
-    private Type addTOToTypeBuilder(final UnionTypeDefinition typeDef,
+    private GeneratedTOBuilder addTOToTypeBuilder(final UnionTypeDefinition typeDef,
             final GeneratedTypeBuilder typeBuilder, final DataSchemaNode leaf, final Module parentModule) {
         final List<GeneratedTOBuilder> types = typeProvider.provideGeneratedTOBuildersForUnionTypeDef(
             typeBuilder.getIdentifier().createEnclosed(BindingMapping.getClassName(leaf.getQName())),
@@ -1905,17 +1915,17 @@ 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);
-
-        for (GeneratedTOBuilder builder : types) {
-            if (builder.isUnion()) {
-                final GeneratedTransferObject type = builder.build();
-                createUnionBuilder(builder, typeBuilder, type, parentModule);
-            }
+        for (final GeneratedTOBuilder genTOBuilder : types) {
+            resultTOBuilder.addEnclosingTransferObject(genTOBuilder);
         }
 
-        return createReturnTypeForUnion(resultTOBuilder, typeDef, typeBuilder, parentModule);
+        final GeneratedPropertyBuilder genPropBuilder = resultTOBuilder.addProperty("value");
+        genPropBuilder.setReturnType(Types.CHAR_ARRAY);
+        resultTOBuilder.addEqualsIdentity(genPropBuilder);
+        resultTOBuilder.addHashIdentity(genPropBuilder);
+        resultTOBuilder.addToStringProperty(genPropBuilder);
+        processEnclosedTOBuilderes(typeBuilder, genTOBuilders);
+        return resultTOBuilder;
     }
 
     /**
@@ -1948,6 +1958,14 @@ abstract class AbstractTypeGenerator {
 
     }
 
+    private static GeneratedTOBuilder processEnclosedTOBuilderes(final GeneratedTypeBuilder typeBuilder,
+            final List<GeneratedTOBuilder> genTOBuilders) {
+        for (final GeneratedTOBuilder genTOBuilder : genTOBuilders) {
+            typeBuilder.addEnclosingTransferObject(genTOBuilder);
+        }
+        return genTOBuilders.get(0);
+    }
+
     /**
      * Adds the implemented types to type builder.
      *