*/
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
Code Review / yangtools.git / blobdiff