Binding generator v2 - uses statement - support list

- generate type from uses list which extends reference list type
- add suffix "Data" to the method getKey in grouping to avoid clashing with
  the method generated from uses this grouping
- add test yang

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

diff --git a/binding2/mdsal-binding2-generator-impl/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/impl/AuxiliaryGenUtils.java b/binding2/mdsal-binding2-generator-impl/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/impl/AuxiliaryGenUtils.java
index 26a6b0d5e773c280f2c8d0d3a358a7f52488fda3..7f5c52c0624662bc0087915aea97604e466956b0 100644 (file)
--- a/binding2/mdsal-binding2-generator-impl/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/impl/AuxiliaryGenUtils.java
+++ b/binding2/mdsal-binding2-generator-impl/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/impl/AuxiliaryGenUtils.java
@@ -35,6 +35,7 @@ import org.opendaylight.mdsal.binding.javav2.generator.util.JavaIdentifierNormal
 import org.opendaylight.mdsal.binding.javav2.generator.util.Types;
 import org.opendaylight.mdsal.binding.javav2.generator.util.YangSnippetCleaner;
 import org.opendaylight.mdsal.binding.javav2.generator.util.generated.type.builder.GeneratedTOBuilderImpl;
+import org.opendaylight.mdsal.binding.javav2.generator.util.generated.type.builder.GeneratedTypeBuilderImpl;
 import org.opendaylight.mdsal.binding.javav2.generator.yang.types.TypeProviderImpl;
 import org.opendaylight.mdsal.binding.javav2.model.api.Constant;
 import org.opendaylight.mdsal.binding.javav2.model.api.Type;
