Binding generator v2 - namespace fix #2

- fix namespace of data type in grouping namespace

- add suffix "Grouping" for grouping type name
        & "Data" for data type name

TODO #3 - support generate type from uses grouping

Change-Id: I1e59929169eb13bcba75de61770525d35213b524
Signed-off-by: Jie Han <han.jie@zte.com.cn>
(cherry picked from commit 58d35f538fe48fd71df99cc0e901da92634357a2)

diff --git a/binding2/mdsal-binding2-generator-impl/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/impl/AugmentToGenType.java b/binding2/mdsal-binding2-generator-impl/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/impl/AugmentToGenType.java
index 2dc6ccdfdb66ed439da3bf2f5ebcc7e093e0c12d..aec35db00d256efaf42efbb77c9179ea57cb2f0b 100644 (file)
--- a/binding2/mdsal-binding2-generator-impl/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/impl/AugmentToGenType.java
+++ b/binding2/mdsal-binding2-generator-impl/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/impl/AugmentToGenType.java
@@ -139,7 +139,7 @@ final class AugmentToGenType {
 
             for (AugmentationSchema augSchema : schemaPathAugmentListEntry.getValue()) {
                 GenHelperUtil.processUsesAugments(schemaContext, augSchema, module, genCtx,
-                        genTypeBuilders, verboseClassComments, typeProvider);
+                        genTypeBuilders, verboseClassComments, typeProvider, BindingNamespaceType.Data);
             }
 
         }
@@ -241,12 +241,13 @@ final class AugmentToGenType {
         if (!(targetSchemaNode instanceof ChoiceSchemaNode)) {
             genCtx = GenHelperUtil.addRawAugmentGenTypeDefinition(module, augmentNamespacePackageName,
                     targetTypeBuilder.toInstance(), schemaPathAugmentListEntry.getValue(), genTypeBuilders, genCtx,
-                    schemaContext, verboseClassComments, typeProvider);
+                    schemaContext, verboseClassComments, typeProvider, BindingNamespaceType.Data);
         } else {
             genCtx = generateTypesFromAugmentedChoiceCases(schemaContext, module, basePackageName,
                     targetTypeBuilder.toInstance(), (ChoiceSchemaNode) targetSchemaNode,
                     schemaPathAugmentListEntry.getValue(),
-                    null, genCtx, verboseClassComments, genTypeBuilders, typeProvider);
+                    null, genCtx, verboseClassComments, genTypeBuilders, typeProvider,
+                    BindingNamespaceType.Data);
         }
         return genCtx;
     }
@@ -255,7 +256,7 @@ final class AugmentToGenType {
            final String augmentPackageName, final List<AugmentationSchema> schemaPathAugmentListEntry, final Module module,
            final UsesNode usesNode, final DataNodeContainer usesNodeParent, Map<Module, ModuleContext> genCtx,
            Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final boolean verboseClassComments,
-           final TypeProvider typeProvider) {
+           final TypeProvider typeProvider, final BindingNamespaceType namespaceType) {
 
         Preconditions.checkArgument(augmentPackageName != null, "Package Name cannot be NULL.");
         Preconditions.checkArgument(schemaPathAugmentListEntry != null,
@@ -294,13 +295,13 @@ final class AugmentToGenType {
             }
             genCtx = GenHelperUtil.addRawAugmentGenTypeDefinition(module, packageName,
                     targetTypeBuilder.toInstance(), schemaPathAugmentListEntry, genTypeBuilders, genCtx,
-                    schemaContext, verboseClassComments, typeProvider);
+                    schemaContext, verboseClassComments, typeProvider, namespaceType);
             return genCtx;
         } else {
             genCtx = generateTypesFromAugmentedChoiceCases(schemaContext, module, augmentPackageName,
                     targetTypeBuilder.toInstance(), (ChoiceSchemaNode) targetSchemaNode,
                     schemaPathAugmentListEntry,
-                    usesNodeParent, genCtx, verboseClassComments, genTypeBuilders, typeProvider);
+                    usesNodeParent, genCtx, verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
             return genCtx;
         }
     }
