From: Jozef Gloncak Date: Wed, 24 Jul 2013 11:34:28 +0000 (+0200) Subject: Added uses to extends list. X-Git-Tag: releasepom-0.1.0~255^2 X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=commitdiff_plain;h=b4d71d207d8c5e96a8b6dac8804a4a0de03812a8 Added uses to extends list. Groupings in YANG are used through key word uses. YANG elements which contains uses "something" are now generated as interface which extends "something". Change-Id: Icc3db4191876e31cf1d27d9ddc71e4b0702a956f Signed-off-by: Jozef Gloncak --- diff --git a/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/main/java/org/opendaylight/controller/sal/binding/generator/impl/BindingGeneratorImpl.java b/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/main/java/org/opendaylight/controller/sal/binding/generator/impl/BindingGeneratorImpl.java index 6700b470fa..bc767edd2d 100644 --- a/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/main/java/org/opendaylight/controller/sal/binding/generator/impl/BindingGeneratorImpl.java +++ b/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/main/java/org/opendaylight/controller/sal/binding/generator/impl/BindingGeneratorImpl.java @@ -7,12 +7,14 @@ */ package org.opendaylight.controller.sal.binding.generator.impl; -import static org.opendaylight.controller.binding.generator.util.BindingGeneratorUtil.*; +import static org.opendaylight.controller.binding.generator.util.BindingGeneratorUtil.moduleNamespaceToPackageName; +import static org.opendaylight.controller.binding.generator.util.BindingGeneratorUtil.packageNameForGeneratedType; +import static org.opendaylight.controller.binding.generator.util.BindingGeneratorUtil.parseToClassName; +import static org.opendaylight.controller.binding.generator.util.BindingGeneratorUtil.parseToValidParamName; +import static org.opendaylight.controller.binding.generator.util.BindingGeneratorUtil.schemaNodeToTransferObjectBuilder; import static org.opendaylight.controller.yang.model.util.SchemaContextUtil.findDataSchemaNode; import static org.opendaylight.controller.yang.model.util.SchemaContextUtil.findParentModule; -import java.util.concurrent.Future; - import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; @@ -20,6 +22,7 @@ import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Set; +import java.util.concurrent.Future; import org.opendaylight.controller.binding.generator.util.ReferencedTypeImpl; import org.opendaylight.controller.binding.generator.util.Types; @@ -35,6 +38,7 @@ import org.opendaylight.controller.sal.binding.model.api.type.builder.GeneratedP import org.opendaylight.controller.sal.binding.model.api.type.builder.GeneratedTOBuilder; import org.opendaylight.controller.sal.binding.model.api.type.builder.GeneratedTypeBuilder; import org.opendaylight.controller.sal.binding.model.api.type.builder.MethodSignatureBuilder; +import org.opendaylight.controller.sal.binding.yang.types.GroupingDefinitionDependencySort; import org.opendaylight.controller.sal.binding.yang.types.TypeProviderImpl; import org.opendaylight.controller.yang.binding.Notification; import org.opendaylight.controller.yang.common.QName; @@ -57,6 +61,7 @@ import org.opendaylight.controller.yang.model.api.SchemaContext; import org.opendaylight.controller.yang.model.api.SchemaNode; import org.opendaylight.controller.yang.model.api.SchemaPath; import org.opendaylight.controller.yang.model.api.TypeDefinition; +import org.opendaylight.controller.yang.model.api.UsesNode; import org.opendaylight.controller.yang.model.api.type.BitsTypeDefinition; import org.opendaylight.controller.yang.model.api.type.EnumTypeDefinition; import org.opendaylight.controller.yang.model.api.type.EnumTypeDefinition.EnumPair; @@ -70,6 +75,7 @@ public final class BindingGeneratorImpl implements BindingGenerator { private Map> genTypeBuilders; private TypeProvider typeProvider; private SchemaContext schemaContext; + private final Map allGroupings = new HashMap(); public BindingGeneratorImpl() { super(); @@ -90,6 +96,7 @@ public final class BindingGeneratorImpl implements BindingGenerator { final Set modules = context.getModules(); genTypeBuilders = new HashMap<>(); for (final Module module : modules) { + generatedTypes.addAll(allGroupingsToGenTypes(module)); generatedTypes.add(moduleToDataType(module)); generatedTypes.addAll(allTypeDefinitionsToGenTypes(module)); generatedTypes.addAll(allContainersToGenTypes(module)); @@ -99,7 +106,7 @@ public final class BindingGeneratorImpl implements BindingGenerator { generatedTypes.addAll(allRPCMethodsToGenType(module)); generatedTypes.addAll(allNotificationsToGenType(module)); generatedTypes.addAll(allIdentitiesToGenTypes(module, context)); - generatedTypes.addAll(allGroupingsToGenTypes(module)); + } return generatedTypes; } @@ -124,6 +131,7 @@ public final class BindingGeneratorImpl implements BindingGenerator { for (final Module contextModule : contextModules) { final List generatedTypes = new ArrayList<>(); + generatedTypes.addAll(allGroupingsToGenTypes(contextModule)); generatedTypes.add(moduleToDataType(contextModule)); generatedTypes.addAll(allTypeDefinitionsToGenTypes(contextModule)); generatedTypes.addAll(allContainersToGenTypes(contextModule)); @@ -133,7 +141,6 @@ public final class BindingGeneratorImpl implements BindingGenerator { generatedTypes.addAll(allRPCMethodsToGenType(contextModule)); generatedTypes.addAll(allNotificationsToGenType(contextModule)); generatedTypes.addAll(allIdentitiesToGenTypes(contextModule, context)); - generatedTypes.addAll(allGroupingsToGenTypes(contextModule)); if (modules.contains(contextModule)) { filteredGenTypes.addAll(generatedTypes); @@ -185,7 +192,9 @@ public final class BindingGeneratorImpl implements BindingGenerator { final List schemaContainers = it.allContainers(); final String basePackageName = moduleNamespaceToPackageName(module); for (final ContainerSchemaNode container : schemaContainers) { - generatedTypes.add(containerToGenType(basePackageName, container)); + if (!container.isAddedByUses()) { + generatedTypes.add(containerToGenType(basePackageName, container)); + } } return generatedTypes; } @@ -210,7 +219,9 @@ public final class BindingGeneratorImpl implements BindingGenerator { final String basePackageName = moduleNamespaceToPackageName(module); if (schemaLists != null) { for (final ListSchemaNode list : schemaLists) { - generatedTypes.addAll(listToGenType(basePackageName, list)); + if (!list.isAddedByUses()) { + generatedTypes.addAll(listToGenType(basePackageName, list)); + } } } return generatedTypes; @@ -230,7 +241,7 @@ public final class BindingGeneratorImpl implements BindingGenerator { final List generatedTypes = new ArrayList<>(); for (final ChoiceNode choice : choiceNodes) { - if (choice != null) { + if ((choice != null) && !choice.isAddedByUses()) { generatedTypes.addAll(choiceToGeneratedType(basePackageName, choice)); } } @@ -292,6 +303,7 @@ public final class BindingGeneratorImpl implements BindingGenerator { } final GeneratedTypeBuilder moduleDataTypeBuilder = moduleTypeBuilder(module, "Data"); + addInterfaceDefinition(module, moduleDataTypeBuilder); final String basePackageName = moduleNamespaceToPackageName(module); if (moduleDataTypeBuilder != null) { @@ -335,6 +347,7 @@ public final class BindingGeneratorImpl implements BindingGenerator { if (input != null) { rpcInOut.add(new DataNodeIterator(input)); GeneratedTypeBuilder inType = addRawInterfaceDefinition(basePackageName, input, rpcName); + addInterfaceDefinition(input, inType); resolveDataSchemaNodes(basePackageName, inType, input.getChildNodes()); Type inTypeInstance = inType.toInstance(); genRPCTypes.add(inTypeInstance); @@ -344,8 +357,8 @@ public final class BindingGeneratorImpl implements BindingGenerator { Type outTypeInstance = Types.typeForClass(Void.class); if (output != null) { rpcInOut.add(new DataNodeIterator(output)); - GeneratedTypeBuilder outType = addRawInterfaceDefinition(basePackageName, output, rpcName); + addInterfaceDefinition(output, outType); resolveDataSchemaNodes(basePackageName, outType, output.getChildNodes()); outTypeInstance = outType.toInstance(); genRPCTypes.add(outTypeInstance); @@ -358,13 +371,17 @@ public final class BindingGeneratorImpl implements BindingGenerator { List nContainers = it.allContainers(); if ((nContainers != null) && !nContainers.isEmpty()) { for (final ContainerSchemaNode container : nContainers) { - genRPCTypes.add(containerToGenType(basePackageName, container)); + if (!container.isAddedByUses()) { + genRPCTypes.add(containerToGenType(basePackageName, container)); + } } } List nLists = it.allLists(); if ((nLists != null) && !nLists.isEmpty()) { for (final ListSchemaNode list : nLists) { - genRPCTypes.addAll(listToGenType(basePackageName, list)); + if (!list.isAddedByUses()) { + genRPCTypes.addAll(listToGenType(basePackageName, list)); + } } } } @@ -398,11 +415,15 @@ public final class BindingGeneratorImpl implements BindingGenerator { // Containers for (ContainerSchemaNode node : it.allContainers()) { - genNotifyTypes.add(containerToGenType(basePackageName, node)); + if (!node.isAddedByUses()) { + genNotifyTypes.add(containerToGenType(basePackageName, node)); + } } // Lists for (ListSchemaNode node : it.allLists()) { - genNotifyTypes.addAll(listToGenType(basePackageName, node)); + if (!node.isAddedByUses()) { + genNotifyTypes.addAll(listToGenType(basePackageName, node)); + } } final GeneratedTypeBuilder notificationTypeBuilder = addDefaultInterfaceDefinition(basePackageName, notification); @@ -460,10 +481,16 @@ public final class BindingGeneratorImpl implements BindingGenerator { final List genTypes = new ArrayList<>(); final String basePackageName = moduleNamespaceToPackageName(module); final Set groupings = module.getGroupings(); - if (groupings != null && !groupings.isEmpty()) { - for (final GroupingDefinition grouping : groupings) { - genTypes.add(groupingToGenType(basePackageName, grouping)); - } + List groupingsSortedByDependencies; + // groupingsSortedByDependencies = + // sortGroupingDefinitionsByUses(groupings); + groupingsSortedByDependencies = GroupingDefinitionDependencySort.sort(groupings); + + for (final GroupingDefinition grouping : groupingsSortedByDependencies) { + GeneratedType genType = groupingToGenType(basePackageName, grouping); + genTypes.add(genType); + SchemaPath schemaPath = grouping.getPath(); + allGroupings.put(schemaPath, genType); } return genTypes; } @@ -562,6 +589,8 @@ public final class BindingGeneratorImpl implements BindingGenerator { if (!(targetSchemaNode instanceof ChoiceNode)) { final GeneratedTypeBuilder augTypeBuilder = addRawAugmentGenTypeDefinition(augmentPackageName, targetPackageName, targetSchemaNodeName, augSchema); + addInterfaceDefinition(augSchema, augTypeBuilder); + final GeneratedType augType = augTypeBuilder.toInstance(); genTypes.add(augType); } else { @@ -686,7 +715,7 @@ public final class BindingGeneratorImpl implements BindingGenerator { final GeneratedTypeBuilder typeBuilder, final Set schemaNodes) { if ((schemaNodes != null) && (typeBuilder != null)) { for (final DataSchemaNode schemaNode : schemaNodes) { - if (schemaNode.isAugmenting()) { + if (schemaNode.isAugmenting() || schemaNode.isAddedByUses()) { continue; } addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode, typeBuilder); @@ -737,7 +766,7 @@ public final class BindingGeneratorImpl implements BindingGenerator { } final String choiceName = choiceNode.getQName().getLocalName(); - if (choiceName != null) { + if (choiceName != null && !choiceNode.isAddedByUses()) { final String packageName = packageNameForGeneratedType(basePackageName, choiceNode.getPath()); final GeneratedTypeBuilder choiceType = addDefaultInterfaceDefinition(packageName, choiceNode); constructGetter(typeBuilder, choiceName, choiceNode.getDescription(), choiceType); @@ -834,7 +863,7 @@ public final class BindingGeneratorImpl implements BindingGenerator { leafDesc = ""; } - if (leafName != null) { + if (leafName != null && !leaf.isAddedByUses()) { final TypeDefinition typeDef = leaf.getType(); Type returnType = null; @@ -879,7 +908,7 @@ public final class BindingGeneratorImpl implements BindingGenerator { leafDesc = ""; } - if (leafName != null) { + if (leafName != null && !leaf.isAddedByUses()) { final TypeDefinition typeDef = leaf.getType(); // TODO: properly resolve enum types @@ -911,7 +940,7 @@ public final class BindingGeneratorImpl implements BindingGenerator { nodeDesc = ""; } - if (nodeName != null) { + if (nodeName != null && !node.isAddedByUses()) { final TypeDefinition type = node.getType(); final Type listType = Types.listTypeFor(typeProvider.javaTypeForSchemaDefinitionType(type)); @@ -927,7 +956,7 @@ public final class BindingGeneratorImpl implements BindingGenerator { if ((containerNode != null) && (typeBuilder != null)) { final String nodeName = containerNode.getQName().getLocalName(); - if (nodeName != null) { + if (nodeName != null && !containerNode.isAddedByUses()) { final String packageName = packageNameForGeneratedType(basePackageName, containerNode.getPath()); final GeneratedTypeBuilder rawGenType = addDefaultInterfaceDefinition(packageName, containerNode); @@ -944,7 +973,7 @@ public final class BindingGeneratorImpl implements BindingGenerator { if ((schemaNode != null) && (typeBuilder != null)) { final String listName = schemaNode.getQName().getLocalName(); - if (listName != null) { + if (listName != null && !schemaNode.isAddedByUses()) { final String packageName = packageNameForGeneratedType(basePackageName, schemaNode.getPath()); final GeneratedTypeBuilder rawGenType = addDefaultInterfaceDefinition(packageName, schemaNode); constructGetter(typeBuilder, listName, schemaNode.getDescription(), Types.listTypeFor(rawGenType)); @@ -967,7 +996,14 @@ public final class BindingGeneratorImpl implements BindingGenerator { private GeneratedTypeBuilder addDefaultInterfaceDefinition(final String packageName, final SchemaNode schemaNode) { final GeneratedTypeBuilder builder = addRawInterfaceDefinition(packageName, schemaNode, ""); builder.addImplementsType(Types.DATA_OBJECT); - builder.addImplementsType(Types.augmentableTypeFor(builder)); + if (!(schemaNode instanceof GroupingDefinition)) { + builder.addImplementsType(Types.augmentableTypeFor(builder)); + } + + if (schemaNode instanceof DataNodeContainer) { + addInterfaceDefinition((DataNodeContainer) schemaNode, builder); + } + return builder; } @@ -1200,4 +1236,27 @@ public final class BindingGeneratorImpl implements BindingGenerator { } + /** + * Adds the implemented types to type builder. The method passes through the + * list of elements which contains {@code dataNodeContainer} and adds them + * as implements type to builder + * + * @param dataNodeContainer + * element which contains the list of used YANG groupings + * @param builder + * builder to which are added implemented types according to + * dataNodeContainer + * @return generated type builder which contains implemented types + */ + private GeneratedTypeBuilder addInterfaceDefinition(final DataNodeContainer dataNodeContainer, + final GeneratedTypeBuilder builder) { + for (UsesNode usesNode : dataNodeContainer.getUses()) { + if (usesNode.getGroupingPath() != null) { + GeneratedType genType = allGroupings.get(usesNode.getGroupingPath()); + builder.addImplementsType(new ReferencedTypeImpl(genType.getPackageName(), genType.getName())); + } + } + return builder; + } + } diff --git a/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/main/java/org/opendaylight/controller/sal/binding/yang/types/GroupingDefinitionDependencySort.java b/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/main/java/org/opendaylight/controller/sal/binding/yang/types/GroupingDefinitionDependencySort.java new file mode 100644 index 0000000000..47e7d447cb --- /dev/null +++ b/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/main/java/org/opendaylight/controller/sal/binding/yang/types/GroupingDefinitionDependencySort.java @@ -0,0 +1,111 @@ +/* + * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.controller.sal.binding.yang.types; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import org.opendaylight.controller.yang.model.api.GroupingDefinition; +import org.opendaylight.controller.yang.model.api.SchemaPath; +import org.opendaylight.controller.yang.model.api.UsesNode; +import org.opendaylight.controller.yang.parser.util.TopologicalSort; +import org.opendaylight.controller.yang.parser.util.TopologicalSort.Node; +import org.opendaylight.controller.yang.parser.util.TopologicalSort.NodeImpl; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.collect.Maps; +import com.google.common.collect.Sets; + +//import org.opendaylight.controller.yang.model.util.GroupingDefinition; + +public class GroupingDefinitionDependencySort { + private static final Logger logger = LoggerFactory.getLogger(GroupingDefinitionDependencySort.class); + + public static List sort(final Set groupingDefinitions) { + if (groupingDefinitions == null) { + logger.error("Set of grouping definitions cannot be NULL!"); + throw new IllegalArgumentException("Set of Type Definitions " + "cannot be NULL!"); + } + + final List resultGroupingDefinitions = new ArrayList(); + final Set unsorted = groupingDefinitionsToGroupingNodes(groupingDefinitions); + final List sortedNodes = TopologicalSort.sort(unsorted); + for (Node node : sortedNodes) { + resultGroupingDefinitions.add(((GroupingNode) node).getGroupingDefinition()); + } + return resultGroupingDefinitions; + + } + + private static Set groupingDefinitionsToGroupingNodes(final Set groupingDefinitions) { + final Map nodeMap = Maps.newHashMap(); + final Set resultNodes = Sets.newHashSet(); + + for (final GroupingDefinition groupingDefinition : groupingDefinitions) { + final Node node = new GroupingNode(groupingDefinition); + nodeMap.put(groupingDefinition.getPath(), node); + resultNodes.add(node); + } + + for (final Node node : resultNodes) { + final GroupingNode groupingNode = (GroupingNode) node; + final GroupingDefinition groupingDefinition = groupingNode.getGroupingDefinition(); + + Set usesNodes = groupingDefinition.getUses(); + for (UsesNode usesNode : usesNodes) { + SchemaPath schemaPath = usesNode.getGroupingPath(); + if (schemaPath != null) { + Node nodeTo = nodeMap.get(schemaPath); + groupingNode.addEdge(nodeTo); + } + } + } + + return resultNodes; + } + + private static final class GroupingNode extends NodeImpl { + private final GroupingDefinition groupingDefinition; + + GroupingNode(GroupingDefinition groupingDefinition) { + this.groupingDefinition = groupingDefinition; + } + + GroupingDefinition getGroupingDefinition() { + return groupingDefinition; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (!(o instanceof GroupingNode)) { + return false; + } + GroupingNode groupingNode = (GroupingNode) o; + if (!groupingDefinition.equals(groupingNode.groupingDefinition)) { + return false; + } + return true; + } + + @Override + public int hashCode() { + return groupingDefinition.hashCode(); + } + + @Override + public String toString() { + return "GroupingNode{" + "groupingType=" + groupingDefinition + '}'; + } + } +} diff --git a/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/test/java/org/opendaylight/controller/sal/binding/generator/impl/UsesTest.java b/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/test/java/org/opendaylight/controller/sal/binding/generator/impl/UsesTest.java new file mode 100644 index 0000000000..6381d93034 --- /dev/null +++ b/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/test/java/org/opendaylight/controller/sal/binding/generator/impl/UsesTest.java @@ -0,0 +1,690 @@ +/* + * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.controller.sal.binding.generator.impl; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; + +import java.io.File; +import java.util.ArrayList; +import java.util.List; +import java.util.Set; + +import org.junit.Test; +import org.opendaylight.controller.sal.binding.generator.api.BindingGenerator; +import org.opendaylight.controller.sal.binding.model.api.GeneratedTransferObject; +import org.opendaylight.controller.sal.binding.model.api.GeneratedType; +import org.opendaylight.controller.sal.binding.model.api.MethodSignature; +import org.opendaylight.controller.sal.binding.model.api.ParameterizedType; +import org.opendaylight.controller.sal.binding.model.api.Type; +import org.opendaylight.controller.yang.model.api.Module; +import org.opendaylight.controller.yang.model.api.SchemaContext; +import org.opendaylight.controller.yang.model.parser.api.YangModelParser; +import org.opendaylight.controller.yang.parser.impl.YangParserImpl; + +public class UsesTest { + + private class MethodSignaturePattern { + final String name; + final String type; + + public MethodSignaturePattern(String methodName, String methodType) { + this.name = methodName; + this.type = methodType; + } + + public String getName() { + return this.name; + } + + public String getType() { + return this.type; + } + } + + private static void containsSignatures(final List searchedSignsIn, + final MethodSignaturePattern... searchedSignsWhat) { + if (searchedSignsIn == null) { + throw new IllegalArgumentException("List of method signatures in which should be searched can't be null"); + } + if (searchedSignsWhat == null) { + throw new IllegalArgumentException("Array of method signatures which should be searched can't be null"); + } + + for (MethodSignaturePattern searchedSignWhat : searchedSignsWhat) { + boolean nameMatchFound = false; + String typeNameFound = ""; + for (MethodSignature searchedSignIn : searchedSignsIn) { + if (searchedSignWhat.getName().equals(searchedSignIn.getName())) { + nameMatchFound = true; + typeNameFound = resolveFullNameOfReturnType(searchedSignIn); + if (searchedSignWhat.getType().equals(typeNameFound)) { + break; + } + } + } + assertTrue("Method " + searchedSignWhat.getName() + " wasn't found.", nameMatchFound); + assertEquals("Return type in method " + searchedSignWhat.getName() + " doesn't match expected type ", + searchedSignWhat.getType(), typeNameFound); + + } + } + + private static String resolveFullNameOfReturnType(final MethodSignature methodSignature) { + final StringBuilder nameBuilder = new StringBuilder(); + if (methodSignature.getReturnType() instanceof ParameterizedType) { + nameBuilder.append(methodSignature.getReturnType().getName() + "<"); + ParameterizedType parametrizedTypes = (ParameterizedType) methodSignature.getReturnType(); + for (Type parametrizedType : parametrizedTypes.getActualTypeArguments()) { + nameBuilder.append(parametrizedType.getName() + ","); + } + if (nameBuilder.charAt(nameBuilder.length() - 1) == ',') { + nameBuilder.deleteCharAt(nameBuilder.length() - 1); + } + nameBuilder.append(">"); + } else { + nameBuilder.append(methodSignature.getReturnType().getName()); + } + return nameBuilder.toString(); + } + + private static boolean containsInterface(String interfaceName, GeneratedType genType) { + List caseCImplements = genType.getImplements(); + for (Type caseCImplement : caseCImplements) { + if (caseCImplement.getName().equals(interfaceName)) { + return true; + } + } + return false; + } + + private static List loadTestResources(String testFile) { + final List testModels = new ArrayList(); + final File listModelFile = new File(UsesTest.class.getResource(testFile).getPath()); + testModels.add(listModelFile); + return testModels; + } + + @Test + public void usesInGroupingDependenciesTest() { + List testModels = loadTestResources("/uses-of-grouping/uses-of-grouping-dependencies.yang"); + final YangModelParser parser = new YangParserImpl(); + final Set modules = parser.parseYangModels(testModels); + final SchemaContext context = parser.resolveSchemaContext(modules); + + assertNotNull(context); + final BindingGenerator bindingGen = new BindingGeneratorImpl(); + final List genTypes = bindingGen.generateTypes(context); + GeneratedType groupingU = null; + GeneratedType groupingX = null; + GeneratedType groupingV = null; + + int groupingUCounter = 0; + int groupingXCounter = 0; + int groupingVCounter = 0; + + for (Type type : genTypes) { + if (type instanceof GeneratedType && !(type instanceof GeneratedTransferObject)) { + GeneratedType genType = (GeneratedType) type; + if (genType.getName().equals("GroupingU")) { + groupingU = genType; + groupingUCounter++; + } else if (genType.getName().equals("GroupingV")) { + groupingV = genType; + groupingVCounter++; + } else if (genType.getName().equals("GroupingX")) { + groupingX = genType; + groupingXCounter++; + } + } + } + + assertNotNull("Generated type for grouping-U wasn't generated.", groupingU); + assertEquals("GroupingU interface generated more than one time.", 1, groupingUCounter); + assertEquals("GroupingU is in wrong package.", + "org.opendaylight.yang.gen.v1.urn.grouping.dependencies.rev2013718", groupingU.getPackageName()); + + assertNotNull("Generated type for grouping-V wasn't generated.", groupingV); + assertEquals("GroupingV interface generated more than one time.", 1, groupingVCounter); + assertEquals("GroupingV is in wrong package.", + "org.opendaylight.yang.gen.v1.urn.grouping.dependencies.rev2013718", groupingV.getPackageName()); + + assertNotNull("Generated type for grouping-X wasn't generated.", groupingX); + assertEquals("GroupingX interface generated more than one time.", 1, groupingXCounter); + assertEquals("GroupingX is in wrong package.", + "org.opendaylight.yang.gen.v1.urn.grouping.dependencies.rev2013718", groupingX.getPackageName()); + + assertTrue("GroupingV doesn't extend GroupingU.", containsInterface("GroupingV", groupingU)); + assertTrue("GroupingX doesn't extend GroupingU.", containsInterface("GroupingX", groupingU)); + assertTrue("GroupingZ doesn't extend GroupingV.", containsInterface("GroupingZ", groupingV)); + assertTrue("GroupingZZ doesn't extend GroupingV.", containsInterface("GroupingZZ", groupingV)); + assertTrue("GroupingY doesn't extend GroupingX.", containsInterface("GroupingY", groupingX)); + } + + @Test + public void usesInCaseTest() { + List testModels = loadTestResources("/uses-of-grouping/uses-of-grouping-case.yang"); + final YangModelParser parser = new YangParserImpl(); + final Set modules = parser.parseYangModels(testModels); + final SchemaContext context = parser.resolveSchemaContext(modules); + + assertNotNull(context); + final BindingGenerator bindingGen = new BindingGeneratorImpl(); + final List genTypes = bindingGen.generateTypes(context); + + GeneratedType groupingCaseTest = null; + int groupingCaseTestCounter = 0; + GeneratedType caseC = null; + int caseCCounter = 0; + for (Type type : genTypes) { + if (type instanceof GeneratedType && !(type instanceof GeneratedTransferObject)) { + GeneratedType genType = (GeneratedType) type; + if (genType.getName().equals("C")) { + caseC = genType; + caseCCounter++; + } else if (genType.getName().equals("GroupingCaseTest")) { + groupingCaseTest = genType; + groupingCaseTestCounter++; + } + } + } + + assertNotNull("Generated type for case C wasn't generated.", caseC); + assertEquals("Case C interface generated more than one time.", 1, caseCCounter); + assertEquals( + "Case C is in wrong package.", + "org.opendaylight.yang.gen.v1.urn.grouping.uses._case.rev2013718.container.with.choicetest.choice.test", + caseC.getPackageName()); + + assertNotNull("Generated type for grouping-case-test wasn't generated.", groupingCaseTest); + assertEquals("GroupingCaseTest interface generated more than one time.", 1, groupingCaseTestCounter); + assertEquals("GroupingCaseTest is in wrong package.", + "org.opendaylight.yang.gen.v1.urn.grouping.uses._case.rev2013718", groupingCaseTest.getPackageName()); + + assertTrue("Case C doesn't extend GroupingCaseTest.", containsInterface("GroupingCaseTest", caseC)); + assertTrue("Case C shouldn't contain any method.", caseC.getMethodDefinitions().isEmpty()); + + assertEquals("Number of method in GroupingCaseTest is incorrect", 1, groupingCaseTest.getMethodDefinitions() + .size()); + containsSignatures(groupingCaseTest.getMethodDefinitions(), new MethodSignaturePattern( + "getLeafGroupingCaseTest1", "String")); + } + + @Test + public void usesInContainerTest() { + List testModels = loadTestResources("/uses-of-grouping/uses-of-grouping-container.yang"); + final YangModelParser parser = new YangParserImpl(); + final Set modules = parser.parseYangModels(testModels); + final SchemaContext context = parser.resolveSchemaContext(modules); + + assertNotNull(context); + final BindingGenerator bindingGen = new BindingGeneratorImpl(); + final List genTypes = bindingGen.generateTypes(context); + + int containerTestCount = 0; + int groupingContainerTestCounter = 0; + GeneratedType containerTest = null; + GeneratedType groupingContainerTest = null; + + for (Type type : genTypes) { + if (type instanceof GeneratedType && !(type instanceof GeneratedTransferObject)) { + GeneratedType genType = (GeneratedType) type; + if (genType.getName().equals("GroupingContainerTest")) { + groupingContainerTest = genType; + groupingContainerTestCounter++; + } else if (genType.getName().equals("ContainerTest")) { + containerTest = genType; + containerTestCount++; + } + } + } + + assertNotNull("Generated type for grouping-container-test wasn't generated", groupingContainerTest); + assertEquals("GroupingContainerTest interface - incorrect number of occurences", 1, + groupingContainerTestCounter); + assertEquals("GroupingContainerTest isn't in correct package", + "org.opendaylight.yang.gen.v1.urn.grouping.uses.container.rev2013718", + groupingContainerTest.getPackageName()); + + assertNotNull("Generated type for container-test wasn't generated", containerTest); + assertEquals("ContainerTest interface - incorrect number of occurences", 1, containerTestCount); + assertEquals("ContainerTest isn't in correct package", + "org.opendaylight.yang.gen.v1.urn.grouping.uses.container.rev2013718", containerTest.getPackageName()); + + assertTrue("ContainerTest doesn't extend GroupingContainerTest.", + containsInterface("GroupingContainerTest", containerTest)); + + assertEquals("Number of method in GroupingContainerTestis incorrect", 2, groupingContainerTest + .getMethodDefinitions().size()); + assertEquals("Number of method in ContainerTest is incorrect", 1, containerTest.getMethodDefinitions().size()); + + containsSignatures(groupingContainerTest.getMethodDefinitions(), new MethodSignaturePattern( + "getLeafGroupingContainerTest1", "String"), new MethodSignaturePattern("getLeafGroupingContainerTest2", + "Short")); + + containsSignatures(containerTest.getMethodDefinitions(), new MethodSignaturePattern("getContainerLeafTest", + "String")); + } + + @Test + public void usesInGroupingTest() { + List testModels = loadTestResources("/uses-of-grouping/uses-of-grouping-grouping.yang"); + final YangModelParser parser = new YangParserImpl(); + final Set modules = parser.parseYangModels(testModels); + final SchemaContext context = parser.resolveSchemaContext(modules); + + assertNotNull(context); + final BindingGenerator bindingGen = new BindingGeneratorImpl(); + final List genTypes = bindingGen.generateTypes(context); + + int groupingTestCount = 0; + int groupingGroupingTestCounter = 0; + GeneratedType groupingTest = null; + GeneratedType groupingGroupingTest = null; + + for (Type type : genTypes) { + if (type instanceof GeneratedType && !(type instanceof GeneratedTransferObject)) { + GeneratedType genType = (GeneratedType) type; + if (genType.getName().equals("GroupingGroupingTest")) { + groupingGroupingTest = genType; + groupingGroupingTestCounter++; + } else if (genType.getName().equals("GroupingTest")) { + groupingTest = genType; + groupingTestCount++; + } + } + } + + assertNotNull("Generated type for grouping-grouping-test wasn't generated", groupingGroupingTest); + assertEquals("GroupingGroupingTest interface - incorrect number of occurences", 1, groupingGroupingTestCounter); + assertEquals("GroupingGroupingTest isn't in correct package", + "org.opendaylight.yang.gen.v1.urn.grouping.uses.grouping.rev2013718", + groupingGroupingTest.getPackageName()); + + assertNotNull("Generated type for grouping-test wasn't generated", groupingTest); + assertEquals("GroupingTest interface - incorrect number of occurences", 1, groupingTestCount); + assertEquals("GroupingTest isn't in correct package", + "org.opendaylight.yang.gen.v1.urn.grouping.uses.grouping.rev2013718", groupingTest.getPackageName()); + + assertTrue("GroupingTest doesn't extend GroupingGroupingTest.", + containsInterface("GroupingGroupingTest", groupingTest)); + + assertEquals("Number of method in GroupingGroupingTest is incorrect", 1, groupingGroupingTest + .getMethodDefinitions().size()); + assertEquals("Number of method in GroupingTest is incorrect", 1, groupingTest.getMethodDefinitions().size()); + + containsSignatures(groupingGroupingTest.getMethodDefinitions(), new MethodSignaturePattern( + "getLeafGroupingGrouping", "String")); + + containsSignatures(groupingTest.getMethodDefinitions(), new MethodSignaturePattern("getLeafGroupingTest", + "Byte")); + } + + @Test + public void usesInListTest() { + List testModels = loadTestResources("/uses-of-grouping/uses-of-grouping-list.yang"); + final YangModelParser parser = new YangParserImpl(); + final Set modules = parser.parseYangModels(testModels); + final SchemaContext context = parser.resolveSchemaContext(modules); + + assertNotNull(context); + final BindingGenerator bindingGen = new BindingGeneratorImpl(); + final List genTypes = bindingGen.generateTypes(context); + + int listTestCounter = 0; + int groupingListTestCounter = 0; + int containerGroupingListTestCounter = 0; + int listGroupingListTestCounter = 0; + GeneratedType listTest = null; + GeneratedType groupingListTest = null; + GeneratedType containerGroupingListTest = null; + GeneratedType listGroupingListTest = null; + + for (Type type : genTypes) { + if (type instanceof GeneratedType && !(type instanceof GeneratedTransferObject)) { + GeneratedType genType = (GeneratedType) type; + if (genType.getName().equals("GroupingListTest")) { + groupingListTest = genType; + groupingListTestCounter++; + } else if (genType.getName().equals("ListTest")) { + listTest = genType; + listTestCounter++; + } else if (genType.getName().equals("ContainerGroupingListTest")) { + containerGroupingListTest = genType; + containerGroupingListTestCounter++; + } else if (genType.getName().equals("ListGroupingListTest")) { + listGroupingListTest = genType; + listGroupingListTestCounter++; + } + } + } + + assertNotNull("Generated type for grouping-list-test wasn't generated", groupingListTest); + assertEquals("GroupingListTest interface - incorrect number of occurences", 1, groupingListTestCounter); + assertEquals("GroupingListTest isn't in correct package", + "org.opendaylight.yang.gen.v1.urn.grouping.uses.list.rev2013718", groupingListTest.getPackageName()); + + assertNotNull("Generated type for list-test wasn't generated", listTest); + assertEquals("ListTest interface - incorrect number of occurences", 1, listTestCounter); + assertEquals("ListTest isn't in correct package", + "org.opendaylight.yang.gen.v1.urn.grouping.uses.list.rev2013718", listTest.getPackageName()); + + assertNotNull("Generated type for container-grouping-list-test wasn't generated", containerGroupingListTest); + assertEquals("ContainerGroupingListTest interface - incorrect number of occurences", 1, + containerGroupingListTestCounter); + assertEquals("ContainerGroupingListTest isn't in correct package", + "org.opendaylight.yang.gen.v1.urn.grouping.uses.list.rev2013718.grouping.list.test", + containerGroupingListTest.getPackageName()); + + assertNotNull("Generated type for list-grouping-list-test wasn't generated", listGroupingListTest); + assertEquals("ListGroupingListTest interface - incorrect number of occurences", 1, listGroupingListTestCounter); + assertEquals("ListGroupingListTest isn't in correct package", + "org.opendaylight.yang.gen.v1.urn.grouping.uses.list.rev2013718.grouping.list.test", + listGroupingListTest.getPackageName()); + + assertTrue("ListTest doesn't extend GroupingGroupingTest.", containsInterface("GroupingListTest", listTest)); + + assertEquals("Number of method in GroupingListTest is incorrect", 4, groupingListTest.getMethodDefinitions() + .size()); + assertEquals("Number of method in ListTest is incorrect", 1, listTest.getMethodDefinitions().size()); + assertEquals("Number of method in ContainerGroupingListTest is incorrect", 1, containerGroupingListTest + .getMethodDefinitions().size()); + assertEquals("Number of method in ListGroupingListTest is incorrect", 1, listGroupingListTest + .getMethodDefinitions().size()); + + containsSignatures(groupingListTest.getMethodDefinitions(), new MethodSignaturePattern( + "getContainerGroupingListTest", "ContainerGroupingListTest"), new MethodSignaturePattern( + "getLeafGroupingListTest", "String"), new MethodSignaturePattern("getLeaffllistGroupingListTest", + "List"), new MethodSignaturePattern("getListGroupingListTest", "List")); + containsSignatures(listTest.getMethodDefinitions(), new MethodSignaturePattern("getListLeafTest", "String")); + containsSignatures(containerGroupingListTest.getMethodDefinitions(), new MethodSignaturePattern( + "getLeafContainerGroupingListTest", "Short")); + containsSignatures(listGroupingListTest.getMethodDefinitions(), new MethodSignaturePattern( + "getLeafListGroupingListTest", "Integer")); + } + + @Test + public void usesInModulTest() { + List testModels = loadTestResources("/uses-of-grouping/uses-of-grouping-modul.yang"); + final YangModelParser parser = new YangParserImpl(); + final Set modules = parser.parseYangModels(testModels); + final SchemaContext context = parser.resolveSchemaContext(modules); + + assertNotNull(context); + final BindingGenerator bindingGen = new BindingGeneratorImpl(); + final List genTypes = bindingGen.generateTypes(context); + + int groupingModulTestCounter = 0; + int groupingUsesModulDataCounter = 0; + GeneratedType groupingModulTest = null; + GeneratedType groupingUsesModulData = null; + + for (Type type : genTypes) { + if (type instanceof GeneratedType && !(type instanceof GeneratedTransferObject)) { + GeneratedType genType = (GeneratedType) type; + if (genType.getName().equals("GroupingModulTest")) { + groupingModulTest = genType; + groupingModulTestCounter++; + } else if (genType.getName().equals("GroupingUsesModulData")) { + groupingUsesModulData = genType; + groupingUsesModulDataCounter++; + } + } + } + + assertNotNull("Generated type for grouping-list-test wasn't generated", groupingModulTest); + assertEquals("GroupingModulTest interface - incorrect number of occurences", 1, groupingModulTestCounter); + assertEquals("GroupingModulTest isn't in correct package", + "org.opendaylight.yang.gen.v1.urn.grouping.uses.modul.rev2013718", groupingModulTest.getPackageName()); + + assertNotNull("Generated type for modul wasn't generated", groupingUsesModulData); + assertEquals("GroupingUsesModulData interface - incorrect number of occurences", 1, + groupingUsesModulDataCounter); + assertEquals("GroupingUsesModulData isn't in correct package", + "org.opendaylight.yang.gen.v1.urn.grouping.uses.modul.rev2013718", + groupingUsesModulData.getPackageName()); + + assertTrue("GroupingUsesModulData doesn't extend GroupingModulTest.", + containsInterface("GroupingModulTest", groupingUsesModulData)); + + assertEquals("Number of method in GroupingUsesModulData is incorrect", 0, groupingUsesModulData + .getMethodDefinitions().size()); + assertEquals("Number of method in GroupingModulTest is incorrect", 2, groupingModulTest.getMethodDefinitions() + .size()); + + containsSignatures(groupingModulTest.getMethodDefinitions(), new MethodSignaturePattern( + "getLeafGroupingModulTest", "String"), new MethodSignaturePattern("getLeafGroupingModulTest2", "Short")); + } + + @Test + public void usesInRpcTest() { + List testModels = loadTestResources("/uses-of-grouping/uses-of-grouping-rpc.yang"); + final YangModelParser parser = new YangParserImpl(); + final Set modules = parser.parseYangModels(testModels); + final SchemaContext context = parser.resolveSchemaContext(modules); + + assertNotNull(context); + final BindingGenerator bindingGen = new BindingGeneratorImpl(); + final List genTypes = bindingGen.generateTypes(context); + + int rpcTestInputCounter = 0; + int rpcTestOutputCounter = 0; + int groupingRpcInputTestCounter = 0; + int groupingRpcOutputTestCounter = 0; + int containerGroupingRpcInputTestCounter = 0; + GeneratedType rpcTestInput = null; + GeneratedType rpcTestOutput = null; + GeneratedType groupingRpcInputTest = null; + GeneratedType groupingRpcOutputTest = null; + GeneratedType containerGroupingRpcInputTest = null; + + for (Type type : genTypes) { + if (type instanceof GeneratedType && !(type instanceof GeneratedTransferObject)) { + GeneratedType genType = (GeneratedType) type; + if (genType.getName().equals("RpcTestInput")) { + rpcTestInput = genType; + rpcTestInputCounter++; + } else if (genType.getName().equals("RpcTestOutput")) { + rpcTestOutput = genType; + rpcTestOutputCounter++; + } else if (genType.getName().equals("GroupingRpcInputTest")) { + groupingRpcInputTest = genType; + groupingRpcInputTestCounter++; + } else if (genType.getName().equals("GroupingRpcOutputTest")) { + groupingRpcOutputTest = genType; + groupingRpcOutputTestCounter++; + } else if (genType.getName().equals("ContainerGroupingRpcInputTest")) { + containerGroupingRpcInputTest = genType; + containerGroupingRpcInputTestCounter++; + } + + } + } + + assertNotNull("Generated type for RPC test input wasn't generated", rpcTestInput); + assertEquals("RpcTestInput interface - incorrect number of occurences", 1, rpcTestInputCounter); + assertEquals("RpcTestInput isn't in correct package", + "org.opendaylight.yang.gen.v1.urn.grouping.uses.rpc.rev2013718", rpcTestInput.getPackageName()); + + assertNotNull("Generated type for RPC test output wasn't generated", rpcTestOutput); + assertEquals("RpcTestOutput interface - incorrect number of occurences", 1, rpcTestOutputCounter); + assertEquals("RpcTestOutput isn't in correct package", + "org.opendaylight.yang.gen.v1.urn.grouping.uses.rpc.rev2013718", rpcTestOutput.getPackageName()); + + assertNotNull("Generated type for grouping-rpc-input-test wasn't generated", groupingRpcInputTest); + assertEquals("RpcTestOutput interface - incorrect number of occurences", 1, groupingRpcInputTestCounter); + assertEquals("GroupingRpcInputTest isn't in correct package", + "org.opendaylight.yang.gen.v1.urn.grouping.uses.rpc.rev2013718", groupingRpcInputTest.getPackageName()); + + assertNotNull("Generated type for grouping-rpc-output-test wasn't generated", groupingRpcOutputTest); + assertEquals("RpcTestOutput interface - incorrect number of occurences", 1, groupingRpcOutputTestCounter); + assertEquals("GroupingRpcOutputTest isn't in correct package", + "org.opendaylight.yang.gen.v1.urn.grouping.uses.rpc.rev2013718", groupingRpcOutputTest.getPackageName()); + + assertNotNull("Generated type for container-grouping-rpc-input-test wasn't generated", + containerGroupingRpcInputTest); + assertEquals("ContainerGroupingRpcInputTest interface - incorrect number of occurences", 1, + containerGroupingRpcInputTestCounter); + assertEquals("ContainerGroupingRpcInputTest isn't in correct package", + "org.opendaylight.yang.gen.v1.urn.grouping.uses.rpc.rev2013718.grouping.rpc.input.test", + containerGroupingRpcInputTest.getPackageName()); + + assertTrue("RpcTestInput doesn't extend GroupingRpcInputTest.", + containsInterface("GroupingRpcInputTest", rpcTestInput)); + assertTrue("RpcTestOutput doesn't extend GroupingRpcOutputTest.", + containsInterface("GroupingRpcOutputTest", rpcTestOutput)); + + assertEquals("Number of method in RpcTestInput is incorrect", 0, rpcTestInput.getMethodDefinitions().size()); + assertEquals("Number of method in RpcTestOutput is incorrect", 0, rpcTestOutput.getMethodDefinitions().size()); + assertEquals("Number of method in GroupingRpcInputTest is incorrect", 2, groupingRpcInputTest + .getMethodDefinitions().size()); + assertEquals("Number of method in GroupingRpcOutputTest is incorrect", 1, groupingRpcOutputTest + .getMethodDefinitions().size()); + assertEquals("Number of method in ContainerGroupingRpcInputTest is incorrect", 1, containerGroupingRpcInputTest + .getMethodDefinitions().size()); + + containsSignatures(groupingRpcInputTest.getMethodDefinitions(), new MethodSignaturePattern( + "getContainerGroupingRpcInputTest", "ContainerGroupingRpcInputTest"), new MethodSignaturePattern( + "getLeaflistGroupingRpcInputTest", "List")); + containsSignatures(groupingRpcOutputTest.getMethodDefinitions(), new MethodSignaturePattern( + "getLeafGroupingRpcOutputTest", "Byte")); + containsSignatures(containerGroupingRpcInputTest.getMethodDefinitions(), new MethodSignaturePattern( + "getLeafContainerGroupingRpcInputTest", "String")); + } + + @Test + public void usesInAugmentTest() { + List testModels = loadTestResources("/uses-of-grouping/uses-of-grouping-augment.yang"); + final YangModelParser parser = new YangParserImpl(); + final Set modules = parser.parseYangModels(testModels); + final SchemaContext context = parser.resolveSchemaContext(modules); + + assertNotNull(context); + final BindingGenerator bindingGen = new BindingGeneratorImpl(); + final List genTypes = bindingGen.generateTypes(context); + + GeneratedType containerAugment1 = null; + GeneratedType groupingAugmentTest = null; + int containerAugment1Counter = 0; + int groupingAugmentTestCounter = 0; + + for (Type type : genTypes) { + if (type instanceof GeneratedType && !(type instanceof GeneratedTransferObject)) { + GeneratedType genType = (GeneratedType) type; + if (genType.getName().equals("ContainerAugment1")) { + containerAugment1 = genType; + containerAugment1Counter++; + } else if (genType.getName().equals("GroupingAugmentTest")) { + groupingAugmentTest = genType; + groupingAugmentTestCounter++; + } + } + } + + assertNotNull("Generated type for augment /container-augment wasn't generated.", containerAugment1); + assertEquals("ContainerAugment1 interface generated more than one time.", 1, containerAugment1Counter); + assertEquals("ContainerAugment1 is in wrong package.", + "org.opendaylight.yang.gen.v1.urn.grouping.uses.augment.rev2013718", containerAugment1.getPackageName()); + + assertNotNull("Generated type for grouping-augment-test wasn't generated.", groupingAugmentTest); + assertEquals("GroupingAugmentTest interface generated more than one time.", 1, groupingAugmentTestCounter); + assertEquals("groupingAugmentTest is in wrong package.", + "org.opendaylight.yang.gen.v1.urn.grouping.uses.augment.rev2013718", + groupingAugmentTest.getPackageName()); + + assertTrue("ContainerAugment1 doesn't extend GroupingAugmentTest.", + containsInterface("GroupingAugmentTest", containerAugment1)); + + assertEquals("Number of method in GroupingCaseTest is incorrect", 0, containerAugment1.getMethodDefinitions() + .size()); + + assertEquals("Number of method in ContainerAugment1 is incorrect", 0, containerAugment1.getMethodDefinitions() + .size()); + assertEquals("Number of method in GroupingCaseTest is incorrect", 1, groupingAugmentTest.getMethodDefinitions() + .size()); + + containsSignatures(groupingAugmentTest.getMethodDefinitions(), new MethodSignaturePattern( + "getLeafGroupingAugmentTest", "String")); + } + + @Test + public void usesInNotification() { + List testModels = loadTestResources("/uses-of-grouping/uses-of-grouping-notification.yang"); + final YangModelParser parser = new YangParserImpl(); + final Set modules = parser.parseYangModels(testModels); + final SchemaContext context = parser.resolveSchemaContext(modules); + + assertNotNull(context); + final BindingGenerator bindingGen = new BindingGeneratorImpl(); + final List genTypes = bindingGen.generateTypes(context); + + GeneratedType notificationTest = null; + GeneratedType groupingNotificationTest = null; + GeneratedType containerGroupingNotificationTest = null; + int notificationTestCounter = 0; + int groupingNotificationTestCounter = 0; + int containerGroupingNotificationTestCounter = 0; + + for (Type type : genTypes) { + if (type instanceof GeneratedType && !(type instanceof GeneratedTransferObject)) { + GeneratedType genType = (GeneratedType) type; + if (genType.getName().equals("NotificationTest")) { + notificationTest = genType; + notificationTestCounter++; + } else if (genType.getName().equals("GroupingNotificationTest")) { + groupingNotificationTest = genType; + groupingNotificationTestCounter++; + } else if (genType.getName().equals("ContainerGroupingNotificationTest")) { + containerGroupingNotificationTest = genType; + containerGroupingNotificationTestCounter++; + } + } + } + + assertNotNull("Generated type for notification-test wasn't generated.", notificationTest); + assertEquals("NotificationTest interface generated more than one time.", 1, notificationTestCounter); + assertEquals("NotificationTest is in wrong package.", + "org.opendaylight.yang.gen.v1.urn.grouping.uses.notification.rev2013718", + notificationTest.getPackageName()); + + assertNotNull("Generated type for grouping-notification-test wasn't generated.", groupingNotificationTest); + assertEquals("GroupingNotificationTest interface generated more than one time.", 1, + groupingNotificationTestCounter); + assertEquals("groupingNotificationTest is in wrong package.", + "org.opendaylight.yang.gen.v1.urn.grouping.uses.notification.rev2013718", + groupingNotificationTest.getPackageName()); + + assertNotNull("Generated type for container-grouping-notification-test wasn't generated.", + containerGroupingNotificationTest); + assertEquals("ContainerGroupingNotificationTest interface generated more than one time.", 1, + containerGroupingNotificationTestCounter); + assertEquals("ContainerGroupingNotificationTest is in wrong package.", + "org.opendaylight.yang.gen.v1.urn.grouping.uses.notification.rev2013718.grouping.notification.test", + containerGroupingNotificationTest.getPackageName()); + + assertTrue("NotificationTest doesn't extend GroupingNotificationTest.", + containsInterface("GroupingNotificationTest", notificationTest)); + + assertEquals("Number of method in NotificationTest is incorrect", 1, notificationTest.getMethodDefinitions() + .size()); + assertEquals("Number of method in GroupingNotificationTest is incorrect", 2, groupingNotificationTest + .getMethodDefinitions().size()); + assertEquals("Number of method in ContainerGroupingNotificationTest is incorrect", 1, + containerGroupingNotificationTest.getMethodDefinitions().size()); + + containsSignatures(notificationTest.getMethodDefinitions(), new MethodSignaturePattern( + "getLeafNotificationTest", "String")); + containsSignatures(groupingNotificationTest.getMethodDefinitions(), new MethodSignaturePattern( + "getContainerGroupingNotificationTest", "ContainerGroupingNotificationTest"), + new MethodSignaturePattern("getLeaffllistGroupingNotificationTest", "List")); + containsSignatures(containerGroupingNotificationTest.getMethodDefinitions(), new MethodSignaturePattern( + "getLeafContainerGroupingNotificationTest", "Long")); + } + +} diff --git a/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/test/resources/uses-of-grouping.yang b/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/test/resources/uses-of-grouping.yang new file mode 100644 index 0000000000..36913cd40d --- /dev/null +++ b/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/test/resources/uses-of-grouping.yang @@ -0,0 +1,145 @@ +module grouping_uses { + + namespace "urn:uses:of:grouping"; + prefix "sbd"; + + organization "OPEN DAYLIGHT"; + contact "http://www.opendaylight.org/"; + + revision 2013-07-18 { + } + + + + grouping grouping-modul-test { + leaf leaf-grouping-modul-test { + type string; + } + leaf leaf-grouping-modul-test2 { + type uint8; + } + } + + grouping grouping-container-test { + leaf leaf-grouping-container-test1 { + type string; + } + leaf leaf-grouping-container-test2 { + type uint8; + } + } + + grouping grouping-case-test { + leaf leaf-grouping-case-test1 { + type string; + } + } + + grouping grouping-choice-test { + choice choice-grouing-choice-test { + case case-choice-grouping-choice-test1 { + leaf leaf-case-choice-grouping-choice-test1 { + type string; + } + } + case case-choice-grouping-choice-test2 { + leaf leaf-case-choice-grouping-choice-test2 { + type uint8; + } + } + } + } + + grouping grouping-list-test { + leaf leaf-grouping-list-test { + type string; + } + container container-grouping-list-test { + leaf leaf-container-grouping-list-test { + type uint8; + } + } + list list-grouping-list-test { + leaf leaf-list-grouping-list-test { + type int32; + } + } + leaf-list leaflist-grouping-list-test { + type string; + } + } + + grouping grouping-grouping-test { + leaf leaf-grouping-grouping { + type string; + } + } + + grouping grouping-rpc-input-test { + container container-grouping-rpc-input-test { + leaf leaf-container-grouping-rpc-input-test { + type string; + } + } + leaf-list leaflist-grouping-rpc-input-test { + type uint8; + } + } + + grouping grouping-rpc-output-test { + leaf leaf-grouping-rpc-output-test { + type int8; + } + } + +//grouping in GROUPING + grouping grouping-atest { + leaf leaf-grouping-test { + type int8; + } + uses grouping-grouping-test; + } + +//grouping in MODUL +// uses grouping-modul-test; + +//grouping in RPC + rpc rpc-test { + input { + uses grouping-rpc-input-test; + } + output { + uses grouping-rpc-output-test; + } + } + +//grouping in CONTAINER + container container-test { + leaf container-leaf-test { + type string; + } + uses grouping-container-test; + } + +//grouping in CASE + container container-with-choicetest { + choice choice-test { + case a { + leaf leaf-choice-test1 { + type string; + } + } + case c { + uses grouping-case-test; + } + } + } + +//grouping in LIST + list list-test { + leaf list-leaf-test { + type string; + } + uses grouping-list-test; + } +} \ No newline at end of file diff --git a/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/test/resources/uses-of-grouping/uses-of-grouping-augment.yang b/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/test/resources/uses-of-grouping/uses-of-grouping-augment.yang new file mode 100644 index 0000000000..0b999115be --- /dev/null +++ b/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/test/resources/uses-of-grouping/uses-of-grouping-augment.yang @@ -0,0 +1,31 @@ +module grouping_uses_augment { + + namespace "urn:grouping:uses:augment"; + prefix "sbd"; + + organization "OPEN DAYLIGHT"; + contact "http://www.opendaylight.org/"; + + revision 2013-07-18 { + } + + grouping grouping-augment-test { + leaf leaf-grouping-augment-test { + type string; + } + } + + + container container-augment { + leaf leaf-container-augment1 { + type string; + } + leaf leaf-container-augment2 { + type int64; + } + } + + augment "/container-augment" { + uses grouping-augment-test; + } +} \ No newline at end of file diff --git a/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/test/resources/uses-of-grouping/uses-of-grouping-case.yang b/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/test/resources/uses-of-grouping/uses-of-grouping-case.yang new file mode 100644 index 0000000000..2f97f1bfd7 --- /dev/null +++ b/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/test/resources/uses-of-grouping/uses-of-grouping-case.yang @@ -0,0 +1,47 @@ +module grouping_uses_case { + + namespace "urn:grouping:uses:case"; + prefix "sbd"; + + organization "OPEN DAYLIGHT"; + contact "http://www.opendaylight.org/"; + + revision 2013-07-18 { + } + + + grouping grouping-case-test { + leaf leaf-grouping-case-test1 { + type string; + } + } + + grouping grouping-choice-test { + choice choice-grouing-choice-test { + case case-choice-grouping-choice-test1 { + leaf leaf-case-choice-grouping-choice-test1 { + type string; + } + } + case case-choice-grouping-choice-test2 { + leaf leaf-case-choice-grouping-choice-test2 { + type uint8; + } + } + } + } + +//grouping in CASE + container container-with-choicetest { + choice choice-test { + case a { + leaf leaf-choice-test1 { + type string; + } + } + case c { + uses grouping-case-test; + } + } + } +} \ No newline at end of file diff --git a/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/test/resources/uses-of-grouping/uses-of-grouping-container.yang b/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/test/resources/uses-of-grouping/uses-of-grouping-container.yang new file mode 100644 index 0000000000..77b8c00a18 --- /dev/null +++ b/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/test/resources/uses-of-grouping/uses-of-grouping-container.yang @@ -0,0 +1,28 @@ +module grouping_uses_container { + + namespace "urn:grouping:uses:container"; + prefix "sbd"; + + organization "OPEN DAYLIGHT"; + contact "http://www.opendaylight.org/"; + + revision 2013-07-18 { + } + + grouping grouping-container-test { + leaf leaf-grouping-container-test1 { + type string; + } + leaf leaf-grouping-container-test2 { + type uint8; + } + } + +//grouping in CONTAINER + container container-test { + leaf container-leaf-test { + type string; + } + uses grouping-container-test; + } +} \ No newline at end of file diff --git a/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/test/resources/uses-of-grouping/uses-of-grouping-dependencies.yang b/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/test/resources/uses-of-grouping/uses-of-grouping-dependencies.yang new file mode 100644 index 0000000000..ef6efb5a8f --- /dev/null +++ b/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/test/resources/uses-of-grouping/uses-of-grouping-dependencies.yang @@ -0,0 +1,52 @@ +module grouping_dependencies { + + namespace "urn:grouping:dependencies"; + prefix "sbd"; + + organization "OPEN DAYLIGHT"; + contact "http://www.opendaylight.org/"; + + revision 2013-07-18 { + } + + grouping grouping-U { + leaf leaf-grouping-U { + type string; + } + uses grouping-V; + uses grouping-X; + } + + grouping grouping-V { + leaf leaf-grouping-V { + type string; + } + uses grouping-Z; + uses grouping-ZZ; + } + + grouping grouping-X { + leaf leaf-grouping-X { + type string; + } + uses grouping-Y; + } + + grouping grouping-Y { + leaf leaf-grouping-Y { + type string; + } + } + + grouping grouping-Z { + leaf leaf-grouping-Z { + type string; + } + } + + grouping grouping-ZZ { + leaf leaf-grouping-ZZ { + type string; + } + } +} \ No newline at end of file diff --git a/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/test/resources/uses-of-grouping/uses-of-grouping-grouping.yang b/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/test/resources/uses-of-grouping/uses-of-grouping-grouping.yang new file mode 100644 index 0000000000..3c68cd7a43 --- /dev/null +++ b/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/test/resources/uses-of-grouping/uses-of-grouping-grouping.yang @@ -0,0 +1,27 @@ +module grouping_uses_grouping { + + namespace "urn:grouping:uses:grouping"; + prefix "sbd"; + + organization "OPEN DAYLIGHT"; + contact "http://www.opendaylight.org/"; + + revision 2013-07-18 { + } + + grouping grouping-grouping-test { + leaf leaf-grouping-grouping { + type string; + } + } + + +//grouping in GROUPING + grouping grouping-test { + leaf leaf-grouping-test { + type int8; + } + uses grouping-grouping-test; + } + +} \ No newline at end of file diff --git a/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/test/resources/uses-of-grouping/uses-of-grouping-list.yang b/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/test/resources/uses-of-grouping/uses-of-grouping-list.yang new file mode 100644 index 0000000000..420d3369a4 --- /dev/null +++ b/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/test/resources/uses-of-grouping/uses-of-grouping-list.yang @@ -0,0 +1,39 @@ +module grouping_uses_list { + + namespace "urn:grouping:uses:list"; + prefix "sbd"; + + organization "OPEN DAYLIGHT"; + contact "http://www.opendaylight.org/"; + + revision 2013-07-18 { + } + + + grouping grouping-list-test { + leaf leaf-grouping-list-test { + type string; + } + container container-grouping-list-test { + leaf leaf-container-grouping-list-test { + type uint8; + } + } + list list-grouping-list-test { + leaf leaf-list-grouping-list-test { + type int32; + } + } + leaf-list leaffllist-grouping-list-test { + type string; + } + } + +//grouping in LIST + list list-test { + leaf list-leaf-test { + type string; + } + uses grouping-list-test; + } +} \ No newline at end of file diff --git a/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/test/resources/uses-of-grouping/uses-of-grouping-modul.yang b/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/test/resources/uses-of-grouping/uses-of-grouping-modul.yang new file mode 100644 index 0000000000..4dc6b17daa --- /dev/null +++ b/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/test/resources/uses-of-grouping/uses-of-grouping-modul.yang @@ -0,0 +1,23 @@ +module grouping_uses_modul { + + namespace "urn:grouping:uses:modul"; + prefix "sbd"; + + organization "OPEN DAYLIGHT"; + contact "http://www.opendaylight.org/"; + + revision 2013-07-18 { + } + + grouping grouping-modul-test { + leaf leaf-grouping-modul-test { + type string; + } + leaf leaf-grouping-modul-test2 { + type uint8; + } + } + +//grouping in MODUL + uses grouping-modul-test; +} \ No newline at end of file diff --git a/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/test/resources/uses-of-grouping/uses-of-grouping-notification.yang b/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/test/resources/uses-of-grouping/uses-of-grouping-notification.yang new file mode 100644 index 0000000000..e3caf2a761 --- /dev/null +++ b/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/test/resources/uses-of-grouping/uses-of-grouping-notification.yang @@ -0,0 +1,30 @@ +module grouping_uses_notification { + + namespace "urn:grouping:uses:notification"; + prefix "sbd"; + + organization "OPEN DAYLIGHT"; + contact "http://www.opendaylight.org/"; + + revision 2013-07-18 { + } + + grouping grouping-notification-test { + container container-grouping-notification-test { + leaf leaf-container-grouping-notification-test { + type uint32; + } + } + leaf-list leaffllist-grouping-notification-test { + type string; + } + } + +//grouping in NOTIFICATION + notification notification-test { + leaf leaf-notification-test { + type string; + } + uses grouping-notification-test; + } +} \ No newline at end of file diff --git a/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/test/resources/uses-of-grouping/uses-of-grouping-rpc.yang b/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/test/resources/uses-of-grouping/uses-of-grouping-rpc.yang new file mode 100644 index 0000000000..81f3b3c299 --- /dev/null +++ b/opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/test/resources/uses-of-grouping/uses-of-grouping-rpc.yang @@ -0,0 +1,40 @@ +module grouping_uses_rpc { + + namespace "urn:grouping:uses:rpc"; + prefix "sbd"; + + organization "OPEN DAYLIGHT"; + contact "http://www.opendaylight.org/"; + + revision 2013-07-18 { + } + + + + grouping grouping-rpc-input-test { + container container-grouping-rpc-input-test { + leaf leaf-container-grouping-rpc-input-test { + type string; + } + } + leaf-list leaflist-grouping-rpc-input-test { + type uint8; + } + } + + grouping grouping-rpc-output-test { + leaf leaf-grouping-rpc-output-test { + type int8; + } + } + +//grouping in RPC + rpc rpc-test { + input { + uses grouping-rpc-input-test; + } + output { + uses grouping-rpc-output-test; + } + } +} \ No newline at end of file diff --git a/opendaylight/sal/yang-prototype/code-generator/binding-generator-util/src/main/java/org/opendaylight/controller/binding/generator/util/Types.java b/opendaylight/sal/yang-prototype/code-generator/binding-generator-util/src/main/java/org/opendaylight/controller/binding/generator/util/Types.java index 2e5bbf0a07..044b76da4d 100644 --- a/opendaylight/sal/yang-prototype/code-generator/binding-generator-util/src/main/java/org/opendaylight/controller/binding/generator/util/Types.java +++ b/opendaylight/sal/yang-prototype/code-generator/binding-generator-util/src/main/java/org/opendaylight/controller/binding/generator/util/Types.java @@ -1,161 +1,153 @@ -/* - * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved. - * - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License v1.0 which accompanies this distribution, - * and is available at http://www.eclipse.org/legal/epl-v10.html - */ -package org.opendaylight.controller.binding.generator.util; - -import java.util.List; -import java.util.Map; -import java.util.Set; - -import org.opendaylight.controller.binding.generator.util.generated.type.builder.GeneratedTOBuilderImpl; -import org.opendaylight.controller.sal.binding.model.api.ConcreteType; -import org.opendaylight.controller.sal.binding.model.api.GeneratedTransferObject; -import org.opendaylight.controller.sal.binding.model.api.ParameterizedType; -import org.opendaylight.controller.sal.binding.model.api.Type; -import org.opendaylight.controller.sal.binding.model.api.WildcardType; -import org.opendaylight.controller.yang.binding.Augmentable; -import org.opendaylight.controller.yang.binding.Augmentation; -import org.opendaylight.controller.yang.binding.BaseIdentity; -import org.opendaylight.controller.yang.binding.DataObject; - -public final class Types { - private static final Type SET_TYPE = typeForClass(Set.class); - private static final Type LIST_TYPE = typeForClass(List.class); - private static final Type MAP_TYPE = typeForClass(Map.class); - public static final Type DATA_OBJECT = typeForClass(DataObject.class); - - public static ConcreteType voidType() { - return new ConcreteTypeImpl(Void.class.getPackage().getName(), - Void.class.getSimpleName()); - } - - public static final Type primitiveType(final String primitiveType) { - return new ConcreteTypeImpl("", primitiveType); - } - - - /** - * Returns an instance of {@link ConcreteType} describing the class - * - * @param cls - * Class to describe - * @return Description of class - */ - public static ConcreteType typeForClass(Class cls) { - return new ConcreteTypeImpl(cls.getPackage().getName(), - cls.getSimpleName()); - } - - /** - * Returns an instance of {@link ParameterizedType} describing the typed - * {@link Map} - * - * @param keyType - * Key Type - * @param valueType - * Value Type - * @return Description of generic type instance - */ - public static ParameterizedType mapTypeFor(Type keyType, Type valueType) { - return parameterizedTypeFor(MAP_TYPE, keyType, valueType); - } - - /** - * Returns an instance of {@link ParameterizedType} describing the typed - * {@link Set} with concrete type of value. - * - * @param valueType - * Value Type - * @return Description of generic type instance of Set - */ - public static ParameterizedType setTypeFor(Type valueType) { - return parameterizedTypeFor(SET_TYPE, valueType); - } - - /** - * Returns an instance of {@link ParameterizedType} describing the typed - * {@link List} with concrete type of value. - * - * @param valueType - * Value Type - * @return Description of type instance of List - */ - public static ParameterizedType listTypeFor(Type valueType) { - return parameterizedTypeFor(LIST_TYPE, valueType); - } - - public static GeneratedTransferObject getBaseIdentityTO() { - Class cls = BaseIdentity.class; - GeneratedTOBuilderImpl gto = new GeneratedTOBuilderImpl(cls.getPackage().getName(), - cls.getSimpleName()); - return gto.toInstance(); - } - - /** - * - * @param type - * @param parameters - * @return - */ - public static ParameterizedType parameterizedTypeFor(Type type, - Type... parameters) { - return new ParametrizedTypeImpl(type, parameters); - } - - public static WildcardType wildcardTypeFor(String packageName, String typeName) { - return new WildcardTypeImpl(packageName, typeName); - } - - public static ParameterizedType augmentableTypeFor(Type valueType) { - final Type augmentable = typeForClass(Augmentable.class); - return parameterizedTypeFor(augmentable, valueType); - } - - public static ParameterizedType augmentationTypeFor(Type valueType) { - final Type augmentation = typeForClass(Augmentation.class); - return parameterizedTypeFor(augmentation, valueType); - } - - private static class ConcreteTypeImpl extends AbstractBaseType implements - ConcreteType { - private ConcreteTypeImpl(String pkName, String name) { - super(pkName, name); - } - } - - private static class ParametrizedTypeImpl extends AbstractBaseType - implements ParameterizedType { - private Type[] actualTypes; - private Type rawType; - - @Override - public Type[] getActualTypeArguments() { - - return actualTypes; - } - - @Override - public Type getRawType() { - return rawType; - } - - public ParametrizedTypeImpl(Type rawType, Type[] actTypes) { - super(rawType.getPackageName(), rawType.getName()); - this.rawType = rawType; - this.actualTypes = actTypes; - } - - } - - private static class WildcardTypeImpl extends AbstractBaseType - implements WildcardType { - public WildcardTypeImpl(String packageName, String typeName) { - super(packageName, typeName); - } - } - -} +/* + * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.controller.binding.generator.util; + +import java.util.List; +import java.util.Map; +import java.util.Set; + +import org.opendaylight.controller.binding.generator.util.generated.type.builder.GeneratedTOBuilderImpl; +import org.opendaylight.controller.sal.binding.model.api.ConcreteType; +import org.opendaylight.controller.sal.binding.model.api.GeneratedTransferObject; +import org.opendaylight.controller.sal.binding.model.api.ParameterizedType; +import org.opendaylight.controller.sal.binding.model.api.Type; +import org.opendaylight.controller.sal.binding.model.api.WildcardType; +import org.opendaylight.controller.yang.binding.Augmentable; +import org.opendaylight.controller.yang.binding.Augmentation; +import org.opendaylight.controller.yang.binding.BaseIdentity; +import org.opendaylight.controller.yang.binding.DataObject; + +public final class Types { + private static final Type SET_TYPE = typeForClass(Set.class); + private static final Type LIST_TYPE = typeForClass(List.class); + private static final Type MAP_TYPE = typeForClass(Map.class); + public static final Type DATA_OBJECT = typeForClass(DataObject.class); + + public static ConcreteType voidType() { + return new ConcreteTypeImpl(Void.class.getPackage().getName(), Void.class.getSimpleName()); + } + + public static final Type primitiveType(final String primitiveType) { + return new ConcreteTypeImpl("", primitiveType); + } + + /** + * Returns an instance of {@link ConcreteType} describing the class + * + * @param cls + * Class to describe + * @return Description of class + */ + public static ConcreteType typeForClass(Class cls) { + return new ConcreteTypeImpl(cls.getPackage().getName(), cls.getSimpleName()); + } + + /** + * Returns an instance of {@link ParameterizedType} describing the typed + * {@link Map} + * + * @param keyType + * Key Type + * @param valueType + * Value Type + * @return Description of generic type instance + */ + public static ParameterizedType mapTypeFor(Type keyType, Type valueType) { + return parameterizedTypeFor(MAP_TYPE, keyType, valueType); + } + + /** + * Returns an instance of {@link ParameterizedType} describing the typed + * {@link Set} with concrete type of value. + * + * @param valueType + * Value Type + * @return Description of generic type instance of Set + */ + public static ParameterizedType setTypeFor(Type valueType) { + return parameterizedTypeFor(SET_TYPE, valueType); + } + + /** + * Returns an instance of {@link ParameterizedType} describing the typed + * {@link List} with concrete type of value. + * + * @param valueType + * Value Type + * @return Description of type instance of List + */ + public static ParameterizedType listTypeFor(Type valueType) { + return parameterizedTypeFor(LIST_TYPE, valueType); + } + + public static GeneratedTransferObject getBaseIdentityTO() { + Class cls = BaseIdentity.class; + GeneratedTOBuilderImpl gto = new GeneratedTOBuilderImpl(cls.getPackage().getName(), cls.getSimpleName()); + return gto.toInstance(); + } + + /** + * + * @param type + * @param parameters + * @return + */ + public static ParameterizedType parameterizedTypeFor(Type type, Type... parameters) { + return new ParametrizedTypeImpl(type, parameters); + } + + public static WildcardType wildcardTypeFor(String packageName, String typeName) { + return new WildcardTypeImpl(packageName, typeName); + } + + public static ParameterizedType augmentableTypeFor(Type valueType) { + final Type augmentable = typeForClass(Augmentable.class); + return parameterizedTypeFor(augmentable, valueType); + } + + public static ParameterizedType augmentationTypeFor(Type valueType) { + final Type augmentation = typeForClass(Augmentation.class); + return parameterizedTypeFor(augmentation, valueType); + } + + private static class ConcreteTypeImpl extends AbstractBaseType implements ConcreteType { + private ConcreteTypeImpl(String pkName, String name) { + super(pkName, name); + } + } + + private static class ParametrizedTypeImpl extends AbstractBaseType implements ParameterizedType { + private Type[] actualTypes; + private Type rawType; + + @Override + public Type[] getActualTypeArguments() { + + return actualTypes; + } + + @Override + public Type getRawType() { + return rawType; + } + + public ParametrizedTypeImpl(Type rawType, Type[] actTypes) { + super(rawType.getPackageName(), rawType.getName()); + this.rawType = rawType; + this.actualTypes = actTypes; + } + + } + + private static class WildcardTypeImpl extends AbstractBaseType implements WildcardType { + public WildcardTypeImpl(String packageName, String typeName) { + super(packageName, typeName); + } + } + +} diff --git a/opendaylight/sal/yang-prototype/code-generator/samples/maven-code-gen-sample/src/main/yang/uses-of-grouping.yang b/opendaylight/sal/yang-prototype/code-generator/samples/maven-code-gen-sample/src/main/yang/uses-of-grouping.yang new file mode 100644 index 0000000000..4e54233485 --- /dev/null +++ b/opendaylight/sal/yang-prototype/code-generator/samples/maven-code-gen-sample/src/main/yang/uses-of-grouping.yang @@ -0,0 +1,184 @@ +module grouping_uses { + + namespace "urn:uses:of:grouping"; + prefix "sbd"; + + organization "OPEN DAYLIGHT"; + contact "http://www.opendaylight.org/"; + + revision 2013-07-18 { + } + + grouping grouping-modul-test { + leaf leaf-grouping-modul-test { + type string; + } + leaf leaf-grouping-modul-test2 { + type uint8; + } + } + + + grouping grouping-container-test { + leaf leaf-grouping-container-test1 { + type string; + } + leaf leaf-grouping-container-test2 { + type uint8; + } + } + + grouping grouping-case-test { + leaf leaf-grouping-case-test1 { + type string; + } + } + + grouping grouping-choice-test { + choice choice-grouing-choice-test { + case case-choice-grouping-choice-test1 { + leaf leaf-case-choice-grouping-choice-test1 { + type string; + } + } + case case-choice-grouping-choice-test2 { + leaf leaf-case-choice-grouping-choice-test2 { + type uint8; + } + } + } + } + + grouping grouping-list-test { + leaf leaf-grouping-list-test { + type string; + } + container container-grouping-list-test { + leaf leaf-container-grouping-list-test { + type uint8; + } + } + list list-grouping-list-test { + leaf leaf-list-grouping-list-test { + type int32; + } + } + leaf-list leaflist-grouping-list-test { + type string; + } + } + + grouping grouping-grouping-test { + leaf leaf-grouping-grouping { + type string; + } + } + + grouping grouping-rpc-input-test { + container container-grouping-rpc-input-test { + leaf leaf-container-grouping-rpc-input-test { + type string; + } + } + leaf-list leaflist-grouping-rpc-input-test { + type uint8; + } + } + + grouping grouping-rpc-output-test { + leaf leaf-grouping-rpc-output-test { + type int8; + } + } + + grouping grouping-notification-test { + container container-grouping-notification-test { + leaf leaf-container-grouping-notification-test { + type uint32; + } + } + leaf-list leaffllist-grouping-notification-test { + type string; + } + } + +//grouping in GROUPING + grouping grouping-atest { + leaf leaf-grouping-test { + type int8; + } + uses grouping-grouping-test; + } + +//grouping in MODUL + uses grouping-modul-test; + +//grouping in RPC + rpc rpc-test { + input { + uses grouping-rpc-input-test; + } + output { + uses grouping-rpc-output-test; + } + } + +//grouping in CONTAINER + container container-test { + leaf container-leaf-test { + type string; + } + uses grouping-container-test; + } + +//grouping in CASE + container container-with-choicetest { + choice choice-test { + case a { + leaf leaf-choice-test1 { + type string; + } + } + case c { + uses grouping-case-test; + } + } + } + +//grouping in LIST + list list-test { + leaf list-leaf-test { + type string; + } + uses grouping-list-test; + } + +//grouping in NOTIFICATION + notification notification-test { + leaf leaf-notification-test { + type string; + } + uses grouping-notification-test; + } + + grouping grouping-augment-test1 { + leaf leaf-grouping-augment-test { + type string; + } + } + + container container-augment { + leaf leaf-container-augment1 { + type string; + } + leaf leaf-container-augment2 { + type int64; + } + } + +//grouping AUGMENT + augment "/container-augment" { + uses grouping-augment-test1; + uses grouping-choice-test; + } +} \ No newline at end of file