@@ -97,13 +98,10 @@ final class AuxiliaryGenUtils {
     }
 
     public static boolean hasBuilderClass(final SchemaNode schemaNode, final BindingNamespaceType namespaceType) {
-        if ((namespaceType.equals(BindingNamespaceType.Data)
-        && (schemaNode instanceof ContainerSchemaNode || schemaNode instanceof ListSchemaNode
+        return (namespaceType.equals(BindingNamespaceType.Data)
+                && (schemaNode instanceof ContainerSchemaNode || schemaNode instanceof ListSchemaNode
                 || schemaNode instanceof RpcDefinition || schemaNode instanceof NotificationDefinition
-                || schemaNode instanceof ChoiceCaseNode))) {
-            return true;
-        }
-        return false;
+                || schemaNode instanceof ChoiceCaseNode));
     }
 
     static Constant qNameConstant(final GeneratedTypeBuilderBase<?> toBuilder, final String constantName,
@@ -230,7 +228,7 @@ final class AuxiliaryGenUtils {
                     final List<QName> keyDef = ((ListSchemaNode)schemaNode).getKeyDefinition();
                     if (keyDef != null && !keyDef.isEmpty()) {
                         sb.append("@see ");
-                        sb.append(linkToKeyClass).append(className).append("Key");
+                        sb.append(linkToKeyClass);
                     }
                     sb.append(NEW_LINE);
                 }
@@ -430,14 +428,8 @@ final class AuxiliaryGenUtils {
     }
 
     static boolean isInnerType(final LeafSchemaNode leaf, final TypeDefinition<?> type) {
-        if (leaf.getPath().equals(type.getPath())) {
-            return true;
-        }
-        if (leaf.getPath().equals(type.getPath().getParent())) {
-            return true;
-        }
+        return leaf.getPath().equals(type.getPath()) || leaf.getPath().equals(type.getPath().getParent());
 
-        return false;
     }
 
     /**
@@ -464,6 +456,18 @@ final class AuxiliaryGenUtils {
         return genTOBuilder;
     }
 
+    static GeneratedTypeBuilder resolveListKeyTypeBuilder(final String packageName, final ListSchemaNode list) {
+        GeneratedTypeBuilder genTypeBuilder = null;
+        if ((list.getKeyDefinition() != null) && (!list.getKeyDefinition().isEmpty())) {
+            // underscore used as separator for distinction of class name parts
+            final String genTOName =
+                    new StringBuilder(list.getQName().getLocalName()).append('_').append(BindingNamespaceType.Key)
+                            .toString();
+            genTypeBuilder = new GeneratedTypeBuilderImpl(packageName, genTOName);
+        }
+        return genTypeBuilder;
+    }
+
     /**
      * Converts <code>leaf</code> schema node to property of generated TO
      * builder.
@@ -485,16 +489,23 @@ final class AuxiliaryGenUtils {
      *         <li>true - other cases</li>
      *         </ul>
      */
-    static boolean resolveLeafSchemaNodeAsProperty(final GeneratedTOBuilder toBuilder, final LeafSchemaNode leaf,
+    static boolean resolveLeafSchemaNodeAsProperty(final String nodeName, final GeneratedTOBuilder toBuilder, final LeafSchemaNode leaf,
         final Type returnType, final boolean isReadOnly) {
 
         if (returnType == null) {
             return false;
         }
         final String leafName = leaf.getQName().getLocalName();
+        final String leafGetterName;
+
+        StringBuilder sb = new StringBuilder(nodeName)
+                .append('_')
+                .append(leafName);
+        leafGetterName = sb.toString();
+
         final String leafDesc = encodeAngleBrackets(leaf.getDescription());
         final GeneratedPropertyBuilder propBuilder =
-                toBuilder.addProperty(JavaIdentifierNormalizer.normalizeSpecificIdentifier(leafName, JavaIdentifier.METHOD));
+                toBuilder.addProperty(JavaIdentifierNormalizer.normalizeSpecificIdentifier(leafGetterName, JavaIdentifier.METHOD));
         propBuilder.setReadOnly(isReadOnly);
         propBuilder.setReturnType(returnType);
         propBuilder.setComment(leafDesc);

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 96f25e513478f8d96af1204839e1115a27848b05..451e389e3cfc19705c0764656aaf1c4a32f86a4f 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
@@ -20,11 +20,13 @@ import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenU
 import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.qNameConstant;
 import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.resolveInnerEnumFromTypeDefinition;
 import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.resolveListKeyTOBuilder;
+import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.resolveListKeyTypeBuilder;
 import static org.opendaylight.mdsal.binding.javav2.generator.util.BindingGeneratorUtil.computeDefaultSUID;
 import static org.opendaylight.mdsal.binding.javav2.generator.util.BindingGeneratorUtil.encodeAngleBrackets;
 import static org.opendaylight.mdsal.binding.javav2.generator.util.BindingGeneratorUtil.packageNameForGeneratedType;
 import static org.opendaylight.mdsal.binding.javav2.generator.util.BindingTypes.NOTIFICATION;
 import static org.opendaylight.mdsal.binding.javav2.generator.util.Types.parameterizedTypeFor;
+import static org.opendaylight.mdsal.binding.javav2.generator.util.Types.wildcardTypeFor;
 import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.findDataSchemaNode;
 import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.findParentModule;
 
@@ -272,7 +274,6 @@ final class GenHelperUtil {
         return genCtx;
     }
 
-
     static void addUsesImplements(final DataNodeContainer superNode, final Module superModule,
             final DataNodeContainer node, final Module module,
             final SchemaContext schemaContext, Map<Module, ModuleContext> genCtx, final BindingNamespaceType namespaceType ) {
@@ -292,6 +293,16 @@ final class GenHelperUtil {
                 Preconditions.checkNotNull(type, module.toString() + "->" + childNode.getPath().toString());
                 Preconditions.checkNotNull(superType, superModule.toString() + "->" + superChildNode.getPath().toString());
                 type.addImplementsType(superType);
+                if (superChildNode instanceof ListSchemaNode
+                        && !((ListSchemaNode)superChildNode).getKeyDefinition().isEmpty()) {
+                    if (namespaceType.equals(BindingNamespaceType.Grouping)) {
+                        genCtx.get(module).getKeyType(childNode.getPath())
+                                .addImplementsType(genCtx.get(superModule).getKeyType(superChildNode.getPath()));
+                    } else if (namespaceType.equals(BindingNamespaceType.Data)){
+                        genCtx.get(module).getKeyGenTO(childNode.getPath())
+                                .addImplementsType(genCtx.get(superModule).getKeyType(superChildNode.getPath()));
+                    }
+                }
                 addUsesImplements((DataNodeContainer)superChildNode, superModule, (DataNodeContainer)childNode, module, schemaContext, genCtx, namespaceType);
             }
         }
@@ -333,6 +344,16 @@ final class GenHelperUtil {
         return null;
     }
 
+    static GeneratedTypeBuilder findKeyByPath(final SchemaPath path, final Map<Module, ModuleContext> genCtx) {
+        for (final ModuleContext ctx : genCtx.values()) {
+            final GeneratedTypeBuilder result = ctx.getKeyType(path);
+            if (result != null) {
+                return result;
+            }
+        }
+        return null;
+    }
+
     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,
@@ -698,38 +719,64 @@ final class GenHelperUtil {
                 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());
+
+            Type getterReturnType = Types.listTypeFor(genType);
+            if (namespaceType.equals(BindingNamespaceType.Grouping)) {
+                getterReturnType = Types.listTypeFor(wildcardTypeFor(genType.getPackageName(), genType.getName(),
+                                true, true));
+            }
+            constructGetter(parent, nodeName, node.getDescription(), getterReturnType, node.getStatus());
+
             final List<QName> listKeys = node.getKeyDefinition();
             final String packageName = new StringBuilder(packageNameForGeneratedType(basePackageName, node.getPath(),
                     BindingNamespaceType.Key)).append('.').append(nodeName).toString();
+            //FIXME: Is it neccessary to generate interface of key and implemented by class?
+            if (namespaceType.equals(BindingNamespaceType.Grouping)) {
+                final GeneratedTypeBuilder genTypeBuilder = resolveListKeyTypeBuilder(packageName, node);
+                for (final DataSchemaNode schemaNode : node.getChildNodes()) {
+                    if (!schemaNode.isAugmenting()) {
+                        addSchemaNodeToListTypeBuilders(nodeName, basePackageName, schemaNode, genType, genTypeBuilder, listKeys,
+                                module, typeProvider, schemaContext, genCtx, genTypeBuilders, verboseClassComments, namespaceType);
+                    }
+                }
+                if (genTypeBuilder != null) {
+                    typeBuildersToGenTypes(module, genType, genTypeBuilder.toInstance(), genCtx, namespaceType);
+                    genCtx.get(module).addKeyType(node.getPath(), genTypeBuilder);
+                }
+            } else {
+                final GeneratedTOBuilder genTOBuilder = resolveListKeyTOBuilder(packageName, node);
+                for (final DataSchemaNode schemaNode : node.getChildNodes()) {
+                    if (!schemaNode.isAugmenting()) {
+                        addSchemaNodeToListBuilders(nodeName, basePackageName, schemaNode, genType, genTOBuilder, listKeys,
+                                module, typeProvider, schemaContext, genCtx, genTypeBuilders, verboseClassComments, namespaceType);
+                    }
+                }
 
-            final GeneratedTOBuilder genTOBuilder = resolveListKeyTOBuilder(packageName, node);
+                // serialVersionUID
+                if (genTOBuilder != null) {
+                    final GeneratedPropertyBuilder prop = new GeneratedPropertyBuilderImpl("serialVersionUID");
+                    prop.setValue(Long.toString(computeDefaultSUID(genTOBuilder)));
+                    genTOBuilder.setSUID(prop);
 
-            for (final DataSchemaNode schemaNode : node.getChildNodes()) {
-                if (!schemaNode.isAugmenting()) {
-                    addSchemaNodeToListBuilders(nodeName, basePackageName, schemaNode, genType, genTOBuilder, listKeys,
-                            module, typeProvider, schemaContext, genCtx, genTypeBuilders, verboseClassComments, namespaceType);
+                    typeBuildersToGenTypes(module, genType, genTOBuilder.toInstance(), genCtx, namespaceType);
+                    genCtx.get(module).addGeneratedTOBuilder(node.getPath(), genTOBuilder);
                 }
             }
-
-            // serialVersionUID
-            if (genTOBuilder != null) {
-                final GeneratedPropertyBuilder prop = new GeneratedPropertyBuilderImpl("serialVersionUID");
-                prop.setValue(Long.toString(computeDefaultSUID(genTOBuilder)));
-                genTOBuilder.setSUID(prop);
-            }
-
-            typeBuildersToGenTypes(module, genType, genTOBuilder, genCtx);
         }
     }
 
     private static void typeBuildersToGenTypes(final Module module, final GeneratedTypeBuilder typeBuilder,
-            final GeneratedTOBuilder genTOBuilder, final Map<Module, ModuleContext> genCtx) {
+            final Type keyType, final Map<Module, ModuleContext> genCtx,
+            final BindingNamespaceType namespaceType) {
         checkArgument(typeBuilder != null, "Generated Type Builder cannot be NULL.");
-        if (genTOBuilder != null) {
-            final GeneratedTransferObject genTO = genTOBuilder.toInstance();
-            constructGetter(typeBuilder, "key", "Returns Primary Key of Yang List Type", genTO, Status.CURRENT);
-            genCtx.get(module).addGeneratedTOBuilder(genTOBuilder);
+        if (keyType != null) {
+            Type returnKeyType = keyType;
+            if (namespaceType.equals(BindingNamespaceType.Grouping)) {
+                returnKeyType = wildcardTypeFor(keyType.getPackageName(), keyType.getName(),
+                        true, true);
+            }
+            constructGetter(typeBuilder, "key", "Returns Primary Key of Yang List Type", returnKeyType, Status.CURRENT);
+
         }
     }
 
@@ -1069,13 +1116,48 @@ final class GenHelperUtil {
                     typeProvider);
             if (listKeys.contains(leafQName)) {
                 if (type == null) {
-                    resolveLeafSchemaNodeAsProperty(schemaContext, typeProvider, genCtx, genTOBuilder, leaf, true,
+                    resolveLeafSchemaNodeAsProperty(nodeName, schemaContext, typeProvider, genCtx, genTOBuilder, leaf, true,
                         module);
                 } else {
-                    AuxiliaryGenUtils.resolveLeafSchemaNodeAsProperty(genTOBuilder, leaf, type, true);
+                    AuxiliaryGenUtils.resolveLeafSchemaNodeAsProperty(nodeName, genTOBuilder, leaf, type, true);
                 }
             }
-        } else if (!schemaNode.isAddedByUses()) {
+        } else {
+            if (schemaNode instanceof LeafListSchemaNode) {
+                resolveLeafListSchemaNode(schemaContext, typeBuilder, (LeafListSchemaNode) schemaNode, module,
+                        typeProvider, genCtx);
+            } else if (schemaNode instanceof ContainerSchemaNode) {
+                containerToGenType(module, basePackageName, typeBuilder, typeBuilder, (ContainerSchemaNode) schemaNode,
+                        schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType);
+            } else if (schemaNode instanceof ListSchemaNode) {
+                listToGenType(module, basePackageName, typeBuilder, typeBuilder, (ListSchemaNode) schemaNode,
+                        schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType);
+            } else if (schemaNode instanceof ChoiceSchemaNode) {
+                choiceToGenType(module, schemaContext, verboseClassComments, basePackageName, typeBuilder,
+                        (ChoiceSchemaNode) schemaNode, genTypeBuilders, genCtx, typeProvider, namespaceType);
+            }
+        }
+    }
+
+    private static void addSchemaNodeToListTypeBuilders(final String nodeName, final String basePackageName,
+                                                    final DataSchemaNode schemaNode, final GeneratedTypeBuilder typeBuilder,
+                                                    final GeneratedTypeBuilder genTypeBuilder, 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 BindingNamespaceType namespaceType) {
+        checkArgument(schemaNode != null, "Data Schema Node cannot be NULL.");
+        checkArgument(typeBuilder != null, "Generated Type Builder cannot be NULL.");
+
+        if (schemaNode instanceof LeafSchemaNode) {
+            final LeafSchemaNode leaf = (LeafSchemaNode) schemaNode;
+            final QName leafQName = leaf.getQName();
+            final Type type = resolveLeafSchemaNodeAsMethod(nodeName, schemaContext, typeBuilder, genCtx, leaf, module,
+                    typeProvider);
+            if (listKeys.contains(leafQName)) {
+                resolveLeafSchemaNodeAsMethod(nodeName, schemaContext, genTypeBuilder, genCtx, leaf, module,
+                        typeProvider);
+            }
+        } else {
             if (schemaNode instanceof LeafListSchemaNode) {
                 resolveLeafListSchemaNode(schemaContext, typeBuilder, (LeafListSchemaNode) schemaNode, module,
                         typeProvider, genCtx);
@@ -1092,7 +1174,7 @@ final class GenHelperUtil {
         }
     }
 
-    private static boolean resolveLeafSchemaNodeAsProperty(final SchemaContext schemaContext, final TypeProvider
+    private static boolean resolveLeafSchemaNodeAsProperty(final String nodeName, final SchemaContext schemaContext, final TypeProvider
             typeProvider, final Map<Module, ModuleContext> genCtx, final GeneratedTOBuilder
             toBuilder, final LeafSchemaNode leaf, final boolean isReadOnly, final Module module) {
 
@@ -1117,7 +1199,7 @@ final class GenHelperUtil {
             } else {
                 returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf);
             }
-            return AuxiliaryGenUtils.resolveLeafSchemaNodeAsProperty(toBuilder, leaf, returnType, isReadOnly);
+            return AuxiliaryGenUtils.resolveLeafSchemaNodeAsProperty(nodeName, toBuilder, leaf, returnType, isReadOnly);
         }
         return false;
     }

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 d72226afc0d586d6851be3a89dacd071bdd786cb..df15698b2f732ec2ce0385846997bfc4cf25a940 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
@@ -42,7 +42,7 @@ import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
 @Beta
 public final class ModuleContext {
     private GeneratedTypeBuilder moduleNode;
-    private final List<GeneratedTOBuilder> genTOs = new ArrayList<>();
+    private final Map<SchemaPath,GeneratedTOBuilder> genTOs = new HashMap<>();
     private final Map<SchemaPath, Type> typedefs = new HashMap<>();
     private final Map<SchemaPath, GeneratedTypeBuilder> childNodes = new HashMap<>();
     private final BiMap<String, GeneratedTypeBuilder> dataTypes = HashBiMap.create();
@@ -57,7 +57,7 @@ public final class ModuleContext {
     private final Multimap<Type, Type> choiceToCases = HashMultimap.create();
     private final BiMap<Type,ChoiceCaseNode> caseTypeToSchema = HashBiMap.create();
     private final Map<SchemaPath, Type> innerTypes = new HashMap<>();
-
+    private final Map<SchemaPath,GeneratedTypeBuilder> keyTypes = new HashMap<>();
 
     List<Type> getGeneratedTypes() {
         final List<Type> result = new ArrayList<>();
@@ -66,7 +66,7 @@ public final class ModuleContext {
             result.add(this.moduleNode.toInstance());
         }
 
-        result.addAll(this.genTOs.stream().map(GeneratedTOBuilder::toInstance).collect(Collectors.toList()));
+        result.addAll(this.genTOs.values().stream().map(GeneratedTOBuilder::toInstance).collect(Collectors.toList()));
         result.addAll(this.typedefs.values().stream().filter(b -> b != null).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()));
@@ -74,7 +74,7 @@ public final class ModuleContext {
         result.addAll(this.identities.values().stream().map(GeneratedTOBuilder::toInstance).collect(Collectors.toList()));
         result.addAll(this.topLevelNodes.stream().map(GeneratedTypeBuilder::toInstance).collect(Collectors.toList()));
         result.addAll(this.augmentations.stream().map(GeneratedTypeBuilder::toInstance).collect(Collectors.toList()));
-
+        result.addAll(this.keyTypes.values().stream().map(GeneratedTypeBuilder::toInstance).collect(Collectors.toList()));
         return ImmutableList.copyOf(result);
     }
 
@@ -102,8 +102,8 @@ public final class ModuleContext {
         this.moduleNode = moduleNode;
     }
 
-    public void addGeneratedTOBuilder(final GeneratedTOBuilder b) {
-        this.genTOs.add(b);
+    public void addGeneratedTOBuilder(final SchemaPath schemaPath, final GeneratedTOBuilder b) {
+        this.genTOs.put(schemaPath, b);
     }
 
     public void addChildNodeType(final SchemaNode p, final GeneratedTypeBuilder b) {
@@ -222,4 +222,16 @@ public final class ModuleContext {
         return this.innerTypes.get(path);
     }
 
+
+    void addKeyType(final SchemaPath path, final GeneratedTypeBuilder genType) {
+        this.keyTypes.put(path, genType);
+    }
+
+    public GeneratedTypeBuilder getKeyType(final SchemaPath path) {
+        return this.keyTypes.get(path);
+    }
+
+    public GeneratedTOBuilder getKeyGenTO(final SchemaPath path) {
+        return this.genTOs.get(path);
+    }
 }

diff --git a/binding2/mdsal-binding2-generator-impl/src/test/java/org/opendaylight/mdsal/binding/javav2/generator/impl/AuxiliaryGenUtilsTest.java b/binding2/mdsal-binding2-generator-impl/src/test/java/org/opendaylight/mdsal/binding/javav2/generator/impl/AuxiliaryGenUtilsTest.java
index 0821848fe5f30dd251043ec929747095e26bdc01..b29d96ac3327f636641b636f3703c42a04175c78 100644 (file)
--- a/binding2/mdsal-binding2-generator-impl/src/test/java/org/opendaylight/mdsal/binding/javav2/generator/impl/AuxiliaryGenUtilsTest.java
+++ b/binding2/mdsal-binding2-generator-impl/src/test/java/org/opendaylight/mdsal/binding/javav2/generator/impl/AuxiliaryGenUtilsTest.java
@@ -597,7 +597,7 @@ public class AuxiliaryGenUtilsTest {
     @SuppressWarnings({ "rawtypes" })
     @Test
     public void resolveLeafSchemaNodeAsPropertyFalseTest() throws Exception {
-        final Class[] parameterTypes = { GeneratedTOBuilder.class, LeafSchemaNode.class, Type.class, boolean.class };
+        final Class[] parameterTypes = { String.class, GeneratedTOBuilder.class, LeafSchemaNode.class, Type.class, boolean.class };
         final Method generate =
                 AuxiliaryGenUtils.class.getDeclaredMethod("resolveLeafSchemaNodeAsProperty", parameterTypes);
         assertNotNull(generate);
@@ -608,7 +608,7 @@ public class AuxiliaryGenUtilsTest {
         final boolean isReadOnly = true;
         final Type type = null;
 
-        final Object[] args2 = { gtob, leaf, type, isReadOnly };
+        final Object[] args2 = { "list", gtob, leaf, type, isReadOnly };
         final boolean result = (boolean) generate.invoke(AuxiliaryGenUtils.class, args2);
         assertNotNull(result);
         assertTrue(!result);
@@ -617,7 +617,7 @@ public class AuxiliaryGenUtilsTest {
     @SuppressWarnings({ "rawtypes" })
     @Test
     public void resolveLeafSchemaNodeAsPropertyTrueTest() throws Exception {
-        final Class[] parameterTypes = { GeneratedTOBuilder.class, LeafSchemaNode.class, Type.class, boolean.class };
+        final Class[] parameterTypes = { String.class, GeneratedTOBuilder.class, LeafSchemaNode.class, Type.class, boolean.class };
         final Method generate =
                 AuxiliaryGenUtils.class.getDeclaredMethod("resolveLeafSchemaNodeAsProperty", parameterTypes);
         assertNotNull(generate);
@@ -629,7 +629,7 @@ public class AuxiliaryGenUtilsTest {
         final Type type = mock(Type.class);
         when(leaf.getQName()).thenReturn(QName.create("ns", "2017-12-04", "ln"));
 
-        final Object[] args2 = { gtob, leaf, type, isReadOnly };
+        final Object[] args2 = { "list", gtob, leaf, type, isReadOnly };
         final boolean result = (boolean) generate.invoke(AuxiliaryGenUtils.class, args2);
         assertNotNull(result);
         assertTrue(result);

diff --git a/binding2/mdsal-binding2-generator-impl/src/test/java/org/opendaylight/mdsal/binding/javav2/generator/impl/BindingGeneratorImplTest.java b/binding2/mdsal-binding2-generator-impl/src/test/java/org/opendaylight/mdsal/binding/javav2/generator/impl/BindingGeneratorImplTest.java
index aa92f2e44c75897fedc859f652e3c0105aa29e33..073c6d7c9def6e77568de09870af21e28b278c6a 100644 (file)
--- a/binding2/mdsal-binding2-generator-impl/src/test/java/org/opendaylight/mdsal/binding/javav2/generator/impl/BindingGeneratorImplTest.java
+++ b/binding2/mdsal-binding2-generator-impl/src/test/java/org/opendaylight/mdsal/binding/javav2/generator/impl/BindingGeneratorImplTest.java
@@ -87,15 +87,15 @@ public class BindingGeneratorImplTest {
                 int test_j = 0;
                 for (final GeneratedProperty generatedProperty : genTransferObj.getProperties()) {
                     switch (generatedProperty.getName()) {
-                        case "key":
+                        case "myListKey":
                             assertEquals("String", generatedProperty.getReturnType().getName());
                             test_j++;
                             break;
-                        case "key1":
+                        case "myListKey1":
                             assertEquals("String", generatedProperty.getReturnType().getName());
                             test_j++;
                             break;
-                        case "key2":
+                        case "myListKey2":
                             assertEquals("String", generatedProperty.getReturnType().getName());
                             test_j++;
                             break;

diff --git a/binding2/mdsal-binding2-generator-impl/src/test/resources/uses-statement/test-uses-list.yang b/binding2/mdsal-binding2-generator-impl/src/test/resources/uses-statement/test-uses-list.yang
new file mode 100644 (file)
index 0000000..8f55bc2
--- /dev/null
+++ b/binding2/mdsal-binding2-generator-impl/src/test/resources/uses-statement/test-uses-list.yang
@@ -0,0 +1,25 @@
+module test-uses-list {
+    yang-version 1.1;
+
+    namespace "urn:test:uses:list";
+    prefix test-uses-list;
+    organization "test.type.org";
+    revision "2017-06-30";
+
+    grouping my-grouping {
+        list my-list {
+            key "my-leaf";
+            leaf my-leaf {
+                type string;
+            }
+
+            leaf my-leaf-two {
+                type string;
+            }
+        }
+    }
+
+    container my-cont {
+        uses my-grouping;
+    }
+}
\ No newline at end of file

diff --git a/binding2/mdsal-binding2-java-api-generator/src/main/java/org/opendaylight/mdsal/binding/javav2/java/api/generator/GeneratorJavaFile.java b/binding2/mdsal-binding2-java-api-generator/src/main/java/org/opendaylight/mdsal/binding/javav2/java/api/generator/GeneratorJavaFile.java
index 70a73c4843ec3bfba265c3223fe13d6301d7824b..74cb9215b117c04575a69b2713b9f2aac6cc56bf 100644 (file)
--- a/binding2/mdsal-binding2-java-api-generator/src/main/java/org/opendaylight/mdsal/binding/javav2/java/api/generator/GeneratorJavaFile.java
+++ b/binding2/mdsal-binding2-java-api-generator/src/main/java/org/opendaylight/mdsal/binding/javav2/java/api/generator/GeneratorJavaFile.java
@@ -187,7 +187,7 @@ public final class GeneratorJavaFile {
         if (generator.isAcceptable(type)) {
             File packageDir;
             if (generator instanceof BuilderGenerator) {
-                Preconditions.checkState(type instanceof GeneratedTypeForBuilder);
+                Preconditions.checkState(type instanceof GeneratedTypeForBuilder, type.getFullyQualifiedName());
                 packageDir = packageToDirectory(parentDir, ((GeneratedTypeForBuilder)type).getPackageNameForBuilder());
             } else {
                 packageDir = packageToDirectory(parentDir, type.getPackageName());

diff --git a/binding2/mdsal-binding2-java-api-generator/src/main/java/org/opendaylight/mdsal/binding/javav2/java/api/generator/renderers/BuilderRenderer.java b/binding2/mdsal-binding2-java-api-generator/src/main/java/org/opendaylight/mdsal/binding/javav2/java/api/generator/renderers/BuilderRenderer.java
index 95a34df1f4e78ed813ffaafdf5edf13468801673..75d2cc069de8bd77170a51dc69e287321e7ca2bd 100644 (file)
--- a/binding2/mdsal-binding2-java-api-generator/src/main/java/org/opendaylight/mdsal/binding/javav2/java/api/generator/renderers/BuilderRenderer.java
+++ b/binding2/mdsal-binding2-java-api-generator/src/main/java/org/opendaylight/mdsal/binding/javav2/java/api/generator/renderers/BuilderRenderer.java
@@ -175,8 +175,11 @@ public class BuilderRenderer extends BaseRenderer {
             for (Type implementedIfc : implementedIfcs) {
                 if ((implementedIfc instanceof GeneratedType && !(implementedIfc instanceof GeneratedTransferObject))) {
                     final GeneratedType ifc = (GeneratedType) implementedIfc;
-                    methods.addAll(ifc.getMethodDefinitions());
-                    collectImplementedMethods(methods, ifc.getImplements());
+                    //TODO:temporarily eliminated for through compiling, to be restored in "support choice" patch.
+                  //  if (implementedIfc instanceof GeneratedTypeForBuilder) {
+                        methods.addAll(ifc.getMethodDefinitions());
+                        collectImplementedMethods(methods, ifc.getImplements());
+                  //  }
                 } else if (Augmentable.class.getName().equals(implementedIfc.getFullyQualifiedName())) {
                     for (Method method : Augmentable.class.getMethods()) {
                         if ("getAugmentation".equals(method.getName())) {

diff --git a/binding2/mdsal-binding2-java-api-generator/src/main/twirl/org/opendaylight/mdsal/binding/javav2/java/api/generator/builderTemplate.scala.txt b/binding2/mdsal-binding2-java-api-generator/src/main/twirl/org/opendaylight/mdsal/binding/javav2/java/api/generator/builderTemplate.scala.txt
index d7eb8d7114614cf501bb694234e671332fa11b32..f29a2b01d1f9f86f1cd05309d29d800f87870512 100644 (file)
--- a/binding2/mdsal-binding2-java-api-generator/src/main/twirl/org/opendaylight/mdsal/binding/javav2/java/api/generator/builderTemplate.scala.txt
+++ b/binding2/mdsal-binding2-java-api-generator/src/main/twirl/org/opendaylight/mdsal/binding/javav2/java/api/generator/builderTemplate.scala.txt
@@ -22,6 +22,7 @@
 @import org.opendaylight.mdsal.binding.javav2.java.api.generator.rangeGenerators.LengthGenerator
 @import org.opendaylight.mdsal.binding.javav2.model.api.ConcreteType
 @import org.opendaylight.mdsal.binding.javav2.model.api.GeneratedType
+@import org.opendaylight.mdsal.binding.javav2.model.api.GeneratedTypeForBuilder
 @import org.opendaylight.mdsal.binding.javav2.model.api.GeneratedTransferObject
 @import org.opendaylight.mdsal.binding.javav2.model.api.GeneratedProperty
 @import org.opendaylight.mdsal.binding.javav2.model.api.Type
@@ -128,7 +129,8 @@ public class @{genType.getName}Builder implements @{getSimpleNameForBuilder} <@{
 }
 
 @generateMethodFieldsFrom() = {
-    @if(genType.isInstanceOf[GeneratedType] && !genType.isInstanceOf[GeneratedTransferObject]) {
+    @if(genType.isInstanceOf[GeneratedType] && genType.isInstanceOf[GeneratedTypeForBuilder]
+            && !genType.isInstanceOf[GeneratedTransferObject]) {
         @if(hasImplementsFromUses(genType.asInstanceOf[GeneratedType])) {
             /**
              * Set fields from given grouping argument. Valid argument is instance of one of following types:
@@ -145,9 +147,11 @@ public class @{genType.getName}Builder implements @{getSimpleNameForBuilder} <@{
             public void fieldsFrom(@{importedNames.get("treeNode")} arg) {
                 boolean isValidArg = false;
                 @for(impl <- getAllIfcs(genType.asInstanceOf[GeneratedType])) {
-                    @if(impl.isInstanceOf[GeneratedType] && !impl.asInstanceOf[GeneratedType].getMethodDefinitions.isEmpty) {
+                    @if(impl.isInstanceOf[GeneratedType] && impl.isInstanceOf[GeneratedTypeForBuilder]
+                            && !impl.asInstanceOf[GeneratedType].getMethodDefinitions.isEmpty) {
                         if (arg instanceof @{impl.asInstanceOf[GeneratedType].getFullyQualifiedName}) {
-                            @if(impl.isInstanceOf[GeneratedType] && !impl.isInstanceOf[GeneratedTransferObject]) {
+                            @if(impl.isInstanceOf[GeneratedType] && impl.isInstanceOf[GeneratedTypeForBuilder]
+                                    && !impl.isInstanceOf[GeneratedTransferObject]) {
                                 @for(getter <- impl.asInstanceOf[GeneratedType].getMethodDefinitions) {
                                     this._@{propertyNameFromGetter(getter)} = ((@{impl.asInstanceOf[GeneratedType].getFullyQualifiedName})arg).@{getter.getName}();
                                 }
@@ -171,7 +175,7 @@ public class @{genType.getName}Builder implements @{getSimpleNameForBuilder} <@{
  * Generate constructor with argument of given type.
  *@
 @generateConstructorFromIfc(impl: Type) = {
-    @if(impl.isInstanceOf[GeneratedType]) {
+    @if(impl.isInstanceOf[GeneratedType] && impl.isInstanceOf[GeneratedTypeForBuilder]) {
         @if(!impl.asInstanceOf[GeneratedType].getMethodDefinitions.isEmpty) {
             public @{genType.getName}Builder(
             @{impl.getFullyQualifiedName} arg) {