@@ -408,7 +409,8 @@ final class AugmentToGenType {
             final List<AugmentationSchema> schemaPathAugmentListEntry,
             final DataNodeContainer usesNodeParent,
             Map<Module, ModuleContext> genCtx, final boolean verboseClassComments,
-            Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider) {
+            Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider,
+            final BindingNamespaceType namespaceType) {
         Preconditions.checkArgument(basePackageName != null, "Base Package Name cannot be NULL.");
         Preconditions.checkArgument(targetType != null, "Referenced Choice Type cannot be NULL.");
         Preconditions.checkArgument(schemaPathAugmentListEntry != null, "Set of Choice Case Nodes cannot be NULL.");
@@ -420,7 +422,8 @@ final class AugmentToGenType {
                     final String packageName = BindingGeneratorUtil.packageNameForGeneratedType(basePackageName,
                             caseNode.getPath(), BindingNamespaceType.Data);
                     final GeneratedTypeBuilder caseTypeBuilder = GenHelperUtil.addDefaultInterfaceDefinition(packageName,
-                            caseNode, module, genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider);
+                            caseNode, module, genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider,
+                            namespaceType);
                     caseTypeBuilder.addImplementsType(targetType);
 
                     SchemaNode parent;
@@ -461,7 +464,8 @@ final class AugmentToGenType {
                     final Iterable<DataSchemaNode> childNodes = node.getChildNodes();
                     if (childNodes != null) {
                         GenHelperUtil.resolveDataSchemaNodes(module, basePackageName, caseTypeBuilder, childOfType,
-                                childNodes, genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider);
+                                childNodes, genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider,
+                                namespaceType);
                     }
                     genCtx.get(module).addCaseType(caseNode.getPath(), caseTypeBuilder);
                     genCtx.get(module).addChoiceToCaseMapping(targetType, caseTypeBuilder, node);

diff --git a/binding2/mdsal-binding2-generator-impl/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/impl/GenHelperUtil.java b/binding2/mdsal-binding2-generator-impl/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/impl/GenHelperUtil.java
index 220c7b6b4a7d284cbebccbe8ba46bafbf5b4002e..d705c27c38bc69c8eb7973b0c802954932ed0708 100644 (file)
--- a/binding2/mdsal-binding2-generator-impl/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/impl/GenHelperUtil.java
+++ b/binding2/mdsal-binding2-generator-impl/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/impl/GenHelperUtil.java
@@ -228,13 +228,13 @@ final class GenHelperUtil {
                           final Iterable<DataSchemaNode> schemaNodes, final Map<Module, ModuleContext> genCtx,
                           final SchemaContext schemaContext, final boolean verboseClassComments,
                           final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders,
-                          final TypeProvider typeProvider) {
+                          final TypeProvider typeProvider, final BindingNamespaceType namespaceType) {
 
         if (schemaNodes != null && parent != null) {
             for (final DataSchemaNode schemaNode : schemaNodes) {
-                if (!schemaNode.isAugmenting() && !schemaNode.isAddedByUses()) {
+                if (!schemaNode.isAugmenting()) {
                     addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode, parent, childOf, module, genCtx,
-                            schemaContext, verboseClassComments, genTypeBuilders, typeProvider);
+                            schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
                 }
             }
         }
@@ -244,15 +244,16 @@ final class GenHelperUtil {
     static GeneratedTypeBuilder addDefaultInterfaceDefinition(final String packageName, final SchemaNode
             schemaNode, final Module module, final Map<Module, ModuleContext> genCtx, final SchemaContext schemaContext,
             final boolean verboseClassComments, final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders,
-            final TypeProvider typeProvider) {
+            final TypeProvider typeProvider, final BindingNamespaceType namespaceType) {
         return addDefaultInterfaceDefinition(packageName, schemaNode, null, module, genCtx, schemaContext,
-                verboseClassComments, genTypeBuilders, typeProvider);
+                verboseClassComments, genTypeBuilders, typeProvider , namespaceType);
     }
 
     static Map<Module, ModuleContext> processUsesAugments(final SchemaContext schemaContext, final
                         DataNodeContainer node, final Module module, Map<Module, ModuleContext> genCtx,
                         final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders,
-                        final boolean verboseClassComments, final TypeProvider typeProvider) {
+                        final boolean verboseClassComments, final TypeProvider typeProvider,
+                        final BindingNamespaceType namespaceType) {
         final String basePackageName = BindingMapping.getRootPackageName(module);
         for (final UsesNode usesNode : node.getUses()) {
             Map<SchemaPath, List<AugmentationSchema>> augmentationsGrouped =
@@ -260,10 +261,10 @@ final class GenHelperUtil {
             for (Map.Entry<SchemaPath, List<AugmentationSchema>> schemaPathAugmentListEntry : augmentationsGrouped.entrySet()) {
                 genCtx = AugmentToGenType.usesAugmentationToGenTypes(schemaContext, basePackageName,
                         schemaPathAugmentListEntry.getValue(), module,
-                        usesNode, node, genCtx, genTypeBuilders, verboseClassComments, typeProvider);
+                        usesNode, node, genCtx, genTypeBuilders, verboseClassComments, typeProvider, namespaceType);
                 for (AugmentationSchema augSchema : schemaPathAugmentListEntry.getValue()) {
                     genCtx = processUsesAugments(schemaContext, augSchema, module, genCtx, genTypeBuilders,
-                            verboseClassComments, typeProvider);
+                            verboseClassComments, typeProvider, namespaceType);
                 }
             }
         }
@@ -293,7 +294,8 @@ final class GenHelperUtil {
     static Map<Module, ModuleContext> addRawAugmentGenTypeDefinition(final Module module, final String augmentPackageName,
             final Type targetTypeRef, final List<AugmentationSchema> schemaPathAugmentListEntry,
             final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final Map<Module, ModuleContext> genCtx,
-            final SchemaContext schemaContext, final boolean verboseClassComments, final TypeProvider typeProvider) {
+            final SchemaContext schemaContext, final boolean verboseClassComments, final TypeProvider typeProvider,
+            final BindingNamespaceType namespaceType) {
 
         //pick augmentation grouped by augmentation target, there is always at least one
         final AugmentationSchema augSchema = schemaPathAugmentListEntry.get(0);
@@ -328,7 +330,7 @@ final class GenHelperUtil {
             //apply all uses
             addImplementedInterfaceFromUses(aug, augTypeBuilder, genCtx);
             augSchemaNodeToMethods(module, BindingMapping.getRootPackageName(module), augTypeBuilder, augTypeBuilder, aug.getChildNodes(),
-               genCtx, schemaContext, verboseClassComments, typeProvider, genTypeBuilders);
+               genCtx, schemaContext, verboseClassComments, typeProvider, genTypeBuilders, namespaceType);
         }
 
         augmentBuilders.put(augTypeBuilder.getName(), augTypeBuilder);
@@ -367,12 +369,12 @@ final class GenHelperUtil {
             final GeneratedTypeBuilder typeBuilder, final GeneratedTypeBuilder childOf, final Iterable<DataSchemaNode> schemaNodes,
             final Map<Module, ModuleContext> genCtx, final SchemaContext schemaContext, final boolean
             verboseClassComments, final TypeProvider typeProvider, final Map<String, Map<String,
-            GeneratedTypeBuilder>> genTypeBuilders) {
+            GeneratedTypeBuilder>> genTypeBuilders, final BindingNamespaceType namespaceType) {
         if (schemaNodes != null && typeBuilder != null) {
             for (final DataSchemaNode schemaNode : schemaNodes) {
                 if (!schemaNode.isAugmenting()) {
                     addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode, typeBuilder, childOf, module, genCtx,
-                            schemaContext, verboseClassComments, genTypeBuilders, typeProvider);
+                            schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
                 }
             }
         }
@@ -406,9 +408,16 @@ final class GenHelperUtil {
     private static GeneratedTypeBuilder addDefaultInterfaceDefinition(final String packageName, final SchemaNode
             schemaNode, final Type parent, final Module module, final Map<Module, ModuleContext> genCtx,
             final SchemaContext schemaContext, final boolean verboseClassComments, final Map<String, Map<String,
-            GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider) {
+            GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider, final BindingNamespaceType namespaceType) {
+
+        String suffix = "";
+        if (schemaNode instanceof GroupingDefinition) {
+            suffix = "grouping";
+        } else if (namespaceType.equals(BindingNamespaceType.Grouping)){
+            suffix = "data";
+        }
 
-        GeneratedTypeBuilder it = addRawInterfaceDefinition(packageName, schemaNode, schemaContext, "",
+        GeneratedTypeBuilder it = addRawInterfaceDefinition(packageName, schemaNode, schemaContext, "", suffix,
                 verboseClassComments, genTypeBuilders);
         if (parent == null) {
             it.addImplementsType(BindingTypes.TREE_NODE);
@@ -423,7 +432,7 @@ final class GenHelperUtil {
             }
         }
 
-        if (!(schemaNode instanceof GroupingDefinition)) {
+        if (namespaceType.equals(BindingNamespaceType.Data)) {
             it.addImplementsType(BindingTypes.augmentable(it));
         }
 
@@ -442,11 +451,12 @@ final class GenHelperUtil {
             genTypeBuilders, TypeProvider typeProvider, Map<Module, ModuleContext> genCtx) {
 
         processUsesAugments(schemaContext, notification, module, genCtx, genTypeBuilders,
-                verboseClassComments, typeProvider);
+                verboseClassComments, typeProvider, BindingNamespaceType.Data);
 
+        final String packageName = packageNameForGeneratedType(basePackageName, notification.getPath(), BindingNamespaceType.Data);
         final GeneratedTypeBuilder notificationInterface = addDefaultInterfaceDefinition
-                (basePackageName, notification, null, module, genCtx, schemaContext,
-                        verboseClassComments, genTypeBuilders, typeProvider);
+                (packageName, notification, null, module, genCtx, schemaContext,
+                        verboseClassComments, genTypeBuilders, typeProvider, BindingNamespaceType.Data);
         annotateDeprecatedIfNecessary(notification.getStatus(), notificationInterface);
         notificationInterface.addImplementsType(NOTIFICATION);
         genCtx.get(module).addChildNodeType(notification, notificationInterface);
@@ -454,7 +464,7 @@ final class GenHelperUtil {
         // Notification object
         resolveDataSchemaNodes(module, basePackageName, notificationInterface,
                 notificationInterface, notification.getChildNodes(), genCtx, schemaContext,
-                verboseClassComments, genTypeBuilders, typeProvider);
+                verboseClassComments, genTypeBuilders, typeProvider, BindingNamespaceType.Data);
 
         //in case of tied notification, incorporate parent's localName
         final StringBuilder sb = new StringBuilder("on_");
@@ -496,8 +506,8 @@ final class GenHelperUtil {
      *
      */
     static GeneratedTypeBuilder addRawInterfaceDefinition(final String packageName, final SchemaNode schemaNode,
-                       final SchemaContext schemaContext, final String prefix, final boolean verboseClassComments,
-                       final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders) {
+            final SchemaContext schemaContext, final String prefix, final String suffix,
+            final boolean verboseClassComments, final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders) {
 
         Preconditions.checkArgument(schemaNode != null, "Data Schema Node cannot be NULL.");
         Preconditions.checkArgument(packageName != null, "Package Name for Generated Type cannot be NULL.");
@@ -509,6 +519,11 @@ final class GenHelperUtil {
             schemaNodeName = new StringBuilder(prefix).append('_').append(schemaNodeName).toString();
         }
 
+        if (suffix != null && !suffix.isEmpty()) {
+            // underscore used as separator for distinction of class name parts
+            schemaNodeName = new StringBuilder(schemaNodeName).append('_').append(suffix).toString();
+        }
+
         final GeneratedTypeBuilderImpl newType = new GeneratedTypeBuilderImpl(packageName, schemaNodeName);
         final Module module = SchemaContextUtil.findParentModule(schemaContext, schemaNode);
         qNameConstant(newType, BindingMapping.QNAME_STATIC_FIELD_NAME, schemaNode.getQName());
@@ -536,12 +551,13 @@ final class GenHelperUtil {
     private static void addSchemaNodeToBuilderAsMethod(final String basePackageName, final DataSchemaNode node,
         final GeneratedTypeBuilder typeBuilder, final GeneratedTypeBuilder childOf, final Module module,
         final Map<Module, ModuleContext> genCtx, final SchemaContext schemaContext, final boolean verboseClassComments,
-        final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider) {
+        final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider,
+        final BindingNamespaceType namespaceType) {
 
         if (node != null && typeBuilder != null) {
             if (node instanceof ContainerSchemaNode) {
                 containerToGenType(module, basePackageName, typeBuilder, childOf, (ContainerSchemaNode) node,
-                        schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider);
+                        schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType);
             } else if (node instanceof LeafListSchemaNode) {
                 resolveLeafListSchemaNode(schemaContext, typeBuilder, (LeafListSchemaNode) node, module,
                             typeProvider, genCtx);
@@ -550,10 +566,10 @@ final class GenHelperUtil {
                         typeProvider);
             } else if (node instanceof ListSchemaNode) {
                 listToGenType(module, basePackageName, typeBuilder, childOf, (ListSchemaNode) node, schemaContext,
-                        verboseClassComments, genCtx, genTypeBuilders, typeProvider);
+                        verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType);
             } else if (node instanceof ChoiceSchemaNode) {
                 choiceToGenType(module, schemaContext, verboseClassComments, basePackageName, childOf,
-                        (ChoiceSchemaNode) node, genTypeBuilders, genCtx, typeProvider);
+                        (ChoiceSchemaNode) node, genTypeBuilders, genCtx, typeProvider, namespaceType);
             } else if (node instanceof AnyXmlSchemaNode || node instanceof AnyDataSchemaNode) {
                 resolveAnyNodeAsMethod(schemaContext, typeBuilder, genCtx, node, module, typeProvider);
             }
@@ -586,7 +602,7 @@ final class GenHelperUtil {
     private static void choiceToGenType(final Module module, final SchemaContext schemaContext, final boolean
             verboseClasssComments, final String basePackageName, final GeneratedTypeBuilder parent, final
             ChoiceSchemaNode choiceNode, final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders,
-            final Map<Module, ModuleContext> genCtx, final TypeProvider typeProvider) {
+            final Map<Module, ModuleContext> genCtx, final TypeProvider typeProvider, final BindingNamespaceType namespaceType) {
         checkArgument(basePackageName != null, "Base Package Name cannot be NULL.");
         checkArgument(choiceNode != null, "Choice Schema Node cannot be NULL.");
 
@@ -594,38 +610,40 @@ final class GenHelperUtil {
             final String packageName = packageNameForGeneratedType(basePackageName, choiceNode.getPath(),
                     BindingNamespaceType.Data);
             final GeneratedTypeBuilder choiceTypeBuilder = addRawInterfaceDefinition(packageName, choiceNode,
-                    schemaContext, "", verboseClasssComments, genTypeBuilders);
+                    schemaContext, "", "", verboseClasssComments, genTypeBuilders);
             constructGetter(parent, choiceNode.getQName().getLocalName(),
                     choiceNode.getDescription(), choiceTypeBuilder, choiceNode.getStatus());
             choiceTypeBuilder.addImplementsType(parameterizedTypeFor(BindingTypes.INSTANTIABLE, choiceTypeBuilder));
             annotateDeprecatedIfNecessary(choiceNode.getStatus(), choiceTypeBuilder);
             genCtx.get(module).addChildNodeType(choiceNode, choiceTypeBuilder);
             generateTypesFromChoiceCases(module, schemaContext, genCtx, basePackageName, choiceTypeBuilder.toInstance(),
-                choiceNode, verboseClasssComments, typeProvider, genTypeBuilders);
+                choiceNode, verboseClasssComments, typeProvider, genTypeBuilders, namespaceType);
         }
     }
 
     private static void containerToGenType(final Module module, final String basePackageName,
         final GeneratedTypeBuilder parent, final GeneratedTypeBuilder childOf, final ContainerSchemaNode node,
         final SchemaContext schemaContext, final boolean verboseClassComments, final Map<Module, ModuleContext> genCtx,
-        final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider) {
+        final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider,
+        final BindingNamespaceType namespaceType) {
 
         final GeneratedTypeBuilder genType = processDataSchemaNode(module, basePackageName, childOf, node,
-                schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider);
+                schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType);
         if (genType != null) {
             constructGetter(parent, node.getQName().getLocalName(), node.getDescription(), genType, node.getStatus());
             resolveDataSchemaNodes(module, basePackageName, genType, genType, node.getChildNodes(), genCtx,
-                    schemaContext, verboseClassComments, genTypeBuilders, typeProvider);
+                    schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
         }
     }
 
     private static void listToGenType(final Module module, final String basePackageName, final GeneratedTypeBuilder
             parent, final GeneratedTypeBuilder childOf, final ListSchemaNode node, final SchemaContext schemaContext,
             final boolean verboseClassComments, final Map<Module, ModuleContext> genCtx,
-            final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider) {
+            final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider,
+            final BindingNamespaceType namespaceType) {
 
         final GeneratedTypeBuilder genType = processDataSchemaNode(module, basePackageName, childOf, node,
-                schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider);
+                schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType);
         if (genType != null) {
             final String nodeName = node.getQName().getLocalName();
             constructGetter(parent, nodeName, node.getDescription(), Types.listTypeFor(genType), node.getStatus());
@@ -638,7 +656,7 @@ final class GenHelperUtil {
             for (final DataSchemaNode schemaNode : node.getChildNodes()) {
                 if (!schemaNode.isAugmenting()) {
                     addSchemaNodeToListBuilders(nodeName, basePackageName, schemaNode, genType, genTOBuilder, listKeys,
-                            module, typeProvider, schemaContext, genCtx, genTypeBuilders, verboseClassComments);
+                            module, typeProvider, schemaContext, genCtx, genTypeBuilders, verboseClassComments, namespaceType);
                 }
             }
 
@@ -862,7 +880,7 @@ final class GenHelperUtil {
     private static void generateTypesFromChoiceCases(final Module module, final SchemaContext schemaContext,
             final Map<Module, ModuleContext> genCtx, final String basePackageName, final Type refChoiceType,
             final ChoiceSchemaNode choiceNode, final boolean verboseClassComments, final TypeProvider typeProvider,
-            final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders) {
+            final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final BindingNamespaceType namespaceType) {
         checkArgument(basePackageName != null, "Base Package Name cannot be NULL.");
         checkArgument(refChoiceType != null, "Referenced Choice Type cannot be NULL.");
         checkArgument(choiceNode != null, "ChoiceNode cannot be NULL.");
@@ -877,7 +895,7 @@ final class GenHelperUtil {
                 final String packageName = packageNameForGeneratedType(basePackageName, caseNode.getPath(),
                     BindingNamespaceType.Data);
                 final GeneratedTypeBuilder caseTypeBuilder = addDefaultInterfaceDefinition(packageName, caseNode,
-                    module, genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider);
+                    module, genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
                 caseTypeBuilder.addImplementsType(refChoiceType);
                 caseTypeBuilder.setParentTypeForBuilder(refChoiceType);
                 annotateDeprecatedIfNecessary(caseNode.getStatus(), caseTypeBuilder);
@@ -915,16 +933,16 @@ final class GenHelperUtil {
                             childOfType = findGroupingByPath(parent.getPath(), genCtx);
                         }
                         resolveDataSchemaNodes(module, basePackageName, caseTypeBuilder, childOfType, caseChildNodes,
-                                genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider);
+                                genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
                     } else {
                         resolveDataSchemaNodes(module, basePackageName, caseTypeBuilder, moduleToDataType(module,
                                 genCtx, verboseClassComments), caseChildNodes, genCtx, schemaContext,
-                                verboseClassComments, genTypeBuilders, typeProvider);
+                                verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
                     }
                 }
             }
             processUsesAugments(schemaContext, caseNode, module, genCtx, genTypeBuilders, verboseClassComments,
-                    typeProvider);
+                    typeProvider, namespaceType);
         }
     }
 
@@ -988,7 +1006,8 @@ final class GenHelperUtil {
             final DataSchemaNode schemaNode, final GeneratedTypeBuilder typeBuilder,
             final GeneratedTOBuilder genTOBuilder, final List<QName> listKeys, final Module module,
             final TypeProvider typeProvider, final SchemaContext schemaContext, final Map<Module, ModuleContext> genCtx,
-            final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final boolean verboseClassComments) {
+            final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final boolean verboseClassComments,
+            final BindingNamespaceType namespaceType) {
         checkArgument(schemaNode != null, "Data Schema Node cannot be NULL.");
         checkArgument(typeBuilder != null, "Generated Type Builder cannot be NULL.");
 
@@ -1012,13 +1031,13 @@ final class GenHelperUtil {
                         typeProvider, genCtx);
             } else if (schemaNode instanceof ContainerSchemaNode) {
                 containerToGenType(module, basePackageName, typeBuilder, typeBuilder, (ContainerSchemaNode) schemaNode,
-                        schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider);
+                        schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType);
             } else if (schemaNode instanceof ListSchemaNode) {
                 listToGenType(module, basePackageName, typeBuilder, typeBuilder, (ListSchemaNode) schemaNode,
-                        schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider);
+                        schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType);
             } else if (schemaNode instanceof ChoiceSchemaNode) {
                 choiceToGenType(module, schemaContext, verboseClassComments, basePackageName, typeBuilder,
-                        (ChoiceSchemaNode) schemaNode, genTypeBuilders, genCtx, typeProvider);
+                        (ChoiceSchemaNode) schemaNode, genTypeBuilders, genCtx, typeProvider, namespaceType);
             }
         }
     }
