*/
package org.opendaylight.yangtools.sal.binding.generator.impl;
-import static org.opendaylight.yangtools.binding.generator.util.BindingGeneratorUtil.moduleNamespaceToPackageName;
-import static org.opendaylight.yangtools.binding.generator.util.BindingGeneratorUtil.packageNameForGeneratedType;
-import static org.opendaylight.yangtools.binding.generator.util.BindingGeneratorUtil.parseToClassName;
-import static org.opendaylight.yangtools.binding.generator.util.BindingGeneratorUtil.parseToValidParamName;
-import static org.opendaylight.yangtools.binding.generator.util.BindingGeneratorUtil.schemaNodeToTransferObjectBuilder;
-import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.findDataSchemaNode;
-import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.findParentModule;
-
-import java.net.URI;
-import java.net.URISyntaxException;
+import static org.opendaylight.yangtools.binding.generator.util.BindingGeneratorUtil.*;
+import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.*;
+
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import org.opendaylight.yangtools.binding.generator.util.generated.type.builder.GeneratedTypeBuilderImpl;
import org.opendaylight.yangtools.sal.binding.generator.api.BindingGenerator;
import org.opendaylight.yangtools.sal.binding.generator.spi.TypeProvider;
-import org.opendaylight.yangtools.sal.binding.model.api.ConcreteType;
import org.opendaylight.yangtools.sal.binding.model.api.GeneratedTransferObject;
import org.opendaylight.yangtools.sal.binding.model.api.GeneratedType;
import org.opendaylight.yangtools.sal.binding.model.api.ParameterizedType;
/**
* Only parent constructor is invoked.
*/
-
+
private final static String YANG_EXT_NAMESPACE = "urn:opendaylight:yang:extension:yang-ext";
private final static String AUGMENT_IDENTIFIER_NAME = "augment-identifier";
-
+
public BindingGeneratorImpl() {
super();
}
/**
* Resolves generated types from <code>context</code> schema nodes of all
* modules.
- *
+ *
* Generated types are created for modules, groupings, types, containers,
* lists, choices, augments, rpcs, notification, identities.
- *
+ *
* @param context
* schema context which contains data about all schema nodes
* saved in modules
/**
* Resolves generated types from <code>context</code> schema nodes only for
* modules specified in <code>modules</code>
- *
+ *
* Generated types are created for modules, groupings, types, containers,
* lists, choices, augments, rpcs, notification, identities.
- *
+ *
* @param context
* schema context which contains data about all schema nodes
* saved in modules
/**
* Converts all extended type definitions of module to the list of
* <code>Type</code> objects.
- *
+ *
* @param module
* module from which is obtained set of type definitions
* @return list of <code>Type</code> which are generated from extended
* <li>if name of module equals null</li>
* <li>if type definitions of module equal null</li>
* </ul>
- *
+ *
*/
private List<Type> allTypeDefinitionsToGenTypes(final Module module) {
if (module == null) {
/**
* Converts all <b>containers</b> of the module to the list of
* <code>Type</code> objects.
- *
+ *
* @param module
* module from which is obtained DataNodeIterator to iterate over
* all containers
* <li>if the name of module equals null</li>
* <li>if the set of child nodes equals null</li>
* </ul>
- *
+ *
*/
private List<Type> allContainersToGenTypes(final Module module) {
if (module == null) {
/**
* Converts all <b>lists</b> of the module to the list of <code>Type</code>
* objects.
- *
+ *
* @param module
* module from which is obtained DataNodeIterator to iterate over
* all lists
* <li>if the name of module equals null</li>
* <li>if the set of child nodes equals null</li>
* </ul>
- *
+ *
*/
private List<Type> allListsToGenTypes(final Module module) {
if (module == null) {
/**
* Converts all <b>choices</b> of the module to the list of
* <code>Type</code> objects.
- *
+ *
* @param module
* module from which is obtained DataNodeIterator to iterate over
* all choices
* <li>if the module equals null</li>
* <li>if the name of module equals null</li> *
* </ul>
- *
+ *
*/
private List<GeneratedType> allChoicesToGenTypes(final Module module) {
if (module == null) {
/**
* Converts all <b>augmentation</b> of the module to the list
* <code>Type</code> objects.
- *
+ *
* @param module
* module from which is obtained list of all augmentation objects
* to iterate over them
* <li>if the name of module equals null</li>
* <li>if the set of child nodes equals null</li>
* </ul>
- *
+ *
*/
private List<Type> allAugmentsToGenTypes(final Module module) {
if (module == null) {
* Returns list of <code>AugmentationSchema</code> objects. The objects are
* sorted according to the length of their target path from the shortest to
* the longest.
- *
+ *
* @param module
* module from which is obtained list of all augmentation objects
* @return list of sorted <code>AugmentationSchema</code> objects obtained
* <li>if the module equals null</li>
* <li>if the set of augmentation equals null</li>
* </ul>
- *
+ *
*/
private List<AugmentationSchema> resolveAugmentations(final Module module) {
if (module == null) {
* Converts whole <b>module</b> to <code>GeneratedType</code> object.
* Firstly is created the module builder object from which is finally
* obtained reference to <code>GeneratedType</code> object.
- *
+ *
* @param module
* module from which are obtained the module name, child nodes,
* uses and is derived package name
* the module
* @throws IllegalArgumentException
* if the module equals null
- *
+ *
*/
private GeneratedType moduleToDataType(final Module module) {
if (module == null) {
* Converts all <b>rpcs</b> inputs and outputs substatements of the module
* to the list of <code>Type</code> objects. In addition are to containers
* and lists which belong to input or output also part of returning list.
- *
+ *
* @param module
* module from which is obtained set of all rpc objects to
* iterate over them
* <li>if the name of module equals null</li>
* <li>if the set of child nodes equals null</li>
* </ul>
- *
+ *
*/
private List<Type> allRPCMethodsToGenType(final Module module) {
if (module == null) {
* Converts all <b>notifications</b> of the module to the list of
* <code>Type</code> objects. In addition are to this list added containers
* and lists which are part of this notification.
- *
+ *
* @param module
* module from which is obtained set of all notification objects
* to iterate over them
* <li>if the name of module equals null</li>
* <li>if the set of child nodes equals null</li>
* </ul>
- *
+ *
*/
private List<Type> allNotificationsToGenType(final Module module) {
if (module == null) {
/**
* Converts all <b>identities</b> of the module to the list of
* <code>Type</code> objects.
- *
+ *
* @param module
* module from which is obtained set of all identity objects to
* iterate over them
* {@link identityToGenType}
* @return list of <code>Type</code> which are generated from identities
* (object of type <code>IdentitySchemaNode</code>
- *
+ *
*/
private List<Type> allIdentitiesToGenTypes(final Module module, final SchemaContext context) {
List<Type> genTypes = new ArrayList<>();
* If identity doesn't contain base identity then only reference to abstract
* class {@link org.opendaylight.yangtools.yang.model.api.BaseIdentity
* BaseIdentity} is added
- *
+ *
* @param basePackageName
* string contains the module package name
* @param identity
* @param context
* SchemaContext which is used to get package and name
* information about base of identity
- *
+ *
* @return GeneratedType which is generated from identity (object of type
* <code>IdentitySchemaNode</code>
- *
+ *
*/
private GeneratedType identityToGenType(final String basePackageName, final IdentitySchemaNode identity,
final SchemaContext context) {
* dependencies. At least dependend (indepedent) groupings are in the list
* saved at first positions. For every grouping the record is added to map
* {@link BindingGeneratorImpl#allGroupings allGroupings}
- *
+ *
* @param module
* module from which is obtained set of all grouping objects to
* iterate over them
* @return list of <code>Type</code> which are generated from groupings
* (object of type <code>GroupingDefinition</code>)
- *
+ *
*/
private List<Type> allGroupingsToGenTypes(final Module module) {
if (module == null) {
final Set<GroupingDefinition> groupings = module.getGroupings();
List<GroupingDefinition> groupingsSortedByDependencies;
- groupingsSortedByDependencies = GroupingDefinitionDependencySort.sort(groupings);
+ groupingsSortedByDependencies = GroupingDefinitionDependencySort.sort(groupings);
for (final GroupingDefinition grouping : groupingsSortedByDependencies) {
GeneratedType genType = groupingToGenType(basePackageName, grouping);
* Converts individual grouping to GeneratedType. Firstly generated type
* builder is created and every child node of grouping is resolved to the
* method.
- *
+ *
* @param basePackageName
* string contains the module package name
* @param grouping
* Tries to find EnumTypeDefinition in <code>typeDefinition</code>. If base
* type of <code>typeDefinition</code> is of the type ExtendedType then this
* method is recursivelly called with this base type.
- *
+ *
* @param typeDefinition
* TypeDefinition in which should be EnumTypeDefinition found as
* base type
/**
* Adds enumeration builder created from <code>enumTypeDef</code> to
* <code>typeBuilder</code>.
- *
+ *
* Each <code>enumTypeDef</code> item is added to builder with its name and
* value.
- *
+ *
* @param enumTypeDef
* EnumTypeDefinition contains enum data
* @param enumName
/**
* Generates type builder for <code>module</code>.
- *
+ *
* @param module
* Module which is source of package name for generated type
* builder
* generated types for all containers, list and choices which are child of
* <code>augSchema</code> node or a generated types for cases are added if
* augmented node is choice.
- *
+ *
* @param augmentPackageName
* string with the name of the package to which the augmentation
* belongs
/**
* Returns a generated type builder for an augmentation.
- *
+ *
* The name of the type builder is equal to the name of augmented node with
* serial number as suffix.
- *
+ *
* @param augmentPackageName
* string with contains the package name to which the augment
* belongs
genTypeBuilders.put(augmentPackageName, augmentBuilders);
}
final String augIdentifier = getAugmentIdentifier(augSchema.getUnknownSchemaNodes());
-
- final String augTypeName = augIdentifier != null ? parseToClassName(augIdentifier): augGenTypeName(augmentBuilders, targetTypeName);
+
+ final String augTypeName = augIdentifier != null ? parseToClassName(augIdentifier) : augGenTypeName(
+ augmentBuilders, targetTypeName);
final Type targetTypeRef = new ReferencedTypeImpl(targetPackageName, targetTypeName);
final Set<DataSchemaNode> augChildNodes = augSchema.getChildNodes();
String ret = null;
for (UnknownSchemaNode unknownSchemaNode : unknownSchemaNodes) {
QName nodeType = unknownSchemaNode.getNodeType();
- if(AUGMENT_IDENTIFIER_NAME.equals(nodeType.getLocalName()) &&
- YANG_EXT_NAMESPACE.equals(nodeType.getNamespace().toString())) {
+ if (AUGMENT_IDENTIFIER_NAME.equals(nodeType.getLocalName())
+ && YANG_EXT_NAMESPACE.equals(nodeType.getNamespace().toString())) {
return unknownSchemaNode.getNodeParameter();
}
}
/**
* Convert a container, list and choice subnodes (and recursivelly their
* subnodes) of augment to generated types
- *
+ *
* @param augBasePackageName
* string with the augment package name
* @param augChildNodes
* set of data schema nodes which represents child nodes of the
* augment
- *
+ *
* @return list of <code>Type</code> which represents container, list and
* choice subnodes of augment
*/
* Returns first unique name for the augment generated type builder. The
* generated type builder name for augment consists from name of augmented
* node and serial number of its augmentation.
- *
+ *
* @param builders
* map of builders which were created in the package to which the
* augmentation belongs
* generated type builder is created. The subnodes of
* <code>containerNode</code> are added as methods and the instance of
* <code>GeneratedType</code> is returned.
- *
+ *
* @param basePackageName
* string contains the module package name
* @param containerNode
/**
* Adds the methods to <code>typeBuilder</code> which represent subnodes of
* node for which <code>typeBuilder</code> was created.
- *
+ *
* The subnodes aren't mapped to the methods if they are part of grouping or
* augment (in this case are already part of them).
- *
+ *
* @param basePackageName
* string contains the module package name
* @param typeBuilder
/**
* Adds the methods to <code>typeBuilder</code> what represents subnodes of
* node for which <code>typeBuilder</code> was created.
- *
+ *
* @param basePackageName
* string contains the module package name
* @param typeBuilder
/**
* Adds to <code>typeBuilder</code> a method which is derived from
* <code>schemaNode</code>.
- *
+ *
* @param basePackageName
* string with the module package name
* @param schemaNode
/**
* Creates a getter method for a choice node.
- *
+ *
* Firstly generated type builder for choice is created or found in
* {@link BindingGeneratorImpl#allGroupings allGroupings}. The package name
* in the builder is created as concatenation of module package name and
* names of all parent nodes. In the end the getter method for choice is
* added to <code>typeBuilder</code> and return type is set to choice
* builder.
- *
+ *
* @param basePackageName
* string with the module package name
* @param typeBuilder
* <li>if <code>typeBuilder</code> equals null</li>
* <li>if <code>choiceNode</code> equals null</li>
* </ul>
- *
+ *
*/
private void resolveChoiceSchemaNode(final String basePackageName, final GeneratedTypeBuilder typeBuilder,
final ChoiceNode choiceNode) {
/**
* Converts <code>choiceNode</code> to the list of generated types for
* choice and its cases.
- *
+ *
* The package names for choice and for its cases are created as
* concatenation of the module package (<code>basePackageName</code>) and
* names of all parents node.
- *
+ *
* @param basePackageName
* string with the module package name
* @param choiceNode
* <li>if <code>basePackageName</code> equals null</li>
* <li>if <code>choiceNode</code> equals null</li>
* </ul>
- *
+ *
*/
private List<GeneratedType> choiceToGeneratedType(final String basePackageName, final ChoiceNode choiceNode) {
if (basePackageName == null) {
/**
* Converts <code>caseNodes</code> set to list of corresponding generated
* types.
- *
+ *
* For every <i>case</i> which isn't added through augment or <i>uses</i> is
* created generated type builder. The package names for the builder is
* created as concatenation of the module package (
* <code>basePackageName</code>) and names of all parents nodes of the
* concrete <i>case</i>. There is also relation "<i>implements type</i>"
* between every case builder and <i>choice</i> type
- *
+ *
* @param basePackageName
* string with the module package name
* @param refChoiceType
/**
* Generates list of generated types for all the cases of a choice which are
* added to the choice through the augment.
- *
- *
+ *
+ *
* @param basePackageName
* string contains name of package to which augment belongs. If
* an augmented choice is from an other package (pcg1) than an
/**
* Converts <code>leaf</code> to the getter method which is added to
* <code>typeBuilder</code>.
- *
+ *
* @param typeBuilder
* generated type builder to which is added getter method as
* <code>leaf</code> mapping
leafDesc = "";
}
+ final Module parentModule = findParentModule(schemaContext, leaf);
if (leafName != null && !leaf.isAddedByUses()) {
final TypeDefinition<?> typeDef = leaf.getType();
}
((TypeProviderImpl) typeProvider).putReferencedType(leaf.getPath(), returnType);
} else if (typeDef instanceof UnionType) {
- GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, leafName);
+ GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, leafName, parentModule);
if (genTOBuilder != null) {
returnType = new ReferencedTypeImpl(genTOBuilder.getPackageName(), genTOBuilder.getName());
}
} else if (typeDef instanceof BitsTypeDefinition) {
- GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, leafName);
+ GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, leafName, parentModule);
if (genTOBuilder != null) {
returnType = new ReferencedTypeImpl(genTOBuilder.getPackageName(), genTOBuilder.getName());
}
/**
* Converts <code>leaf</code> schema node to property of generated TO
* builder.
- *
+ *
* @param toBuilder
* generated TO builder to which is <code>leaf</code> added as
* property
/**
* Converts <code>node</code> leaf list schema node to getter method of
* <code>typeBuilder</code>.
- *
+ *
* @param typeBuilder
* generated type builder to which is <code>node</code> added as
* getter method
/**
* Creates a getter method for a container node.
- *
+ *
* Firstly generated type builder for container is created or found in
* {@link BindingGeneratorImpl#allGroupings allGroupings}. The package name
* in the builder is created as concatenation of module package name and
* names of all parent nodes. In the end the getter method for container is
* added to <code>typeBuilder</code> and return type is set to container
* type builder.
- *
+ *
* @param basePackageName
* string with the module package name
* @param typeBuilder
/**
* Creates a getter method for a list node.
- *
+ *
* Firstly generated type builder for list is created or found in
* {@link BindingGeneratorImpl#allGroupings allGroupings}. The package name
* in the builder is created as concatenation of module package name and
* names of all parent nodes. In the end the getter method for list is added
* to <code>typeBuilder</code> and return type is set to list type builder.
- *
+ *
* @param basePackageName
* string with the module package name
* @param typeBuilder
/**
* Instantiates generated type builder with <code>packageName</code> and
* <code>schemaNode</code>.
- *
+ *
* The new builder always implements
* {@link org.opendaylight.yangtools.yang.binding.DataObject DataObject}.<br />
* If <code>schemaNode</code> is instance of GroupingDefinition it also
* {@link org.opendaylight.yangtools.yang.model.api.DataNodeContainer
* DataNodeContainer} it can also implement nodes which are specified in
* <i>uses</i>.
- *
+ *
* @param packageName
* string with the name of the package to which
* <code>schemaNode</code> belongs.
/**
* Wraps the calling of the same overloaded method.
- *
+ *
* @param packageName
* string with the package name to which returning generated type
* builder belongs
/**
* Returns reference to generated type builder for specified
* <code>schemaNode</code> with <code>packageName</code>.
- *
+ *
* Firstly the generated type builder is searched in
* {@link BindingGeneratorImpl#genTypeBuilders genTypeBuilders}. If it isn't
* found it is created and added to <code>genTypeBuilders</code>.
- *
+ *
* @param packageName
* string with the package name to which returning generated type
* builder belongs
* <li>if Q name of schema node is null</li>
* <li>if schema node name is nul</li>
* </ul>
- *
+ *
*/
private GeneratedTypeBuilder addRawInterfaceDefinition(final String packageName, final SchemaNode schemaNode,
final String prefix) {
/**
* Creates the name of the getter method from <code>methodName</code>.
- *
+ *
* @param methodName
* string with the name of the getter method
* @return string with the name of the getter method for
/**
* Creates the name of the setter method from <code>methodName</code>.
- *
+ *
* @param methodName
* string with the name of the setter method
* @return string with the name of the setter method for
/**
* Created a method signature builder as part of
* <code>interfaceBuilder</code>.
- *
+ *
* The method signature builder is created for the getter method of
* <code>schemaNodeName</code>. Also <code>comment</code> and
* <code>returnType</code> information are added to the builder.
- *
+ *
* @param interfaceBuilder
* generated type builder for which the getter method should be
* created
/**
* Creates a method signature builder as a part of
* <code>interfaceBuilder</code> for <code>schemaNodeName</code>
- *
+ *
* The method signature builder is created for the setter method of
* <code>schemaNodeName</code>. Also <code>comment</code>
* <code>parameterType</code> data are added to the builder. The return type
* of the method is set to <code>void</code>.
- *
+ *
* @param interfaceBuilder
* generated type builder for which the setter method should be
* created
final List<String> listKeys = listKeys(list);
GeneratedTOBuilder genTOBuilder = resolveListKeyTOBuilder(packageName, list);
-
-
- if(genTOBuilder != null) {
- ParameterizedType identifierMarker = Types.parameterizedTypeFor( Types.typeForClass(Identifier.class), typeBuilder);
- ParameterizedType identifiableMarker = Types.parameterizedTypeFor(Types.typeForClass(Identifiable.class), genTOBuilder);
+
+ if (genTOBuilder != null) {
+ ParameterizedType identifierMarker = Types.parameterizedTypeFor(Types.typeForClass(Identifier.class),
+ typeBuilder);
+ ParameterizedType identifiableMarker = Types.parameterizedTypeFor(Types.typeForClass(Identifiable.class),
+ genTOBuilder);
genTOBuilder.addImplementsType(identifierMarker);
typeBuilder.addImplementsType(identifiableMarker);
}
/**
* Adds <code>schemaNode</code> to <code>typeBuilder</code> as getter method
* or to <code>genTOBuilder</code> as property.
- *
+ *
* @param basePackageName
* string contains the module package name
* @param schemaNode
/**
* Selects the names of the list keys from <code>list</code> and returns
* them as the list of the strings
- *
- * @param list of string with names of the list keys
+ *
+ * @param list
+ * of string with names of the list keys
* @return list of string which represents names of the list keys. If the
* <code>list</code> contains no keys then the empty list is
* returned.
return listKeys;
}
-
/**
* Generates for the <code>list</code> which contains any list keys special
* generated TO builder.
- *
+ *
* @param packageName
* string with package name to which the list belongs
* @param list
* {@link org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition
* BitsTypeDefinition} which are also added to <code>typeBuilder</code> as
* enclosing transfer object.
- *
+ *
* @param typeDef
- * type definition which can be of type <code>UnionType</code>
- * or <code>BitsTypeDefinition</code>
+ * type definition which can be of type <code>UnionType</code> or
+ * <code>BitsTypeDefinition</code>
* @param typeBuilder
* generated type builder to which is added generated TO created
* from <code>typeDef</code>
* @return generated TO builder for <code>typeDef</code>
*/
private GeneratedTOBuilder addTOToTypeBuilder(TypeDefinition<?> typeDef, GeneratedTypeBuilder typeBuilder,
- String leafName) {
+ String leafName, Module parentModule) {
final String classNameFromLeaf = parseToClassName(leafName);
GeneratedTOBuilder genTOBuilder = null;
final String packageName = typeBuilder.getFullyQualifiedName();
if (typeDef instanceof UnionTypeDefinition) {
- genTOBuilder = ((TypeProviderImpl) typeProvider).provideGeneratedTOBuilderForUnionTypeDefinition(packageName, typeDef,
- classNameFromLeaf);
+ genTOBuilder = ((TypeProviderImpl) typeProvider).provideGeneratedTOBuilderForUnionTypeDefinition(
+ packageName, typeDef, classNameFromLeaf, parentModule);
} else if (typeDef instanceof BitsTypeDefinition) {
- genTOBuilder = ((TypeProviderImpl) typeProvider).provideGeneratedTOBuilderForBitsTypeDefinition(packageName, typeDef,
- classNameFromLeaf);
+ genTOBuilder = ((TypeProviderImpl) typeProvider).provideGeneratedTOBuilderForBitsTypeDefinition(
+ packageName, typeDef, classNameFromLeaf);
}
if (genTOBuilder != null) {
typeBuilder.addEnclosingTransferObject(genTOBuilder);
/**
* Adds the implemented types to type builder.
- *
+ *
* The method passes through the list of <i>uses</i> in
* {@code dataNodeContainer}. For every <i>use</i> is obtained coresponding
* generated type from {@link BindingGeneratorImpl#allGroupings
* allGroupings} which is adde as <i>implements type</i> to
* <code>builder</code>
- *
+ *
* @param dataNodeContainer
* element which contains the list of used YANG groupings
* @param builder
import java.util.TreeMap;
import org.apache.commons.lang.StringEscapeUtils;
-import org.opendaylight.yangtools.binding.generator.util.ReferencedTypeImpl;
import org.opendaylight.yangtools.binding.generator.util.TypeConstants;
import org.opendaylight.yangtools.binding.generator.util.Types;
import org.opendaylight.yangtools.binding.generator.util.generated.type.builder.EnumerationBuilderImpl;
/**
* The outter map maps module names to the map of the types for the module.
- * The inner map maps the name of the concrete type to the JAVA <code>Type</code> (usually it is generated TO).
+ * The inner map maps the name of the concrete type to the JAVA
+ * <code>Type</code> (usually it is generated TO).
*/
private Map<String, Map<String, Type>> genTypeDefsContextMap;
/**
* Creates new instance of class <code>TypeProviderImpl</code>.
- *
+ *
* @param schemaContext
* contains the schema data red from YANG files
* @throws IllegalArgumentException
/**
* Puts <code>refType</code> to map with key <code>refTypePath</code>
- *
+ *
* @param refTypePath
* schema path used as the map key
* @param refType
* <li>if <code>refTypePath</code> equal null</li>
* <li>if <code>refType</code> equal null</li>
* </ul>
- *
+ *
*/
public void putReferencedType(final SchemaPath refTypePath, final Type refType) {
if (refTypePath == null) {
}
/**
- *
+ *
* Converts basic YANG type <code>type</code> to JAVA <code>Type</code>.
- *
+ *
* @param type
* string with YANG name of type
* @returns JAVA <code>Type</code> for YANG type <code>type</code>
/**
* Converts schema definition type <code>typeDefinition</code> to JAVA
* <code>Type</code>
- *
+ *
* @param typeDefinition
* type definition which is converted to JAVA type
* @throws IllegalArgumentException
* Seeks for identity reference <code>idref</code> the JAVA
* <code>type</code>.<br />
* <br />
- *
+ *
* <i>Example:<br />
* If identy which is referenced via <code>idref</code> has name <b>Idn</b>
* then returning type is <b>{@code Class<? extends Idn>}</b></i>
- *
+ *
* @param idref
* identityref type definition for which JAVA <code>Type</code>
* is sought
/**
* Converts <code>typeDefinition</code> to concrete JAVA <code>Type</code>.
- *
+ *
* @param typeDefinition
* type definition which should be converted to JAVA
* <code>Type</code>
/**
* Gets base type definition for <code>extendTypeDef</code>. The method is
* recursivelly called until non <code>ExtendedType</code> type is found.
- *
+ *
* @param extendTypeDef
* type definition for which is the base type definition sought
* @return type definition which is base type for <code>extendTypeDef</code>
/**
* Converts <code>leafrefType</code> to JAVA <code>Type</code>.
- *
+ *
* The path of <code>leafrefType</code> is followed to find referenced node
* and its <code>Type</code> is returned.
- *
+ *
* @param leafrefType
* leafref type definition for which is the type sought
* @return JAVA <code>Type</code> of data schema node which is referenced in
* <li>if <code>leafrefType</code> equal null</li>
* <li>if path statement of <code>leafrefType</code> equal null</li>
* </ul>
- *
+ *
*/
public Type provideTypeForLeafref(final LeafrefTypeDefinition leafrefType) {
Type returnType = null;
/**
* Checks if <code>dataNode</code> is <code>LeafSchemaNode</code> and if it
* so then checks if it is of type <code>EnumTypeDefinition</code>.
- *
+ *
* @param dataNode
* data schema node for which is checked if it is leaf and if it
* is of enum type
/**
* Checks if <code>dataNode</code> is <code>LeafListSchemaNode</code> and if
* it so then checks if it is of type <code>EnumTypeDefinition</code>.
- *
+ *
* @param dataNode
* data schema node for which is checked if it is leaflist and if
* it is of enum type
* Converts <code>enumTypeDef</code> to
* {@link org.opendaylight.yangtools.sal.binding.model.api.Enumeration
* enumeration}.
- *
+ *
* @param enumTypeDef
* enumeration type definition which is converted to enumeration
* @param enumName
/**
* Adds enumeration to <code>typeBuilder</code>. The enumeration data are
* taken from <code>enumTypeDef</code>.
- *
+ *
* @param enumTypeDef
* enumeration type definition is source of enumeration data for
* <code>typeBuilder</code>
* <li>if name of <code>enumTypeDef</code> equal null</li>
* <li>if name of <code>typeBuilder</code> equal null</li>
* </ul>
- *
+ *
*/
private Enumeration addInnerEnumerationToTypeBuilder(final EnumTypeDefinition enumTypeDef, final String enumName,
final GeneratedTypeBuilder typeBuilder) {
/**
* Updates <code>enumBuilder</code> with data from <code>enumTypeDef</code>.
* Specifically this data represents list of value-name pairs.
- *
+ *
* @param enumTypeDef
* enum type definition as source of enum data for
* <code>enumBuilder</code>
/**
* Converts <code>dataNode</code> to JAVA <code>Type</code>.
- *
+ *
* @param dataNode
* contains information about YANG type
* @return JAVA <code>Type</code> representation of <code>dataNode</code>
/**
* Passes through all modules and through all its type definitions and
* convert it to generated types.
- *
+ *
* The modules are firstly sorted by mutual dependencies. The modules are
* sequentially passed. All type definitions of a module are at the
* beginning sorted so that type definition with less amount of references
* {@link TypeProviderImpl#genTypeDefsContextMap genTypeDefsContextMap}
* which map current module name to the map which maps type names to
* returned types (generated types).
- *
+ *
*/
private void resolveTypeDefsFromContext() {
final Set<Module> modules = schemaContext.getModules();
}
/**
- *
+ *
* @param basePackageName
* string with name of package to which the module belongs
* @param moduleName
ExtendedType innerExtendedType = (ExtendedType) innerTypeDefinition;
returnType = provideGeneratedTOFromExtendedType(innerExtendedType, basePackageName, typedefName);
} else if (innerTypeDefinition instanceof UnionTypeDefinition) {
+ final Module parentModule = findParentModuleForTypeDefinition(schemaContext, typedef);
final GeneratedTOBuilder genTOBuilder = provideGeneratedTOBuilderForUnionTypeDefinition(
- basePackageName, typedef, typedefName);
+ basePackageName, typedef, typedefName, parentModule);
returnType = genTOBuilder.toInstance();
} else if (innerTypeDefinition instanceof EnumTypeDefinition) {
final EnumTypeDefinition enumTypeDef = (EnumTypeDefinition) innerTypeDefinition;
/**
* Wraps base YANG type to generated TO.
- *
+ *
* @param basePackageName
* string with name of package to which the module belongs
* @param typedef
* Converts <code>typedef</code> to generated TO with
* <code>typeDefName</code>. Every union type from <code>typedef</code> is
* added to generated TO builder as property.
- *
+ *
* @param basePackageName
* string with name of package to which the module belongs
* @param typedef
* </ul>
*/
public GeneratedTOBuilder provideGeneratedTOBuilderForUnionTypeDefinition(final String basePackageName,
- final TypeDefinition<?> typedef, String typeDefName) {
+ final TypeDefinition<?> typedef, final String typeDefName, final Module parentModule) {
if (basePackageName == null) {
throw new IllegalArgumentException("Base Package Name cannot be NULL!");
}
}
Map<String, Type> genTOsMap = null;
- final Module parentModule = findParentModuleForTypeDefinition(schemaContext, typedef);
+ // final Module parentModule =
+ // findParentModuleForTypeDefinition(schemaContext, typedef);
if (parentModule != null && parentModule.getName() != null) {
genTOsMap = genTypeDefsContextMap.get(parentModule.getName());
genTOsMap.put(typedef.getQName().getLocalName(), unionGenTransObject.toInstance());
/**
* Adds a new property with the name <code>propertyName</code> and with type
* <code>type</code> to <code>unonGenTransObject</code>.
- *
+ *
* @param unionGenTransObject
* generated TO to which should be property added
* @param type
/**
* Converts <code>typedef</code> to the generated TO builder.
- *
+ *
* @param basePackageName
* string with name of package to which the module belongs
* @param typedef
/**
* Converts <code>typeDef</code> which should be of the type
* <code>BitsTypeDefinition</code> to <code>GeneratedTOBuilder</code>.
- *
+ *
* All the bits of the typeDef are added to returning generated TO as
* properties.
- *
+ *
* @param basePackageName
* string with name of package to which the module belongs
* @param typeDef
/**
* Converts the pattern constraints from <code>typedef</code> to the list of
* the strings which represents these constraints.
- *
+ *
* @param typedef
* extended type in which are the pattern constraints sought
* @return list of strings which represents the constraint patterns
* @throws IllegalArgumentException
* if <code>typedef</code> equals null
- *
+ *
*/
private List<String> resolveRegExpressionsFromTypedef(ExtendedType typedef) {
final List<String> regExps = new ArrayList<String>();
}
/**
- *
+ *
* Adds to the <code>genTOBuilder</code> the constant which contains regular
* expressions from the <code>regularExpressions</code>
- *
+ *
* @param genTOBuilder
* generated TO builder to which are
* <code>regular expressions</code> added
* <code>innerExtendedType</code>, about the package name
* <code>typedefName</code> and about the generated TO name
* <code>typedefName</code>.
- *
+ *
* It is supposed that <code>innerExtendedType</code> is already present in
* {@link TypeProviderImpl#genTypeDefsContextMap genTypeDefsContextMap} to
* be possible set it as extended type for the returning generated TO.
- *
+ *
* @param innerExtendedType
* extended type which is part of some other extended type
* @param basePackageName
* equal depth. In next step are lists from this map concatenated to one
* list in ascending order according to their depth. All type definitions
* are in the list behind all type definitions on which depends.
- *
+ *
* @param unsortedTypeDefinitions
* list of type definitions which should be sorted by depth
* @return list of type definitions sorted according their each other
/**
* Returns how many immersion is necessary to get from the type definition
* to the base type.
- *
+ *
* @param typeDefinition
* type definition for which is depth sought.
* @return number of immersions which are necessary to get from the type