import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.*;\r
import org.opendaylight.yangtools.yang.parser.util.ModuleDependencySort\r
import org.opendaylight.yangtools.yang.model.util.ExtendedType;\r
-\r
+import org.opendaylight.yangtools.yang.model.api.UsesNode\r
+import org.opendaylight.yangtools.yang.binding.annotations.RoutingContext\r
+import org.opendaylight.yangtools.sal.binding.model.api.type.builder.AnnotationTypeBuilder\r
+import org.opendaylight.yangtools.yang.model.api.ModuleImport\r
+import org.opendaylight.yangtools.yang.binding.DataContainer\rimport java.util.Iterator
+import org.opendaylight.yangtools.yang.model.api.AugmentationTarget
+import java.util.Collection
+import org.opendaylight.yangtools.yang.model.api.YangNode
+
public class BindingGeneratorImpl implements BindingGenerator {\r
/**\r
* Outter key represents the package name. Outter value represents map of\r
private def List<Type> allTypeDefinitionsToGenTypes(Module module) {\r
checkArgument(module !== null, "Module reference cannot be NULL.");\r
checkArgument(module.name !== null, "Module name cannot be NULL.");\r
- val Set<TypeDefinition<?>> typeDefinitions = module.typeDefinitions;\r
+ val it = new DataNodeIterator(module);\r
+ val List<TypeDefinition<?>> typeDefinitions = it.allTypedefs;\r
checkState(typeDefinitions !== null, '''Type Definitions for module «module.name» cannot be NULL.''');\r
\r
val List<Type> generatedTypes = new ArrayList();\r
}\r
return generatedTypes;\r
}\r
+ \r
+ private def List<Type> dataNodeContainerToGenType(String basePackageName, DataNodeContainer node, Module module) {\r
+ if (node === null) {\r
+ return null;\r
+ }\r
+ if (!(node instanceof SchemaNode)) {\r
+ throw new IllegalArgumentException("node to generate must be instance of SchemaNode");\r
+ }\r
+ val List<Type> result = new ArrayList();\r
+\r
+ result.addAll(processUsesAugments(node, module));\r
+\r
+ val packageName = packageNameForGeneratedType(basePackageName, (node as SchemaNode).path);\r
+ val typeBuilder = addDefaultInterfaceDefinition(packageName, node as SchemaNode);\r
+ val schemaNodes = node.childNodes;\r
+ if (node instanceof ContainerSchemaNode) {\r
+ resolveDataSchemaNodes(basePackageName, typeBuilder, schemaNodes);\r
+ result.add(typeBuilder.toInstance());\r
+ } else if (node instanceof ListSchemaNode) {\r
+ val List<String> listKeys = listKeys(node as ListSchemaNode);\r
+ val genTOBuilder = resolveListKeyTOBuilder(packageName, node as ListSchemaNode);\r
+\r
+ if(genTOBuilder !== null) {\r
+ val identifierMarker = IDENTIFIER.parameterizedTypeFor(typeBuilder);\r
+ val identifiableMarker = IDENTIFIABLE.parameterizedTypeFor(genTOBuilder);\r
+ genTOBuilder.addImplementsType(identifierMarker);\r
+ typeBuilder.addImplementsType(identifiableMarker);\r
+ }\r
+ for (schemaNode : schemaNodes) {\r
+ if (!schemaNode.isAugmenting()) {\r
+ addSchemaNodeToListBuilders(basePackageName, schemaNode, typeBuilder, genTOBuilder, listKeys);\r
+ }\r
+ }\r
+ result.addAll(typeBuildersToGenTypes(typeBuilder, genTOBuilder));\r
+ }\r
+ \r
+ return result;\r
+ }\r
+\r
+ private def List<Type> processUsesAugments(DataNodeContainer node, Module module) {\r
+ val List<Type> result = new ArrayList();\r
+ val basePackageName = moduleNamespaceToPackageName(module);\r
+\r
+ for (usesNode : node.uses) {\r
+ for (augment : usesNode.augmentations) {\r
+ result.addAll(augmentationToGenTypes(basePackageName, augment, module, usesNode));\r
+ result.addAll(processUsesAugments(augment, module));\r
+ }\r
+ }\r
+\r
+ return result;\r
+ }\r
\r
/**\r
* Converts all <b>containers</b> of the module to the list of\r
val basePackageName = moduleNamespaceToPackageName(module);\r
for (container : schemaContainers) {\r
if(!container.isAddedByUses()) {\r
- generatedTypes.add(containerToGenType(basePackageName, container));\r
+ generatedTypes.addAll(dataNodeContainerToGenType(basePackageName, container, module));\r
}\r
}\r
return generatedTypes;\r
if(schemaLists !== null) {\r
for (list : schemaLists) {\r
if(!list.isAddedByUses()) {\r
- generatedTypes.addAll(listToGenType(basePackageName, list));\r
+ generatedTypes.addAll(dataNodeContainerToGenType(basePackageName, list, module));\r
}\r
}\r
}\r
* </ul>\r
*\r
*/\r
- private def List<GeneratedType> allChoicesToGenTypes(Module module) {\r
+ private def List<Type> allChoicesToGenTypes(Module module) {\r
checkArgument(module !== null, "Module reference cannot be NULL.");\r
checkArgument(module.name !== null, "Module name cannot be NULL.");\r
\r
val choiceNodes = it.allChoices();\r
val basePackageName = moduleNamespaceToPackageName(module);\r
\r
- val List<GeneratedType> generatedTypes = new ArrayList();\r
+ val List<Type> generatedTypes = new ArrayList();\r
for (choice : choiceNodes) {\r
if((choice !== null) && !choice.isAddedByUses()) {\r
- generatedTypes.addAll(choiceToGeneratedType(basePackageName, choice));\r
+ generatedTypes.addAll(choiceToGeneratedType(basePackageName, choice, module));\r
}\r
}\r
return generatedTypes;\r
val basePackageName = moduleNamespaceToPackageName(module);\r
val List<AugmentationSchema> augmentations = resolveAugmentations(module);\r
for (augment : augmentations) {\r
- generatedTypes.addAll(augmentationToGenTypes(basePackageName, augment));\r
+ generatedTypes.addAll(augmentationToGenTypes(basePackageName, augment, module, null));\r
}\r
return generatedTypes;\r
}\r
if((nContainers !== null) && !nContainers.isEmpty()) {\r
for (container : nContainers) {\r
if(!container.isAddedByUses()) {\r
- genRPCTypes.add(containerToGenType(basePackageName, container));\r
+ genRPCTypes.addAll(dataNodeContainerToGenType(basePackageName, container, module));\r
}\r
}\r
}\r
if((nLists !== null) && !nLists.isEmpty()) {\r
for (list : nLists) {\r
if(!list.isAddedByUses()) {\r
- genRPCTypes.addAll(listToGenType(basePackageName, list));\r
+ genRPCTypes.addAll(dataNodeContainerToGenType(basePackageName, list, module));\r
+ }\r
+ }\r
+ }\r
+ val List<ChoiceNode> nChoices = iter.allChoices();\r
+ if((nChoices !== null) && !nChoices.isEmpty()) {\r
+ for (choice : nChoices) {\r
+ if(!choice.isAddedByUses()) {\r
+ genRPCTypes.addAll(choiceToGeneratedType(basePackageName, choice, module));\r
}\r
}\r
}\r
val basePackageName = moduleNamespaceToPackageName(module);\r
val List<Type> generatedTypes = new ArrayList();\r
\r
+ \r
+\r
for (notification : notifications) {\r
if(notification !== null) {\r
+ generatedTypes.addAll(processUsesAugments(notification, module));\r
+\r
val iter = new DataNodeIterator(notification);\r
\r
// Containers\r
for (node : iter.allContainers()) {\r
if(!node.isAddedByUses()) {\r
- generatedTypes.add(containerToGenType(basePackageName, node));\r
+ generatedTypes.addAll(dataNodeContainerToGenType(basePackageName, node, module));\r
}\r
}\r
\r
// Lists\r
for (node : iter.allLists()) {\r
if(!node.isAddedByUses()) {\r
- generatedTypes.addAll(listToGenType(basePackageName, node));\r
+ generatedTypes.addAll(dataNodeContainerToGenType(basePackageName, node, module));\r
}\r
}\r
val notificationInterface = addDefaultInterfaceDefinition(basePackageName, notification);\r
checkArgument(module !== null, "Module parameter can not be null");\r
val List<Type> genTypes = new ArrayList();\r
val basePackageName = moduleNamespaceToPackageName(module);\r
- val Set<GroupingDefinition> groupings = module.groupings;\r
+ val it = new DataNodeIterator(module);\r
+ val List<GroupingDefinition> groupings = it.allGroupings();\r
val List<GroupingDefinition> groupingsSortedByDependencies = new GroupingDefinitionDependencySort().sort(\r
groupings);\r
\r
for (grouping : groupingsSortedByDependencies) {\r
- val genType = groupingToGenType(basePackageName, grouping);\r
+ val genType = groupingToGenType(basePackageName, grouping, module);\r
genTypes.add(genType);\r
+ genTypes.addAll(processUsesAugments(grouping, module));\r
val schemaPath = grouping.path;\r
allGroupings.put(schemaPath, genType);\r
}\r
* @return GeneratedType which is generated from grouping (object of type\r
* <code>GroupingDefinition</code>)\r
*/\r
- private def GeneratedType groupingToGenType(String basePackageName, GroupingDefinition grouping) {\r
+ private def GeneratedType groupingToGenType(String basePackageName, GroupingDefinition grouping, Module module) {\r
if(grouping === null) {\r
return null;\r
}\r
val typeBuilder = addDefaultInterfaceDefinition(packageName, grouping);\r
\r
resolveDataSchemaNodes(basePackageName, typeBuilder, schemaNodes);\r
+\r
return typeBuilder.toInstance();\r
}\r
\r
val moduleName = parseToClassName(module.name) + postfix;\r
\r
return new GeneratedTypeBuilderImpl(packageName, moduleName);\r
-\r
}\r
\r
/**\r
* <li>if target path of <code>augSchema</code> equals null</li>\r
* </ul>\r
*/\r
- private def List<Type> augmentationToGenTypes(String augmentPackageName, AugmentationSchema augSchema) {\r
- checkArgument(augmentPackageName !== null, "Package Name cannot be NULL.");\r
- checkArgument(augSchema !== null, "Augmentation Schema cannot be NULL.");\r
- checkState(augSchema.targetPath !== null,\r
- "Augmentation Schema does not contain Target Path (Target Path is NULL).");\r
- val List<Type> genTypes = new ArrayList();\r
-\r
+ private def List<Type> augmentationToGenTypes(String augmentPackageName, AugmentationSchema augSchema, Module module,
+ UsesNode parentUsesNode) {
+ checkArgument(augmentPackageName !== null, "Package Name cannot be NULL.");
+ checkArgument(augSchema !== null, "Augmentation Schema cannot be NULL.");
+ checkState(augSchema.targetPath !== null,
+ "Augmentation Schema does not contain Target Path (Target Path is NULL).");
+ val List<Type> genTypes = new ArrayList();
+ genTypes.addAll(processUsesAugments(augSchema, module));
+
// EVERY augmented interface will extends Augmentation<T> interface\r
// and DataObject interface!!!\r
- val targetPath = augSchema.targetPath;\r
- val targetSchemaNode = findDataSchemaNode(schemaContext, targetPath);\r
- if(targetSchemaNode !== null) {\r
- var targetType = yangToJavaMapping.get(targetSchemaNode.path);\r
- if(targetType == null) {\r
-\r
+ val targetPath = augSchema.targetPath;
+ var targetSchemaNode = findDataSchemaNode(schemaContext, targetPath);
+ if (targetSchemaNode instanceof DataSchemaNode && (targetSchemaNode as DataSchemaNode).isAddedByUses()) {\r
+ if (parentUsesNode == null) {\r
+ targetSchemaNode = findOriginal(targetSchemaNode as DataSchemaNode);\r
+ } else {\r
+ targetSchemaNode = findOriginalTargetFromGrouping(targetSchemaNode.QName.localName, parentUsesNode);\r
+ }\r
+ if (targetSchemaNode == null) {\r
+ throw new NullPointerException(\r
+ "Failed to find target node from grouping for augmentation " + augSchema + " in module " + module.name);\r
+ }
+ }
+\r
+ if (targetSchemaNode !== null) {
+ var targetType = yangToJavaMapping.get(targetSchemaNode.path);
+ if (targetType == null) {
// FIXME: augmentation should be added as last, all types should already be generated\r
// and have assigned Java Types,\r
- val targetModule = findParentModule(schemaContext, targetSchemaNode);\r
- val targetBasePackage = moduleNamespaceToPackageName(targetModule);\r
- val typePackage = packageNameForGeneratedType(targetBasePackage, targetSchemaNode.getPath());\r
- val targetSchemaNodeName = targetSchemaNode.getQName().getLocalName();\r
- val typeName = parseToClassName(targetSchemaNodeName);\r
- targetType = new ReferencedTypeImpl(typePackage, typeName);\r
+ val targetModule = findParentModule(schemaContext, targetSchemaNode);
+ val targetBasePackage = moduleNamespaceToPackageName(targetModule);
+ val typePackage = packageNameForGeneratedType(targetBasePackage, targetSchemaNode.getPath());
+ val targetSchemaNodeName = targetSchemaNode.getQName().getLocalName();
+ val typeName = parseToClassName(targetSchemaNodeName);
+ targetType = new ReferencedTypeImpl(typePackage, typeName);
+ }
+ val augChildNodes = augSchema.childNodes;
+
+ if (!(targetSchemaNode instanceof ChoiceNode)) {
+ var packageName = augmentPackageName;
+ if (parentUsesNode != null) {
+ packageName = packageNameForGeneratedType(augmentPackageName, augSchema.targetPath);
+ }
+ val augTypeBuilder = addRawAugmentGenTypeDefinition(packageName, augmentPackageName, targetType,
+ augSchema);
+ val augType = augTypeBuilder.toInstance();
+ genTypes.add(augType);
+ } else {
+ genTypes.addAll(
+ generateTypesFromAugmentedChoiceCases(augmentPackageName, targetType, augChildNodes,
+ targetSchemaNode as ChoiceNode));
+ }
+ genTypes.addAll(augmentationBodyToGenTypes(augmentPackageName, augChildNodes, module));
+ }
+
+ return genTypes;
+ }\r
+\r
+ /**\r
+ * Utility method which search for original node defined in grouping.\r
+ */\r
+ private def DataSchemaNode findOriginal(DataSchemaNode node) {\r
+ var DataSchemaNode result = findCorrectTargetFromGrouping(node);\r
+ if (result == null) {\r
+ result = findCorrectTargetFromAugment(node);\r
+ if (result != null) {\r
+ if (result.addedByUses) {\r
+ result = findOriginal(result);\r
+ }\r
}\r
- val augChildNodes = augSchema.childNodes;\r
- if(!(targetSchemaNode instanceof ChoiceNode)) {\r
- val augTypeBuilder = addRawAugmentGenTypeDefinition(augmentPackageName, targetType, augSchema);\r
- val augType = augTypeBuilder.toInstance();\r
- genTypes.add(augType);\r
+ }\r
+ return result;\r
+ }\r
+\r
+ private def DataSchemaNode findCorrectTargetFromAugment(DataSchemaNode node) {\r
+ if (!node.augmenting) {\r
+ return null;\r
+ }\r
+\r
+ var String currentName = node.QName.localName;\r
+ var tmpPath = new ArrayList<String>();\r
+ var YangNode parent = node;\r
+ var AugmentationSchema augment = null;\r
+ do {\r
+ parent = (parent as DataSchemaNode).parent;\r
+ if (parent instanceof AugmentationTarget) {\r
+ tmpPath.add(currentName);\r
+ augment = findNodeInAugment((parent as AugmentationTarget).availableAugmentations, currentName);\r
+ if (augment == null) {\r
+ currentName = (parent as DataSchemaNode).QName.localName; \r
+ }\r
+ }\r
+ } while ((parent as DataSchemaNode).augmenting && augment == null);\r
+\r
+ if (augment == null) {\r
+ return null;\r
+ } else {\r
+ Collections.reverse(tmpPath);\r
+ var Object actualParent = augment;\r
+ var DataSchemaNode result = null;\r
+ for (name : tmpPath) {\r
+ if (actualParent instanceof DataNodeContainer) {\r
+ result = (actualParent as DataNodeContainer).getDataChildByName(name);\r
+ actualParent = (actualParent as DataNodeContainer).getDataChildByName(name);\r
+ } else {\r
+ if (actualParent instanceof ChoiceNode) {\r
+ result = (actualParent as ChoiceNode).getCaseNodeByName(name);\r
+ actualParent = (actualParent as ChoiceNode).getCaseNodeByName(name); \r
+ }\r
+ }\r
+ }\r
+\r
+ if (result.addedByUses) {\r
+ result = findCorrectTargetFromGrouping(result);\r
+ }\r
+\r
+ return result;\r
+ }\r
+ }\r
+\r
+ private def AugmentationSchema findNodeInAugment(Collection<AugmentationSchema> augments, String name) {\r
+ for (augment : augments) {\r
+ if (augment.getDataChildByName(name) != null) {\r
+ return augment;\r
+ }\r
+ }\r
+ return null;\r
+ }\r
+\r
+ private def DataSchemaNode findCorrectTargetFromGrouping(DataSchemaNode node) {\r
+ if (node.path.path.size == 1) {\r
+ // uses is under module statement\r
+ val Module m = findParentModule(schemaContext, node);\r
+ var DataSchemaNode result = null;\r
+ for (u : m.uses) {\r
+ var SchemaNode targetGrouping = findNodeInSchemaContext(schemaContext, u.groupingPath.path);\r
+ if (!(targetGrouping instanceof GroupingDefinition)) {\r
+ throw new IllegalArgumentException("Failed to generate code for augment in " + u);\r
+ }\r
+ var gr = targetGrouping as GroupingDefinition;\r
+ result = gr.getDataChildByName(node.QName.localName);\r
+ }\r
+ if (result == null) {\r
+ throw new IllegalArgumentException("Failed to generate code for augment");\r
+ }\r
+ return result;\r
+ } else {\r
+ var DataSchemaNode result = null;\r
+ var String currentName = node.QName.localName;\r
+ var tmpPath = new ArrayList<String>();\r
+ var YangNode parent = node.parent; \r
+ do {\r
+ tmpPath.add(currentName);\r
+ val dataNodeParent = parent as DataNodeContainer;\r
+ for (u : dataNodeParent.uses) {\r
+ var SchemaNode targetGrouping = findNodeInSchemaContext(schemaContext, u.groupingPath.path);\r
+ if (!(targetGrouping instanceof GroupingDefinition)) {\r
+ throw new IllegalArgumentException("Failed to generate code for augment in " + u);\r
+ }\r
+ var gr = targetGrouping as GroupingDefinition;\r
+ result = gr.getDataChildByName(currentName);\r
+ }\r
+ if (result == null) {\r
+ currentName = (parent as SchemaNode).QName.localName;\r
+ if (parent instanceof DataSchemaNode) {\r
+ parent = (parent as DataSchemaNode).parent;\r
+ } else {\r
+ parent = (parent as DataNodeContainer).parent;\r
+ }\r
+ }\r
+ } while (result == null && !(parent instanceof Module));\r
+\r
+ if (result != null) {\r
+ if (tmpPath.size == 1) {\r
+ return result;\r
+ } else {\r
+ var DataSchemaNode newParent = result;\r
+ Collections.reverse(tmpPath);\r
+ tmpPath.remove(0);\r
+ for (name : tmpPath) {\r
+ newParent = (newParent as DataNodeContainer).getDataChildByName(name);\r
+ }\r
+ return newParent;\r
+ }\r
+ }\r
+\r
+ return result;\r
+ }\r
+ }\r
+\r
+ /**\r
+ * Convenient method to find node added by uses statement.\r
+ */\r
+ private def DataSchemaNode findOriginalTargetFromGrouping(String targetSchemaNodeName, UsesNode parentUsesNode) {\r
+ var SchemaNode targetGrouping = findNodeInSchemaContext(schemaContext, parentUsesNode.groupingPath.path);\r
+ if (!(targetGrouping instanceof GroupingDefinition)) {\r
+ throw new IllegalArgumentException("Failed to generate code for augment in " + parentUsesNode);\r
+ }\r
+\r
+ var grouping = targetGrouping as GroupingDefinition;\r
+ var result = grouping.getDataChildByName(targetSchemaNodeName);\r
+ if (result == null) {\r
+ return null;\r
+ }\r
+ var boolean fromUses = result.addedByUses;\r
+\r
+ var Iterator<UsesNode> groupingUses = grouping.uses.iterator;\r
+ while (fromUses) {\r
+ if (groupingUses.hasNext()) {\r
+ grouping = findNodeInSchemaContext(schemaContext, groupingUses.next().groupingPath.path) as GroupingDefinition;\r
+ result = grouping.getDataChildByName(targetSchemaNodeName);\r
+ fromUses = result.addedByUses;\r
} else {\r
- val choiceTarget = targetSchemaNode as ChoiceNode;\r
- val choiceCaseNodes = choiceTarget.cases;\r
- genTypes.addAll(\r
- generateTypesFromAugmentedChoiceCases(augmentPackageName, targetType, choiceCaseNodes));\r
+ throw new NullPointerException("Failed to generate code for augment in " + parentUsesNode);\r
}\r
- genTypes.addAll(augmentationBodyToGenTypes(augmentPackageName, augChildNodes));\r
}\r
- return genTypes;\r
+\r
+ return result;\r
}\r
\r
/**\r
* and uses of augment\r
* @return generated type builder for augment\r
*/\r
- private def GeneratedTypeBuilder addRawAugmentGenTypeDefinition(String augmentPackageName, Type targetTypeRef,\r
- AugmentationSchema augSchema) {\r
+ private def GeneratedTypeBuilder addRawAugmentGenTypeDefinition(String augmentPackageName, String basePackageName,\r
+ Type targetTypeRef, AugmentationSchema augSchema) {\r
var Map<String, GeneratedTypeBuilder> augmentBuilders = genTypeBuilders.get(augmentPackageName);\r
- if(augmentBuilders === null) {\r
+ if (augmentBuilders === null) {\r
augmentBuilders = new HashMap();\r
genTypeBuilders.put(augmentPackageName, augmentBuilders);\r
}\r
val augIdentifier = getAugmentIdentifier(augSchema.unknownSchemaNodes);\r
\r
- val augTypeName = if(augIdentifier !== null) {\r
+ val augTypeName = if (augIdentifier !== null) {\r
parseToClassName(augIdentifier)\r
} else {\r
augGenTypeName(augmentBuilders, targetTypeRef.name);\r
}\r
- val Set<DataSchemaNode> augChildNodes = augSchema.childNodes;\r
\r
val augTypeBuilder = new GeneratedTypeBuilderImpl(augmentPackageName, augTypeName);\r
\r
augTypeBuilder.addImplementsType(Types.augmentationTypeFor(targetTypeRef));\r
addImplementedInterfaceFromUses(augSchema, augTypeBuilder);\r
\r
- augSchemaNodeToMethods(augmentPackageName, augTypeBuilder, augChildNodes);\r
+ augSchemaNodeToMethods(basePackageName, augTypeBuilder, augSchema.childNodes);\r
augmentBuilders.put(augTypeName, augTypeBuilder);\r
return augTypeBuilder;\r
}\r
* @return list of <code>Type</code> which represents container, list and\r
* choice subnodes of augment\r
*/\r
- private def List<Type> augmentationBodyToGenTypes(String augBasePackageName, Set<DataSchemaNode> augChildNodes) {\r
+ private def List<Type> augmentationBodyToGenTypes(String augBasePackageName, Set<DataSchemaNode> augChildNodes, Module module) {\r
val List<Type> genTypes = new ArrayList();\r
val List<DataNodeIterator> augSchemaIts = new ArrayList();\r
for (childNode : augChildNodes) {\r
+ if (!childNode.addedByUses) {\r
+ \r
+ \r
if(childNode instanceof DataNodeContainer) {\r
augSchemaIts.add(new DataNodeIterator(childNode as DataNodeContainer));\r
\r
if(childNode instanceof ContainerSchemaNode) {\r
- genTypes.add(containerToGenType(augBasePackageName, childNode as ContainerSchemaNode));\r
+ genTypes.addAll(dataNodeContainerToGenType(augBasePackageName, childNode as ContainerSchemaNode, module));\r
} else if(childNode instanceof ListSchemaNode) {\r
- genTypes.addAll(listToGenType(augBasePackageName, childNode as ListSchemaNode));\r
+ genTypes.addAll(dataNodeContainerToGenType(augBasePackageName, childNode as ListSchemaNode, module));\r
}\r
} else if(childNode instanceof ChoiceNode) {\r
val choice = childNode as ChoiceNode;\r
for (caseNode : choice.cases) {\r
augSchemaIts.add(new DataNodeIterator(caseNode));\r
}\r
- genTypes.addAll(choiceToGeneratedType(augBasePackageName, childNode as ChoiceNode));\r
+ genTypes.addAll(choiceToGeneratedType(augBasePackageName, childNode as ChoiceNode, module));\r
+ }\r
+ \r
+ \r
}\r
}\r
\r
\r
if(augContainers !== null) {\r
for (container : augContainers) {\r
- genTypes.add(containerToGenType(augBasePackageName, container));\r
+ genTypes.addAll(dataNodeContainerToGenType(augBasePackageName, container, module));\r
}\r
}\r
if(augLists !== null) {\r
for (list : augLists) {\r
- genTypes.addAll(listToGenType(augBasePackageName, list));\r
+ genTypes.addAll(dataNodeContainerToGenType(augBasePackageName, list, module));\r
}\r
}\r
if(augChoices !== null) {\r
for (choice : augChoices) {\r
- genTypes.addAll(choiceToGeneratedType(augBasePackageName, choice));\r
+ genTypes.addAll(choiceToGeneratedType(augBasePackageName, choice, module));\r
}\r
}\r
}\r
return genTypeName + index;\r
}\r
\r
- /**\r
- * Converts <code>containerNode</code> to generated type. Firstly the\r
- * generated type builder is created. The subnodes of\r
- * <code>containerNode</code> are added as methods and the instance of\r
- * <code>GeneratedType</code> is returned.\r
- *\r
- * @param basePackageName\r
- * string contains the module package name\r
- * @param containerNode\r
- * container schema node with the data about childs nodes and\r
- * schema paths\r
- * @return generated type for <code>containerNode</code>\r
- */\r
- private def GeneratedType containerToGenType(String basePackageName, ContainerSchemaNode containerNode) {\r
- if(containerNode === null) {\r
- return null;\r
- }\r
-\r
- val packageName = packageNameForGeneratedType(basePackageName, containerNode.path);\r
- val schemaNodes = containerNode.childNodes;\r
- val typeBuilder = addDefaultInterfaceDefinition(packageName, containerNode);\r
-\r
- resolveDataSchemaNodes(basePackageName, typeBuilder, schemaNodes);\r
- return typeBuilder.toInstance();\r
- }\r
-\r
/**\r
* Adds the methods to <code>typeBuilder</code> which represent subnodes of\r
* node for which <code>typeBuilder</code> was created.\r
}\r
return typeBuilder;\r
}\r
+ \r
+ private def GeneratedTypeBuilder resolveDataSchemaNodesAugmented(String basePackageName, GeneratedTypeBuilder typeBuilder,\r
+ Set<DataSchemaNode> schemaNodes) {\r
+ if ((schemaNodes !== null) && (typeBuilder !== null)) {\r
+ for (schemaNode : schemaNodes) {\r
+ if (!schemaNode.isAddedByUses()) {\r
+ addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode, typeBuilder);\r
+ }\r
+ }\r
+ }\r
+ return typeBuilder;\r
+ }\r
\r
/**\r
* Adds the methods to <code>typeBuilder</code> what represents subnodes of\r
Set<DataSchemaNode> schemaNodes) {\r
if((schemaNodes !== null) && (typeBuilder !== null)) {\r
for (schemaNode : schemaNodes) {\r
- if(schemaNode.isAugmenting()) {\r
- addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode, typeBuilder);\r
- }\r
- }\r
- }\r
- return typeBuilder;\r
- }\r
+ if (!schemaNode.isAugmenting()) {\r
+ addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode, typeBuilder);\r
+ }\r
+ }\r
+ }\r
+ return typeBuilder;\r
+ }\r
\r
/**\r
* Adds to <code>typeBuilder</code> a method which is derived from\r
* </ul>\r
*\r
*/\r
- private def List<GeneratedType> choiceToGeneratedType(String basePackageName, ChoiceNode choiceNode) {\r
+ private def List<Type> choiceToGeneratedType(String basePackageName, ChoiceNode choiceNode, Module module) {\r
checkArgument(basePackageName !== null, "Base Package Name cannot be NULL.");\r
checkArgument(choiceNode !== null, "Choice Schema Node cannot be NULL.");\r
\r
- val List<GeneratedType> generatedTypes = new ArrayList();\r
+ val List<Type> generatedTypes = new ArrayList();\r
val packageName = packageNameForGeneratedType(basePackageName, choiceNode.path);\r
val choiceTypeBuilder = addRawInterfaceDefinition(packageName, choiceNode);\r
\r
- //choiceTypeBuilder.addImplementsType(DATA_OBJECT);\r
+ choiceTypeBuilder.addImplementsType(DataContainer.typeForClass);\r
val choiceType = choiceTypeBuilder.toInstance();\r
\r
generatedTypes.add(choiceType);\r
val Set<ChoiceCaseNode> caseNodes = choiceNode.cases;\r
if((caseNodes !== null) && !caseNodes.isEmpty()) {\r
- generatedTypes.addAll(generateTypesFromChoiceCases(basePackageName, choiceType, caseNodes));\r
+ generatedTypes.addAll(generateTypesFromChoiceCases(basePackageName, choiceType, caseNodes, module));\r
}\r
return generatedTypes;\r
}\r
* </ul>\r
* *\r
*/\r
- private def List<GeneratedType> generateTypesFromChoiceCases(String basePackageName, Type refChoiceType,\r
- Set<ChoiceCaseNode> caseNodes) {\r
+ private def List<Type> generateTypesFromChoiceCases(String basePackageName, Type refChoiceType,\r
+ Set<ChoiceCaseNode> caseNodes, Module module) {\r
checkArgument(basePackageName !== null, "Base Package Name cannot be NULL.");\r
checkArgument(refChoiceType !== null, "Referenced Choice Type cannot be NULL.");\r
checkArgument(caseNodes !== null, "Set of Choice Case Nodes cannot be NULL.");\r
\r
- val List<GeneratedType> generatedTypes = new ArrayList();\r
+ val List<Type> generatedTypes = new ArrayList();\r
for (caseNode : caseNodes) {\r
if(caseNode !== null && !caseNode.isAddedByUses() && !caseNode.isAugmenting()) {\r
val packageName = packageNameForGeneratedType(basePackageName, caseNode.path);\r
}\r
generatedTypes.add(caseTypeBuilder.toInstance());\r
}\r
+ \r
+ generatedTypes.addAll(processUsesAugments(caseNode, module));\r
}\r
\r
return generatedTypes;\r
* </ul>\r
*/\r
private def List<GeneratedType> generateTypesFromAugmentedChoiceCases(String basePackageName, Type refChoiceType,\r
- Set<ChoiceCaseNode> caseNodes) {\r
+ Set<DataSchemaNode> caseNodes, ChoiceNode targetNode) {\r
checkArgument(basePackageName !== null, "Base Package Name cannot be NULL.");\r
checkArgument(refChoiceType !== null, "Referenced Choice Type cannot be NULL.");\r
checkArgument(caseNodes !== null, "Set of Choice Case Nodes cannot be NULL.");\r
\r
val List<GeneratedType> generatedTypes = new ArrayList();\r
for (caseNode : caseNodes) {\r
- if(caseNode !== null && caseNode.isAugmenting()) {\r
+ if(caseNode !== null) {\r
val packageName = packageNameForGeneratedType(basePackageName, caseNode.path);\r
val caseTypeBuilder = addDefaultInterfaceDefinition(packageName, caseNode);\r
caseTypeBuilder.addImplementsType(refChoiceType);\r
\r
- val Set<DataSchemaNode> childNodes = caseNode.childNodes;\r
- if(childNodes !== null) {\r
- resolveDataSchemaNodes(basePackageName, caseTypeBuilder, childNodes);\r
+ if (caseNode instanceof DataNodeContainer) {\r
+ val DataNodeContainer dataNodeCase = caseNode as DataNodeContainer;\r
+ val Set<DataSchemaNode> childNodes = dataNodeCase.childNodes;\r
+ if(childNodes !== null) {\r
+ resolveDataSchemaNodesAugmented(basePackageName, caseTypeBuilder, childNodes);\r
+ }\r
+ } else {\r
+ val ChoiceCaseNode node = targetNode.getCaseNodeByName(caseNode.getQName().getLocalName());\r
+ val Set<DataSchemaNode> childNodes = node.childNodes;\r
+ if(childNodes !== null) {\r
+ resolveDataSchemaNodesAugmented(basePackageName, caseTypeBuilder, childNodes);\r
+ }\r
}\r
+ \r
generatedTypes.add(caseTypeBuilder.toInstance());\r
}\r
}\r
returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf);\r
}\r
if(returnType !== null) {\r
- constructGetter(typeBuilder, leafName, leafDesc, returnType);\r
+ val MethodSignatureBuilder getter = constructGetter(typeBuilder, leafName, leafDesc, returnType);\r
+ processContextRefExtension(leaf, getter, parentModule);\r
return true;\r
}\r
}\r
return false;\r
}\r
\r
+ private def void processContextRefExtension(LeafSchemaNode leaf, MethodSignatureBuilder getter, Module module) {\r
+ for (node : leaf.unknownSchemaNodes) {\r
+ val nodeType = node.nodeType;\r
+ if ("context-reference".equals(nodeType.localName)) {\r
+ val nodeParam = node.nodeParameter;\r
+ var IdentitySchemaNode identity = null;\r
+ var String basePackageName = null;\r
+ val String[] splittedElement = nodeParam.split(":");\r
+ if (splittedElement.length == 1) {\r
+ identity = findIdentityByName(module.identities, splittedElement.get(0));\r
+ basePackageName = moduleNamespaceToPackageName(module);\r
+ } else if (splittedElement.length == 2) {\r
+ var prefix = splittedElement.get(0);\r
+ val Module dependentModule = findModuleFromImports(module.imports, prefix)\r
+ if (dependentModule == null) {\r
+ throw new IllegalArgumentException("Failed to process context-reference: unknown prefix " + prefix);\r
+ }\r
+ identity = findIdentityByName(dependentModule.identities, splittedElement.get(1));\r
+ basePackageName = moduleNamespaceToPackageName(dependentModule);\r
+ } else {\r
+ throw new IllegalArgumentException("Failed to process context-reference: unknown identity " + nodeParam);\r
+ }\r
+ if (identity == null) {\r
+ throw new IllegalArgumentException("Failed to process context-reference: unknown identity " + nodeParam);\r
+ }\r
+\r
+ val Class<RoutingContext> clazz = typeof(RoutingContext);\r
+ val AnnotationTypeBuilder rc = getter.addAnnotation(clazz.package.name, clazz.simpleName);\r
+ val packageName = packageNameForGeneratedType(basePackageName, identity.path);\r
+ val genTypeName = parseToClassName(identity.QName.localName);\r
+ rc.addParameter("value", packageName + "." + genTypeName + ".class");\r
+ }\r
+ }\r
+ }\r
+\r
+ private def IdentitySchemaNode findIdentityByName(Set<IdentitySchemaNode> identities, String name) {\r
+ for (id : identities) {\r
+ if (id.QName.localName.equals(name)) {\r
+ return id;\r
+ }\r
+ }\r
+ return null;\r
+ }\r
+\r
+ private def Module findModuleFromImports(Set<ModuleImport> imports, String prefix) {\r
+ for (imp : imports) {\r
+ if (imp.prefix.equals(prefix)) {\r
+ return schemaContext.findModuleByName(imp.moduleName, imp.revision);\r
+ }\r
+ }\r
+ return null;\r
+ }\r
+\r
/**\r
* Converts <code>leaf</code> schema node to property of generated TO\r
* builder.\r
return getMethod;\r
}\r
\r
- private def listToGenType(String basePackageName, ListSchemaNode list) {\r
- checkArgument(basePackageName !== null, "Package Name for Generated Type cannot be NULL.");\r
- checkArgument(list !== null, "List Schema Node cannot be NULL.");\r
-\r
- val packageName = packageNameForGeneratedType(basePackageName, list.path);\r
-\r
- // val typeBuilder =\r
- // resolveListTypeBuilder(packageName, list);\r
- val typeBuilder = addDefaultInterfaceDefinition(packageName, list);\r
-\r
- val List<String> listKeys = listKeys(list);\r
- val genTOBuilder = resolveListKeyTOBuilder(packageName, list);\r
-\r
- if(genTOBuilder !== null) {\r
- val identifierMarker = IDENTIFIER.parameterizedTypeFor(typeBuilder);\r
- val identifiableMarker = IDENTIFIABLE.parameterizedTypeFor(genTOBuilder);\r
- genTOBuilder.addImplementsType(identifierMarker);\r
- typeBuilder.addImplementsType(identifiableMarker);\r
- }\r
- val schemaNodes = list.childNodes;\r
-\r
- for (schemaNode : schemaNodes) {\r
- if(!schemaNode.isAugmenting()) {\r
- addSchemaNodeToListBuilders(basePackageName, schemaNode, typeBuilder, genTOBuilder, listKeys);\r
- }\r
- }\r
- return typeBuildersToGenTypes(typeBuilder, genTOBuilder);\r
- }\r
-\r
/**\r
* Adds <code>schemaNode</code> to <code>typeBuilder</code> as getter method\r
* or to <code>genTOBuilder</code> as property.\r
} else {\r
resolveLeafSchemaNodeAsProperty(genTOBuilder, leaf, true);\r
}\r
- } else if(schemaNode instanceof LeafListSchemaNode) {\r
- resolveLeafListSchemaNode(typeBuilder, schemaNode as LeafListSchemaNode);\r
- } else if(schemaNode instanceof ContainerSchemaNode) {\r
- resolveContainerSchemaNode(basePackageName, typeBuilder, schemaNode as ContainerSchemaNode);\r
- } else if(schemaNode instanceof ChoiceNode) {\r
- resolveChoiceSchemaNode(basePackageName,typeBuilder,schemaNode as ChoiceNode);\r
- } else if(schemaNode instanceof ListSchemaNode) {\r
- resolveListSchemaNode(basePackageName, typeBuilder, schemaNode as ListSchemaNode);\r
+ } else if (!schemaNode.addedByUses) {\r
+ if (schemaNode instanceof LeafListSchemaNode) {\r
+ resolveLeafListSchemaNode(typeBuilder, schemaNode as LeafListSchemaNode);\r
+ } else if(schemaNode instanceof ContainerSchemaNode) {\r
+ resolveContainerSchemaNode(basePackageName, typeBuilder, schemaNode as ContainerSchemaNode);\r
+ } else if(schemaNode instanceof ChoiceNode) {\r
+ resolveChoiceSchemaNode(basePackageName,typeBuilder,schemaNode as ChoiceNode);\r
+ } else if(schemaNode instanceof ListSchemaNode) {\r
+ resolveListSchemaNode(basePackageName, typeBuilder, schemaNode as ListSchemaNode);\r
+ }\r
}\r
}\r
\r
Code Review / yangtools.git / blobdiff