@@ -1062,14 +1081,14 @@ final class GenHelperUtil {
     private static GeneratedTypeBuilder processDataSchemaNode(final Module module, final String basePackageName,
         final GeneratedTypeBuilder childOf, final DataSchemaNode node, final SchemaContext schemaContext,
         final boolean verboseClassComments, Map<Module, ModuleContext> genCtx, final Map<String, Map<String,
-        GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider) {
+        GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider, final BindingNamespaceType namespaceType) {
 
         if (node.isAugmenting() || node.isAddedByUses()) {
             return null;
         }
-        final String packageName = packageNameForGeneratedType(basePackageName, node.getPath(), BindingNamespaceType.Data);
+        final String packageName = packageNameForGeneratedType(basePackageName, node.getPath(), namespaceType);
         final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(packageName, node, childOf, module,
-                genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider);
+                genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
         genType.addComment(node.getDescription());
         annotateDeprecatedIfNecessary(node.getStatus(), genType);
         genType.setDescription(createDescription(node, genType.getFullyQualifiedName(), schemaContext, verboseClassComments));
@@ -1082,7 +1101,7 @@ final class GenHelperUtil {
             genCtx = groupingsToGenTypes(module, ((DataNodeContainer) node).getGroupings(), genCtx, schemaContext,
                     verboseClassComments, genTypeBuilders, typeProvider);
             processUsesAugments(schemaContext, (DataNodeContainer) node, module, genCtx, genTypeBuilders,
-                    verboseClassComments, typeProvider);
+                    verboseClassComments, typeProvider, namespaceType);
         }
         return genType;
     }
@@ -1153,15 +1172,15 @@ final class GenHelperUtil {
             verboseClassComments, Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider) {
         final String packageName = packageNameForGeneratedType(basePackageName, grouping.getPath(), BindingNamespaceType.Grouping);
         final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(packageName, grouping, module, genCtx,
-                schemaContext, verboseClassComments, genTypeBuilders, typeProvider);
+                schemaContext, verboseClassComments, genTypeBuilders, typeProvider, BindingNamespaceType.Grouping);
         annotateDeprecatedIfNecessary(grouping.getStatus(), genType);
-        genCtx.get(module).addGroupingType(grouping.getPath(), genType);
+        genCtx.get(module).addGroupingType(grouping, genType);
         resolveDataSchemaNodes(module, basePackageName, genType, genType, grouping.getChildNodes(), genCtx,
-                schemaContext, verboseClassComments, genTypeBuilders, typeProvider);
+                schemaContext, verboseClassComments, genTypeBuilders, typeProvider, BindingNamespaceType.Grouping);
         genCtx = groupingsToGenTypes(module, grouping.getGroupings(), genCtx, schemaContext, verboseClassComments,
                 genTypeBuilders, typeProvider);
         genCtx = processUsesAugments(schemaContext, grouping, module, genCtx, genTypeBuilders, verboseClassComments,
-                typeProvider);
+                typeProvider, BindingNamespaceType.Grouping);
         return genCtx;
     }
 

diff --git a/binding2/mdsal-binding2-generator-impl/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/impl/ModuleContext.java b/binding2/mdsal-binding2-generator-impl/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/impl/ModuleContext.java
index b240b1183b071b0487d18d6a4f7939bce5bf97e6..d72226afc0d586d6851be3a89dacd071bdd786cb 100644 (file)
--- a/binding2/mdsal-binding2-generator-impl/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/impl/ModuleContext.java
+++ b/binding2/mdsal-binding2-generator-impl/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/impl/ModuleContext.java
@@ -31,6 +31,7 @@ import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
 import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
@@ -44,6 +45,7 @@ public final class ModuleContext {
     private final List<GeneratedTOBuilder> genTOs = new ArrayList<>();
     private final Map<SchemaPath, Type> typedefs = new HashMap<>();
     private final Map<SchemaPath, GeneratedTypeBuilder> childNodes = new HashMap<>();
+    private final BiMap<String, GeneratedTypeBuilder> dataTypes = HashBiMap.create();
     private final Map<SchemaPath, GeneratedTypeBuilder> groupings = new HashMap<>();
     private final Map<SchemaPath, GeneratedTypeBuilder> cases = new HashMap<>();
     private final Map<QName,GeneratedTOBuilder> identities = new HashMap<>();
@@ -66,7 +68,7 @@ public final class ModuleContext {
 
         result.addAll(this.genTOs.stream().map(GeneratedTOBuilder::toInstance).collect(Collectors.toList()));
         result.addAll(this.typedefs.values().stream().filter(b -> b != null).collect(Collectors.toList()));
-        result.addAll(this.childNodes.values().stream().map(GeneratedTypeBuilder::toInstance).collect(Collectors.toList()));
+        result.addAll(this.dataTypes.values().stream().map(GeneratedTypeBuilder::toInstance).collect(Collectors.toList()));
         result.addAll(this.groupings.values().stream().map(GeneratedTypeBuilder::toInstance).collect(Collectors.toList()));
         result.addAll(this.cases.values().stream().map(GeneratedTypeBuilder::toInstance).collect(Collectors.toList()));
         result.addAll(this.identities.values().stream().map(GeneratedTOBuilder::toInstance).collect(Collectors.toList()));
@@ -107,10 +109,12 @@ public final class ModuleContext {
     public void addChildNodeType(final SchemaNode p, final GeneratedTypeBuilder b) {
         this.childNodes.put(p.getPath(), b);
         this.typeToSchema.put(b,p);
+        this.dataTypes.put(b.getFullyQualifiedName(), b);
     }
 
-    public void addGroupingType(final SchemaPath p, final GeneratedTypeBuilder b) {
-        this.groupings.put(p, b);
+    public void addGroupingType(final GroupingDefinition p, final GeneratedTypeBuilder b) {
+        this.groupings.put(p.getPath(), b);
+        this.typeToSchema.put(b, p);
     }
 
     public void addTypedefType(final SchemaPath p, final Type t) {

diff --git a/binding2/mdsal-binding2-generator-impl/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/impl/ModuleToGenType.java b/binding2/mdsal-binding2-generator-impl/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/impl/ModuleToGenType.java
index 5f49ccc91b2262a8870f9f32303b3f0fc2ee4b37..c0d7687ff98d64d18690ea13d1d388028ddc3a15 100644 (file)
--- a/binding2/mdsal-binding2-generator-impl/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/impl/ModuleToGenType.java
+++ b/binding2/mdsal-binding2-generator-impl/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/impl/ModuleToGenType.java
@@ -28,6 +28,7 @@ import org.opendaylight.mdsal.binding.javav2.generator.util.generated.type.build
 import org.opendaylight.mdsal.binding.javav2.generator.yang.types.TypeProviderImpl;
 import org.opendaylight.mdsal.binding.javav2.model.api.Type;
 import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedTypeBuilder;
+import org.opendaylight.mdsal.binding.javav2.spec.runtime.BindingNamespaceType;
 import org.opendaylight.mdsal.binding.javav2.util.BindingMapping;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
@@ -62,7 +63,8 @@ final class ModuleToGenType {
             genCtx.get(module).addModuleNode(moduleType);
             final String basePackageName = BindingMapping.getRootPackageName(module);
             GenHelperUtil.resolveDataSchemaNodes(module, basePackageName, moduleType, moduleType, module
-                    .getChildNodes(), genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider);
+                    .getChildNodes(), genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider,
+                    BindingNamespaceType.Data);
         }
 
         //after potential parent data schema nodes

diff --git a/binding2/mdsal-binding2-generator-impl/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/impl/RpcActionGenHelper.java b/binding2/mdsal-binding2-generator-impl/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/impl/RpcActionGenHelper.java
index d192a95335f7275db90dd0d2792a851a3d962d7b..c9b98f7f1a91768106306c7db7abb39897331a01 100644 (file)
--- a/binding2/mdsal-binding2-generator-impl/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/impl/RpcActionGenHelper.java
+++ b/binding2/mdsal-binding2-generator-impl/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/impl/RpcActionGenHelper.java
@@ -42,6 +42,7 @@ import org.opendaylight.mdsal.binding.javav2.model.api.GeneratedTransferObject;
 import org.opendaylight.mdsal.binding.javav2.model.api.GeneratedType;
 import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedTypeBuilder;
 import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.MethodSignatureBuilder;
+import org.opendaylight.mdsal.binding.javav2.spec.runtime.BindingNamespaceType;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.model.api.ActionDefinition;
 import org.opendaylight.yangtools.yang.model.api.ActionNodeContainer;
@@ -248,7 +249,7 @@ final class RpcActionGenHelper {
                 //Action
                 GenHelperUtil.resolveDataSchemaNodes(module, basePackageName, parentType, parentType,
                         ((ContainerSchemaNode) parent).getChildNodes(), genCtx, schemaContext, verboseClassComments,
-                        genTypeBuilders, typeProvider);
+                        genTypeBuilders, typeProvider, BindingNamespaceType.Data);
                 operationMethod.addParameter(parameterizedTypeFor(INSTANCE_IDENTIFIER, parentType), "ii");
                 interfaceBuilder.addImplementsType(parameterizedTypeFor(ACTION, parentType, inType, outType));
             }
@@ -272,7 +273,7 @@ final class RpcActionGenHelper {
             GeneratedTypeBuilder>> genTypeBuilders, final Map<Module, ModuleContext> genCtx, final boolean isInput) {
 
         final GeneratedTypeBuilder nodeType = addRawInterfaceDefinition(basePackageName, operationNode, schemaContext,
-                operationName, verboseClassComments, genTypeBuilders);
+                operationName, "", verboseClassComments, genTypeBuilders);
         addImplementedInterfaceFromUses(operationNode, nodeType, genCtx);
         nodeType.addImplementsType(parameterizedTypeFor(BindingTypes.TREE_CHILD_NODE, parent, parameterizedTypeFor
                 (BindingTypes.ITEM, parent)));
@@ -284,7 +285,7 @@ final class RpcActionGenHelper {
         nodeType.addImplementsType(parameterizedTypeFor(INSTANTIABLE, nodeType));
         nodeType.addImplementsType(augmentable(nodeType));
         GenHelperUtil.resolveDataSchemaNodes(module, basePackageName, nodeType, nodeType, operationNode.getChildNodes(), genCtx,
-                schemaContext, verboseClassComments, genTypeBuilders, typeProvider);
+                schemaContext, verboseClassComments, genTypeBuilders, typeProvider, BindingNamespaceType.Data);
 
         final MethodSignatureBuilder nodeMethod = nodeType.addMethod("implementedInterface");
         nodeMethod.setReturnType(parameterizedTypeFor(CLASS, nodeType));

diff --git a/binding2/mdsal-binding2-generator-impl/src/test/java/org/opendaylight/mdsal/binding/javav2/generator/impl/AugmentToGenTypeTest.java b/binding2/mdsal-binding2-generator-impl/src/test/java/org/opendaylight/mdsal/binding/javav2/generator/impl/AugmentToGenTypeTest.java
index b37669d56b2c37bd020a6e87d933548cd07acb98..63d24bd898d3b8c3952101e67522dbc335aac250 100644 (file)
--- a/binding2/mdsal-binding2-generator-impl/src/test/java/org/opendaylight/mdsal/binding/javav2/generator/impl/AugmentToGenTypeTest.java
+++ b/binding2/mdsal-binding2-generator-impl/src/test/java/org/opendaylight/mdsal/binding/javav2/generator/impl/AugmentToGenTypeTest.java
@@ -32,6 +32,7 @@ import org.opendaylight.mdsal.binding.javav2.generator.util.generated.type.build
 import org.opendaylight.mdsal.binding.javav2.generator.yang.types.TypeProviderImpl;
 import org.opendaylight.mdsal.binding.javav2.model.api.Type;
 import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedTypeBuilder;
+import org.opendaylight.mdsal.binding.javav2.spec.runtime.BindingNamespaceType;
 import org.opendaylight.mdsal.binding.javav2.spec.structural.Augmentable;
 import org.opendaylight.mdsal.binding.javav2.spec.structural.Augmentation;
 import org.opendaylight.yangtools.yang.common.QName;
@@ -724,7 +725,7 @@ public class AugmentToGenTypeTest {
     @Test
     public void usesAugmentationToGenTypesNullPckgNameTest() throws Exception {
         try {
-            AugmentToGenType.usesAugmentationToGenTypes(null, null, null, null, null, null, null, null, false, null);
+            AugmentToGenType.usesAugmentationToGenTypes(null, null, null, null, null, null, null, null, false, null, null);
         } catch (final Exception e) {
             assertNotNull(e);
             assertTrue(e instanceof IllegalArgumentException);
@@ -735,7 +736,7 @@ public class AugmentToGenTypeTest {
     @Test
     public void usesAugmentationToGenTypesNullAugSchemaListEntryTest() throws Exception {
         try {
-            AugmentToGenType.usesAugmentationToGenTypes(null, "", null, null, null, null, null, null, false, null);
+            AugmentToGenType.usesAugmentationToGenTypes(null, "", null, null, null, null, null, null, false, null, null);
         } catch (final Exception e) {
             assertNotNull(e);
             assertTrue(e instanceof IllegalArgumentException);
@@ -748,7 +749,7 @@ public class AugmentToGenTypeTest {
         final List<AugmentationSchema> augmentationSchemaList = new ArrayList<>();
         try {
             AugmentToGenType.usesAugmentationToGenTypes(null, "", augmentationSchemaList, null, null, null, null, null,
-                    false, null);
+                    false, null, null);
         } catch (final Exception e) {
             assertNotNull(e);
             assertTrue(e instanceof IllegalStateException);
@@ -764,7 +765,7 @@ public class AugmentToGenTypeTest {
         augmentationSchemaList.add(augmentationSchema);
         try {
             AugmentToGenType.usesAugmentationToGenTypes(null, "", augmentationSchemaList, null, null, null, null, null,
-                    false, null);
+                    false, null, null);
         } catch (final Exception e) {
             assertNotNull(e);
             assertTrue(e instanceof IllegalStateException);
@@ -809,7 +810,7 @@ public class AugmentToGenTypeTest {
 
         try {
             AugmentToGenType.usesAugmentationToGenTypes(context, "pckg.test.augm", augmentationSchemaList, moduleAug,
-                    usesNode, usesNodeParent, genCtx, genTypeBuilders, false, null);
+                    usesNode, usesNodeParent, genCtx, genTypeBuilders, false, null, null);
         } catch (final Exception e) {
             assertNotNull(e);
             assertTrue(e instanceof IllegalArgumentException);
@@ -855,7 +856,7 @@ public class AugmentToGenTypeTest {
 
         try {
             AugmentToGenType.usesAugmentationToGenTypes(context, "pckg.test.augm", augmentationSchemaList, moduleAug,
-                    usesNode, usesNodeParent, genCtx, genTypeBuilders, false, null);
+                    usesNode, usesNodeParent, genCtx, genTypeBuilders, false, null, null);
         } catch (final Exception e) {
             assertNotNull(e);
             assertTrue(e instanceof NullPointerException);
@@ -906,7 +907,8 @@ public class AugmentToGenTypeTest {
         when(usesNode.getGroupingPath()).thenReturn(path);
 
         final Map<Module, ModuleContext> result = AugmentToGenType.usesAugmentationToGenTypes(context, "pckg.test.augm",
-                augmentationSchemaList, moduleAug, usesNode, usesNodeParent, genCtx, genTypeBuilders, false, null);
+                augmentationSchemaList, moduleAug, usesNode, usesNodeParent, genCtx, genTypeBuilders, false, null,
+                BindingNamespaceType.Data);
         assertNotNull(result);
     }
 
@@ -953,7 +955,8 @@ public class AugmentToGenTypeTest {
         when(usesNode.getGroupingPath()).thenReturn(path);
 
         final Map<Module, ModuleContext> result = AugmentToGenType.usesAugmentationToGenTypes(context, "pckg.test.augm",
-                augmentationSchemaList, moduleAug, usesNode, usesNodeParent, genCtx, genTypeBuilders, false, null);
+                augmentationSchemaList, moduleAug, usesNode, usesNodeParent, genCtx, genTypeBuilders, false, null,
+                BindingNamespaceType.Data);
         assertNotNull(result);
     }
 
@@ -1139,7 +1142,8 @@ public class AugmentToGenTypeTest {
     public void generateTypesFromAugmentedChoiceCasesNullPckgNameTest() throws Exception {
         final Class[] parameterTypes =
                 { SchemaContext.class, Module.class, String.class, Type.class, ChoiceSchemaNode.class, List.class,
-                        DataNodeContainer.class, Map.class, boolean.class, Map.class, TypeProvider.class };
+                        DataNodeContainer.class, Map.class, boolean.class, Map.class, TypeProvider.class,
+                        BindingNamespaceType.class};
         final Method generate =
                 AugmentToGenType.class.getDeclaredMethod("generateTypesFromAugmentedChoiceCases", parameterTypes);
         assertNotNull(generate);
@@ -1156,7 +1160,7 @@ public class AugmentToGenTypeTest {
         final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilder = new HashMap<>();
 
         final Object[] args = { schemaContext, module, pckgName, targetType, targetNode, schemaPathAugmentListEntry,
-                usesNodeParent, genCtx, false, genTypeBuilder, null };
+                usesNodeParent, genCtx, false, genTypeBuilder, null, BindingNamespaceType.Data };
         try {
             generate.invoke(AugmentToGenType.class, args);
             fail();
@@ -1175,7 +1179,8 @@ public class AugmentToGenTypeTest {
     public void generateTypesFromAugmentedChoiceCasesNullTargetType() throws Exception {
         final Class[] parameterTypes =
                 { SchemaContext.class, Module.class, String.class, Type.class, ChoiceSchemaNode.class, List.class,
-                        DataNodeContainer.class, Map.class, boolean.class, Map.class, TypeProvider.class };
+                        DataNodeContainer.class, Map.class, boolean.class, Map.class, TypeProvider.class,
+                        BindingNamespaceType.class };
         final Method generate =
                 AugmentToGenType.class.getDeclaredMethod("generateTypesFromAugmentedChoiceCases", parameterTypes);
         assertNotNull(generate);
@@ -1192,7 +1197,7 @@ public class AugmentToGenTypeTest {
         final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilder = new HashMap<>();
 
         final Object[] args = { schemaContext, module, pckgName, targetType, targetNode, schemaPathAugmentListEntry,
-                usesNodeParent, genCtx, false, genTypeBuilder, null };
+                usesNodeParent, genCtx, false, genTypeBuilder, null, BindingNamespaceType.Data };
         try {
             generate.invoke(AugmentToGenType.class, args);
             fail();
@@ -1211,7 +1216,8 @@ public class AugmentToGenTypeTest {
     public void generateTypesFromAugmentedChoiceCasesNullAugmentNodes() throws Exception {
         final Class[] parameterTypes =
                 { SchemaContext.class, Module.class, String.class, Type.class, ChoiceSchemaNode.class, List.class,
-                        DataNodeContainer.class, Map.class, boolean.class, Map.class, TypeProvider.class };
+                        DataNodeContainer.class, Map.class, boolean.class, Map.class, TypeProvider.class,
+                        BindingNamespaceType.class };
         final Method generate =
                 AugmentToGenType.class.getDeclaredMethod("generateTypesFromAugmentedChoiceCases", parameterTypes);
         assertNotNull(generate);
@@ -1228,7 +1234,7 @@ public class AugmentToGenTypeTest {
         final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilder = new HashMap<>();
 
         final Object[] args = { schemaContext, module, pckgName, targetType, targetNode, schemaPathAugmentListEntry, usesNodeParent,
-                genCtx, false, genTypeBuilder, null };
+                genCtx, false, genTypeBuilder, null, BindingNamespaceType.Data };
         try {
             generate.invoke(AugmentToGenType.class, args);
             fail();
@@ -1247,7 +1253,8 @@ public class AugmentToGenTypeTest {
     public void generateTypesFromAugmentedChoiceCasesNullCaseNodeTest() throws Exception {
         final Class[] parameterTypes =
                 { SchemaContext.class, Module.class, String.class, Type.class, ChoiceSchemaNode.class, List.class,
-                        DataNodeContainer.class, Map.class, boolean.class, Map.class, TypeProvider.class };
+                        DataNodeContainer.class, Map.class, boolean.class, Map.class, TypeProvider.class,
+                        BindingNamespaceType.class };
         final Method generate =
                 AugmentToGenType.class.getDeclaredMethod("generateTypesFromAugmentedChoiceCases", parameterTypes);
         assertNotNull(generate);
@@ -1272,7 +1279,7 @@ public class AugmentToGenTypeTest {
         final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilder = new HashMap<>();
 
         final Object[] args = { schemaContext, module, pckgName, targetType, targetNode, schemaPathAugmentListEntry, usesNodeParent,
-                genCtx, false, genTypeBuilder, null };
+                genCtx, false, genTypeBuilder, null, BindingNamespaceType.Data };
         final Map<Module, ModuleContext> result =
                 (Map<Module, ModuleContext>) generate.invoke(AugmentToGenType.class, args);
         assertEquals(genCtx, result);
@@ -1283,7 +1290,8 @@ public class AugmentToGenTypeTest {
     public void generateTypesFromAugmentedChoiceCasesNullChildTest() throws Exception {
         final Class[] parameterTypes =
                 { SchemaContext.class, Module.class, String.class, Type.class, ChoiceSchemaNode.class, List.class,
-                        DataNodeContainer.class, Map.class, boolean.class, Map.class, TypeProvider.class };
+                        DataNodeContainer.class, Map.class, boolean.class, Map.class, TypeProvider.class,
+                        BindingNamespaceType.class };
         final Method generate =
                 AugmentToGenType.class.getDeclaredMethod("generateTypesFromAugmentedChoiceCases", parameterTypes);
         assertNotNull(generate);
@@ -1327,7 +1335,7 @@ public class AugmentToGenTypeTest {
                 .thenReturn(module);
 
         final Object[] args = { schemaContext, module, pckgName, targetType, targetNode, schemaPathAugmentListEntry, usesNodeParent,
-                genCtx, false, genTypeBuilder, null };
+                genCtx, false, genTypeBuilder, null, BindingNamespaceType.Data };
         try {
             generate.invoke(AugmentToGenType.class, args);
             fail();
@@ -1346,7 +1354,8 @@ public class AugmentToGenTypeTest {
     public void generateTypesFromAugmentedChoiceCasesTest() throws Exception {
         final Class[] parameterTypes =
                 { SchemaContext.class, Module.class, String.class, Type.class, ChoiceSchemaNode.class, List.class,
-                        DataNodeContainer.class, Map.class, boolean.class, Map.class, TypeProvider.class };
+                        DataNodeContainer.class, Map.class, boolean.class, Map.class, TypeProvider.class,
+                        BindingNamespaceType.class };
         final Method generate =
                 AugmentToGenType.class.getDeclaredMethod("generateTypesFromAugmentedChoiceCases", parameterTypes);
         assertNotNull(generate);
@@ -1392,7 +1401,7 @@ public class AugmentToGenTypeTest {
                 .thenReturn(module);
 
         final Object[] args = { schemaContext, module, pckgName, targetType, targetNode, schemaPathAugmentListEntry, usesNodeParent,
-                genCtx, false, genTypeBuilder, null };
+                genCtx, false, genTypeBuilder, null ,BindingNamespaceType.Data };
         final Map<Module, ModuleContext> result =
                 (Map<Module, ModuleContext>) generate.invoke(AugmentToGenType.class, args);
         assertNotNull(result);

diff --git a/binding2/mdsal-binding2-generator-impl/src/test/resources/namespace/namespace-test-foo1.yang b/binding2/mdsal-binding2-generator-impl/src/test/resources/namespace/namespace-test-foo1.yang
new file mode 100644 (file)
index 0000000..8290e36
--- /dev/null
+++ b/binding2/mdsal-binding2-generator-impl/src/test/resources/namespace/namespace-test-foo1.yang
@@ -0,0 +1,21 @@
+module namespace-test-foo1   {
+    namespace "org.test.namespace.foo1";
+    prefix "foo1";
+    revision 2017-05-19;
+
+    container a {
+        container b {
+            leaf c {
+                type string;
+            }
+        }
+    }
+
+    grouping a {
+         container b {
+            leaf c {
+                type string;
+            }
+        }
+    }
+}
\ No newline at end of file

diff --git a/binding2/mdsal-binding2-generator-util/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/util/generated/type/builder/GeneratedTypeBuilderImpl.java b/binding2/mdsal-binding2-generator-util/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/util/generated/type/builder/GeneratedTypeBuilderImpl.java
index fbe3fbef739f7d3117541f1bc8769666e7a8e8c4..1ed403f5198c804c6ebaef606a3e5adfca37c9ba 100644 (file)
--- a/binding2/mdsal-binding2-generator-util/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/util/generated/type/builder/GeneratedTypeBuilderImpl.java
+++ b/binding2/mdsal-binding2-generator-util/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/util/generated/type/builder/GeneratedTypeBuilderImpl.java
@@ -157,7 +157,8 @@ public final class GeneratedTypeBuilderImpl extends AbstractGeneratedTypeBuilder
                 final String baseName = new StringBuilder(normalizeBasePackageName)
                         .append(".").append(BindingNamespaceType.Data.getPackagePrefix()).toString();
 
-                Preconditions.checkState(this.getPackageName().contains(baseName),
+                Preconditions.checkState(this.getPackageName().equals(baseName)
+                                || this.getPackageName().contains(baseName),
                         "Package name does not contain base name!");
 
                 return new StringBuilder(normalizeBasePackageName)