Updated types resolving in parser. Removed unused methods. Updated tests.
Signed-off-by: Martin Vitez <mvitez@cisco.com>
*/
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
* @param maxRange
* @param units
*/
- public AbstractSignedInteger(final SchemaPath path, final QName name,
- final String description, final Number minRange,
+ public AbstractSignedInteger(final QName name, final String description, final Number minRange,
final Number maxRange, final String units) {
this.name = name;
+ this.path = new SchemaPath(Collections.singletonList(name), true);
this.description = description;
- this.path = path;
this.units = units;
this.rangeStatements = new ArrayList<RangeConstraint>();
- final String rangeDescription = "Integer values between " + minRange
- + " and " + maxRange + ", inclusively.";
- this.rangeStatements.add(BaseConstraints.rangeConstraint(minRange,
- maxRange, rangeDescription,
+ final String rangeDescription = "Integer values between " + minRange + " and " + maxRange + ", inclusively.";
+ this.rangeStatements.add(BaseConstraints.rangeConstraint(minRange, maxRange, rangeDescription,
"https://tools.ietf.org/html/rfc6020#section-9.2.4"));
}
- /**
- * @param name
- * @param description
- * @param rangeStatements
- * @param units
- */
- public AbstractSignedInteger(final SchemaPath path, final QName name,
- final String description,
- final List<RangeConstraint> rangeStatements, final String units) {
- this.name = name;
- this.description = description;
- this.path = path;
- this.units = units;
- this.rangeStatements = rangeStatements;
- }
-
@Override
public String getUnits() {
return units;
public int hashCode() {
final int prime = 31;
int result = 1;
- result = prime * result
- + ((description == null) ? 0 : description.hashCode());
+ result = prime * result + ((description == null) ? 0 : description.hashCode());
result = prime * result + ((name == null) ? 0 : name.hashCode());
result = prime * result + ((path == null) ? 0 : path.hashCode());
- result = prime * result
- + ((rangeStatements == null) ? 0 : rangeStatements.hashCode());
- result = prime * result
- + ((reference == null) ? 0 : reference.hashCode());
+ result = prime * result + ((rangeStatements == null) ? 0 : rangeStatements.hashCode());
+ result = prime * result + ((reference == null) ? 0 : reference.hashCode());
result = prime * result + ((units == null) ? 0 : units.hashCode());
return result;
}
/**
*
- * @param path uint type schema path
- * @param name qname
+ * @param name
* @param description
* @param maxRange
* @param units
*/
- public AbstractUnsignedInteger(final SchemaPath path, final QName name, final String description,
- final Number maxRange, final String units) {
+ public AbstractUnsignedInteger(final QName name, final String description, final Number maxRange, final String units) {
this.name = name;
+ this.path = new SchemaPath(Collections.singletonList(name), true);
this.description = description;
- this.path = path;
this.units = units;
this.rangeStatements = new ArrayList<RangeConstraint>();
final String rangeDescription = "Integer values between " + MIN_VALUE + " and " + maxRange + ", inclusively.";
"https://tools.ietf.org/html/rfc6020#section-9.2.4"));
}
- /**
- *
- * @param path uint type schema path
- * @param name qname
- * @param description
- * @param rangeStatements
- * @param units
- */
- public AbstractUnsignedInteger(final SchemaPath path, final QName name, final String description,
- final List<RangeConstraint> rangeStatements, final String units) {
- this.name = name;
- this.description = description;
- this.path = path;
- this.units = units;
- this.rangeStatements = rangeStatements;
- }
-
@Override
public String getUnits() {
return units;
\r
import java.net.URI;\r
import java.util.ArrayList;\r
+import java.util.Collections;\r
import java.util.Date;\r
import java.util.List;\r
\r
/**\r
* Construct QName for Built-in base Yang type. The namespace for\r
* built-in base yang types is defined as: urn:ietf:params:xml:ns:yang:1\r
- * \r
+ *\r
* @param typeName yang type name\r
* @return built-in base yang type QName.\r
*/\r
\r
/**\r
* Creates Schema Path from Qname.\r
- * \r
+ *\r
* @param typeName yang type QName\r
* @return Schema Path from Qname.\r
*/\r
public static final SchemaPath schemaPath(final QName typeName) {\r
- final List<QName> pathList = new ArrayList<QName>();\r
- pathList.add(typeName);\r
+ List<QName> pathList = Collections.singletonList(typeName);\r
return new SchemaPath(pathList, true);\r
}\r
- \r
+\r
/**\r
* Creates Schema Path from List of partial paths defined as Strings, module Namespace and\r
* module latest Revision Date.\r
- * \r
+ *\r
* @param actualPath List of partial paths\r
* @param namespace Module Namespace\r
* @param revision Revision Date\r
* @see BinaryTypeDefinition
*/
public final class BinaryType implements BinaryTypeDefinition {
+ private static final BinaryType INSTANCE = new BinaryType();
private final QName name = BaseTypes.constructQName("binary");
- private final SchemaPath path;
+ private final SchemaPath path = new SchemaPath(Collections.singletonList(name), true);
private final String description = "The binary built-in type represents any binary data, i.e., a sequence of octets.";
private final String reference = "https://tools.ietf.org/html/rfc6020#section-9.8";
- private final BinaryTypeDefinition baseType;
private final List<Byte> bytes;
private final List<LengthConstraint> lengthConstraints;
private final String units = "";
- public BinaryType(final SchemaPath path) {
+ private BinaryType() {
final List<LengthConstraint> constraints = new ArrayList<LengthConstraint>();
- constraints.add(BaseConstraints.lengthConstraint(0, Long.MAX_VALUE, "",
- ""));
+ constraints.add(BaseConstraints.lengthConstraint(0, Long.MAX_VALUE, "", ""));
this.lengthConstraints = Collections.unmodifiableList(constraints);
this.bytes = Collections.emptyList();
- this.path = path;
- this.baseType = this;
}
- public BinaryType(final SchemaPath path, final List<Byte> bytes) {
- final List<LengthConstraint> constraints = new ArrayList<LengthConstraint>();
- constraints.add(BaseConstraints.lengthConstraint(0, Long.MAX_VALUE, "",
- ""));
- this.lengthConstraints = Collections.unmodifiableList(constraints);
- this.bytes = Collections.unmodifiableList(bytes);
- this.path = path;
- this.baseType = this;
+ public static BinaryType getInstance() {
+ return INSTANCE;
}
/*
*/
@Override
public BinaryTypeDefinition getBaseType() {
- return baseType;
+ return this;
}
/*
final int prime = 31;
int result = 1;
result = prime * result + ((bytes == null) ? 0 : bytes.hashCode());
- result = prime * result
- + ((description == null) ? 0 : description.hashCode());
- result = prime
- * result
- + ((lengthConstraints == null) ? 0 : lengthConstraints
- .hashCode());
+ result = prime * result + ((description == null) ? 0 : description.hashCode());
+ result = prime * result + ((lengthConstraints == null) ? 0 : lengthConstraints.hashCode());
result = prime * result + ((name == null) ? 0 : name.hashCode());
result = prime * result + ((path == null) ? 0 : path.hashCode());
- result = prime * result
- + ((reference == null) ? 0 : reference.hashCode());
+ result = prime * result + ((reference == null) ? 0 : reference.hashCode());
result = prime * result + ((units == null) ? 0 : units.hashCode());
return result;
}
* @see BooleanTypeDefinition
*/
public final class BooleanType implements BooleanTypeDefinition {
- private final QName name = BaseTypes.constructQName("boolean");
- private final SchemaPath path;
- private final String description = "The boolean built-in type represents a boolean value.";
- private final String reference = "https://tools.ietf.org/html/rfc6020#section-9.5";
- private final BooleanTypeDefinition baseType;
- private final Boolean defaultValue;
+ private static final BooleanType INSTANCE = new BooleanType();
+ private static final QName name = BaseTypes.constructQName("boolean");
+ private static final SchemaPath path = new SchemaPath(Collections.singletonList(name), true);
+ private static final String description = "The boolean built-in type represents a boolean value.";
+ private static final String reference = "https://tools.ietf.org/html/rfc6020#section-9.5";
private final String units = "";
/**
* Default constructor with default value set to "false".
*/
- public BooleanType(final SchemaPath path) {
- super();
- this.defaultValue = false;
- this.path = path;
- this.baseType = this;
+ private BooleanType() {
}
- /**
- * Boolean Type constructor.
- *
- * @param defaultValue
- * Default Value
- */
- public BooleanType(final SchemaPath path, final Boolean defaultValue) {
- super();
- this.defaultValue = defaultValue;
- this.path = path;
- this.baseType = this;
+ public static BooleanType getInstance() {
+ return INSTANCE;
}
/*
*/
@Override
public BooleanTypeDefinition getBaseType() {
- return baseType;
+ return this;
}
/*
*/
@Override
public Object getDefaultValue() {
- return defaultValue;
+ return false;
}
/*
return Collections.emptyList();
}
- @Override
- public int hashCode() {
- final int prime = 31;
- int result = 1;
- result = prime * result
- + ((defaultValue == null) ? 0 : defaultValue.hashCode());
- result = prime * result
- + ((description == null) ? 0 : description.hashCode());
- result = prime * result + ((name == null) ? 0 : name.hashCode());
- result = prime * result + ((path == null) ? 0 : path.hashCode());
- result = prime * result
- + ((reference == null) ? 0 : reference.hashCode());
- result = prime * result + ((units == null) ? 0 : units.hashCode());
- return result;
- }
-
- @Override
- public boolean equals(Object obj) {
- if (this == obj) {
- return true;
- }
- if (obj == null) {
- return false;
- }
- if (getClass() != obj.getClass()) {
- return false;
- }
- BooleanType other = (BooleanType) obj;
- if (defaultValue == null) {
- if (other.defaultValue != null) {
- return false;
- }
- } else if (!defaultValue.equals(other.defaultValue)) {
- return false;
- }
- if (description == null) {
- if (other.description != null) {
- return false;
- }
- } else if (!description.equals(other.description)) {
- return false;
- }
- if (name == null) {
- if (other.name != null) {
- return false;
- }
- } else if (!name.equals(other.name)) {
- return false;
- }
- if (path == null) {
- if (other.path != null) {
- return false;
- }
- } else if (!path.equals(other.path)) {
- return false;
- }
- if (reference == null) {
- if (other.reference != null) {
- return false;
- }
- } else if (!reference.equals(other.reference)) {
- return false;
- }
- if (units == null) {
- if (other.units != null) {
- return false;
- }
- } else if (!units.equals(other.units)) {
- return false;
- }
- return true;
- }
-
@Override
public String toString() {
StringBuilder builder = new StringBuilder();
builder.append(name);
builder.append(", path=");
builder.append(path);
- builder.append(", description=");
- builder.append(description);
- builder.append(", reference=");
- builder.append(reference);
- builder.append(", defaultValue=");
- builder.append(defaultValue);
- builder.append(", units=");
- builder.append(units);
builder.append("]");
return builder.toString();
}
import org.opendaylight.yangtools.yang.model.api.type.EmptyTypeDefinition;
public final class EmptyType implements EmptyTypeDefinition {
- private final QName name = BaseTypes.constructQName("empty");
- private final SchemaPath path;
- private final String description = "The empty built-in type represents a leaf that does not have any value, it conveys information by its presence or absence.";
- private final String reference = "https://tools.ietf.org/html/rfc6020#page-131";
- private final EmptyTypeDefinition baseType;
-
- public EmptyType(final SchemaPath path) {
- this.path = path;
- this.baseType = this;
+ private static EmptyType INSTANCE;
+ private static final QName NAME = BaseTypes.constructQName("empty");
+ private static final SchemaPath path = new SchemaPath(Collections.singletonList(NAME), true);
+ private static final String description = "The empty built-in type represents a leaf that does not have any value, it conveys information by its presence or absence.";
+ private static final String reference = "https://tools.ietf.org/html/rfc6020#page-131";
+
+ private EmptyType() {
+ }
+
+ public static EmptyType getInstance() {
+ if (INSTANCE == null) {
+ INSTANCE = new EmptyType();
+ }
+ return INSTANCE;
}
@Override
public EmptyTypeDefinition getBaseType() {
- return baseType;
+ return this;
}
@Override
@Override
public QName getQName() {
- return name;
+ return NAME;
}
@Override
return Collections.emptyList();
}
+ @Override
+ public String toString() {
+ return "type empty " + NAME;
+ }
+
}
*/
public final class InstanceIdentifier implements InstanceIdentifierTypeDefinition {
private static final QName name = BaseTypes.constructQName("instance-identifier");
+ private static final SchemaPath path = new SchemaPath(Collections.singletonList(name), true);
private static final String description = "The instance-identifier built-in type is used to "
+ "uniquely identify a particular instance node in the data tree.";
private static final String reference = "https://tools.ietf.org/html/rfc6020#section-9.13";
- private final transient SchemaPath path;
private final RevisionAwareXPath xpath;
- private final String units = "";
- private final InstanceIdentifierTypeDefinition baseType;
+ private static final String units = "";
private boolean requireInstance = true;
- public InstanceIdentifier(final SchemaPath path, final RevisionAwareXPath xpath) {
- super();
- this.path = path;
+ public InstanceIdentifier(final RevisionAwareXPath xpath) {
this.xpath = xpath;
- this.baseType = this;
}
- public InstanceIdentifier(final SchemaPath path, final RevisionAwareXPath xpath, final boolean requireInstance) {
- super();
- this.path = path;
+ public InstanceIdentifier(final RevisionAwareXPath xpath, final boolean requireInstance) {
this.xpath = xpath;
this.requireInstance = requireInstance;
- this.baseType = this;
}
/*
*/
@Override
public InstanceIdentifierTypeDefinition getBaseType() {
- return baseType;
+ return this;
}
/*
return requireInstance;
}
+ @Override
+ public int hashCode() {
+ final int prime = 31;
+ int result = 1;
+ result = prime * result + (requireInstance ? 1231 : 1237);
+ result = prime * result + ((xpath == null) ? 0 : xpath.hashCode());
+ return result;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj)
+ return true;
+ if (obj == null)
+ return false;
+ if (getClass() != obj.getClass())
+ return false;
+ InstanceIdentifier other = (InstanceIdentifier) obj;
+ if (requireInstance != other.requireInstance)
+ return false;
+ if (xpath == null) {
+ if (other.xpath != null)
+ return false;
+ } else if (!xpath.equals(other.xpath))
+ return false;
+ return true;
+ }
+
}
package org.opendaylight.yangtools.yang.model.util;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.type.IntegerTypeDefinition;
/**
* @see AbstractSignedInteger
*/
public final class Int16 extends AbstractSignedInteger {
- private static final QName name = BaseTypes.constructQName("int16");
- private final Short defaultValue = null;
- private static final String description = "int16 represents integer values between -32768 and 32767, inclusively.";
- private final IntegerTypeDefinition baseType;
+ private static Int16 INSTANCE;
+ private static final QName NAME = BaseTypes.constructQName("int16");
+ private static final String DESCRIPTION = "int16 represents integer values between -32768 and 32767, inclusively.";
- public Int16(final SchemaPath path) {
- super(path, name, description, Short.MIN_VALUE, Short.MAX_VALUE, "");
- this.baseType = this;
+ private Int16() {
+ super(NAME, DESCRIPTION, Short.MIN_VALUE, Short.MAX_VALUE, "");
+ }
+ public static Int16 getInstance() {
+ if (INSTANCE == null) {
+ INSTANCE = new Int16();
+ }
+ return INSTANCE;
}
@Override
public IntegerTypeDefinition getBaseType() {
- return baseType;
+ return this;
}
@Override
public Object getDefaultValue() {
- return defaultValue;
- }
-
- @Override
- public int hashCode() {
- final int prime = 31;
- int result = super.hashCode();
- result = prime * result
- + ((defaultValue == null) ? 0 : defaultValue.hashCode());
- return result;
- }
-
- @Override
- public boolean equals(Object obj) {
- if (this == obj) {
- return true;
- }
- if (!super.equals(obj)) {
- return false;
- }
- if (getClass() != obj.getClass()) {
- return false;
- }
- Int16 other = (Int16) obj;
- if (defaultValue == null) {
- if (other.defaultValue != null) {
- return false;
- }
- } else if (!defaultValue.equals(other.defaultValue)) {
- return false;
- }
- return true;
+ return null;
}
@Override
public String toString() {
- StringBuilder builder = new StringBuilder();
- builder.append("Int16 [defaultValue=");
- builder.append(defaultValue);
- builder.append(", AbstractInteger=");
- builder.append(super.toString());
- builder.append("]");
- return builder.toString();
+ return "type " + NAME;
}
+
}
package org.opendaylight.yangtools.yang.model.util;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.type.IntegerTypeDefinition;
/**
*
*/
public final class Int32 extends AbstractSignedInteger {
- private static final QName name = BaseTypes.constructQName("int32");
- private final Integer defaultValue = null;
- private static final String description = "int32 represents integer values between -2147483648 and 2147483647, inclusively.";
- private final IntegerTypeDefinition baseType;
+ private static Int32 INSTANCE;
+ private static final QName NAME = BaseTypes.constructQName("int32");
+ private static final String DESCRIPTION = "int32 represents integer values between -2147483648 and 2147483647, inclusively.";
- public Int32(final SchemaPath path) {
- super(path, name, description, Integer.MIN_VALUE, Integer.MAX_VALUE, "");
- this.baseType = this;
+ private Int32() {
+ super(Int32.NAME, Int32.DESCRIPTION, Integer.MIN_VALUE, Integer.MAX_VALUE, "");
}
- /*
- * (non-Javadoc)
- *
- * @see
- * org.opendaylight.yangtools.yang.model.api.TypeDefinition#getBaseType()
- */
- @Override
- public IntegerTypeDefinition getBaseType() {
- return baseType;
- }
-
- /*
- * (non-Javadoc)
- *
- * @see
- * org.opendaylight.yangtools.yang.model.api.TypeDefinition#getDefaultValue
- * ()
- */
- @Override
- public Object getDefaultValue() {
- return defaultValue;
+ public static Int32 getInstance() {
+ if (INSTANCE == null) {
+ INSTANCE = new Int32();
+ }
+ return INSTANCE;
}
@Override
- public int hashCode() {
- final int prime = 31;
- int result = super.hashCode();
- result = prime * result
- + ((defaultValue == null) ? 0 : defaultValue.hashCode());
- return result;
+ public IntegerTypeDefinition getBaseType() {
+ return this;
}
@Override
- public boolean equals(Object obj) {
- if (this == obj) {
- return true;
- }
- if (!super.equals(obj)) {
- return false;
- }
- if (getClass() != obj.getClass()) {
- return false;
- }
- Int32 other = (Int32) obj;
- if (defaultValue == null) {
- if (other.defaultValue != null) {
- return false;
- }
- } else if (!defaultValue.equals(other.defaultValue)) {
- return false;
- }
- return true;
+ public Object getDefaultValue() {
+ return null;
}
@Override
public String toString() {
- StringBuilder builder = new StringBuilder();
- builder.append("Int32 [defaultValue=");
- builder.append(defaultValue);
- builder.append(", AbstractInteger=");
- builder.append(super.toString());
- builder.append("]");
- return builder.toString();
+ return "type " + NAME;
}
}
/*
- * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
package org.opendaylight.yangtools.yang.model.util;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.type.IntegerTypeDefinition;
/**
* Implementation of Yang int64 built-in type. <br>
- * int64 represents integer values between -9223372036854775808 and 9223372036854775807, inclusively.
- * The Java counterpart of Yang int64 built-in type is
- * {@link Long}.
+ * int64 represents integer values between -9223372036854775808 and
+ * 9223372036854775807, inclusively. The Java counterpart of Yang int64 built-in
+ * type is {@link Long}.
*
*/
public final class Int64 extends AbstractSignedInteger {
- private static final QName name = BaseTypes.constructQName("int64");
- private final Long defaultValue = null;
- private static final String description =
- "int64 represents integer values between -9223372036854775808 and 9223372036854775807, inclusively.";
- private final IntegerTypeDefinition baseType;
-
- public Int64(final SchemaPath path) {
- super(path, name, description, Integer.MIN_VALUE, Integer.MAX_VALUE, "");
- this.baseType = this;
- }
+ private static Int64 INSTANCE;
+ private static final QName NAME = BaseTypes.constructQName("int64");
+ private static final String DESCRIPTION = "int64 represents integer values between -9223372036854775808 and 9223372036854775807, inclusively.";
- /*
- * (non-Javadoc)
- *
- * @see org.opendaylight.yangtools.yang.model.api.TypeDefinition#getBaseType()
- */
- @Override
- public IntegerTypeDefinition getBaseType() {
- return baseType;
+ private Int64() {
+ super(NAME, DESCRIPTION, Integer.MIN_VALUE, Integer.MAX_VALUE, "");
}
- /*
- * (non-Javadoc)
- *
- * @see org.opendaylight.yangtools.yang.model.api.TypeDefinition#getDefaultValue()
- */
- @Override
- public Object getDefaultValue() {
- return defaultValue;
+ public static Int64 getInstance() {
+ if (INSTANCE == null) {
+ INSTANCE = new Int64();
+ }
+ return INSTANCE;
}
@Override
- public int hashCode() {
- final int prime = 31;
- int result = super.hashCode();
- result = prime * result
- + ((defaultValue == null) ? 0 : defaultValue.hashCode());
- return result;
+ public IntegerTypeDefinition getBaseType() {
+ return this;
}
@Override
- public boolean equals(Object obj) {
- if (this == obj) {
- return true;
- }
- if (!super.equals(obj)) {
- return false;
- }
- if (getClass() != obj.getClass()) {
- return false;
- }
- Int64 other = (Int64) obj;
- if (defaultValue == null) {
- if (other.defaultValue != null) {
- return false;
- }
- } else if (!defaultValue.equals(other.defaultValue)) {
- return false;
- }
- return true;
+ public Object getDefaultValue() {
+ return null;
}
@Override
public String toString() {
- StringBuilder builder = new StringBuilder();
- builder.append("Int64 [defaultValue=");
- builder.append(defaultValue);
- builder.append(", AbstractInteger=");
- builder.append(super.toString());
- builder.append("]");
- return builder.toString();
+ return "type " + NAME;
}
+
}
package org.opendaylight.yangtools.yang.model.util;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.type.IntegerTypeDefinition;
/**
* @see AbstractSignedInteger
*/
public final class Int8 extends AbstractSignedInteger {
- private static final QName name = BaseTypes.constructQName("int8");
- private final Byte defaultValue = null;
- private static final String description = "represents integer values between -128 and 127, inclusively.";
- private final IntegerTypeDefinition baseType;
+ private static Int8 INSTANCE;
+ private static final QName NAME = BaseTypes.constructQName("int8");
+ private static final String DESCRIPTION = "represents integer values between -128 and 127, inclusively.";
- public Int8(final SchemaPath path) {
- super(path, name, description, Byte.MIN_VALUE, Byte.MAX_VALUE, "");
- this.baseType = this;
+ private Int8() {
+ super(NAME, DESCRIPTION, Byte.MIN_VALUE, Byte.MAX_VALUE, "");
}
- /*
- * (non-Javadoc)
- *
- * @see
- * org.opendaylight.yangtools.yang.model.api.TypeDefinition#getBaseType()
- */
- @Override
- public IntegerTypeDefinition getBaseType() {
- return baseType;
- }
-
- /*
- * (non-Javadoc)
- *
- * @see
- * org.opendaylight.yangtools.yang.model.api.TypeDefinition#getDefaultValue
- * ()
- */
- @Override
- public Object getDefaultValue() {
- return defaultValue;
+ public static Int8 getInstance() {
+ if (INSTANCE == null) {
+ INSTANCE = new Int8();
+ }
+ return INSTANCE;
}
@Override
- public int hashCode() {
- final int prime = 31;
- int result = super.hashCode();
- result = prime * result
- + ((defaultValue == null) ? 0 : defaultValue.hashCode());
- return result;
+ public IntegerTypeDefinition getBaseType() {
+ return this;
}
@Override
- public boolean equals(Object obj) {
- if (this == obj) {
- return true;
- }
- if (!super.equals(obj)) {
- return false;
- }
- if (getClass() != obj.getClass()) {
- return false;
- }
- Int8 other = (Int8) obj;
- if (defaultValue == null) {
- if (other.defaultValue != null) {
- return false;
- }
- } else if (!defaultValue.equals(other.defaultValue)) {
- return false;
- }
- return true;
+ public Object getDefaultValue() {
+ return null;
}
@Override
public String toString() {
- StringBuilder builder = new StringBuilder();
- builder.append("Int8 [defaultValue=");
- builder.append(defaultValue);
- builder.append(", AbstractInteger=");
- builder.append(super.toString());
- builder.append("]");
- return builder.toString();
+ return "type " + NAME;
}
+
}
* @see StringTypeDefinition
*/
public final class StringType implements StringTypeDefinition {
+ private static final StringType INSTANCE = new StringType();
private final QName name = BaseTypes.constructQName("string");
- private final SchemaPath path;
+ private final SchemaPath path = new SchemaPath(Collections.singletonList(name), true);
private final String defaultValue = "";
private final String description = "";
private final String reference = "";
private final List<LengthConstraint> lengthStatements;
private final List<PatternConstraint> patterns;
private final String units = "";
- private final StringTypeDefinition baseType;
/**
* Default Constructor.
*/
- public StringType(final SchemaPath path) {
- super();
- this.path = path;
+ private StringType() {
final List<LengthConstraint> constraints = new ArrayList<LengthConstraint>();
constraints.add(BaseConstraints.lengthConstraint(0, Long.MAX_VALUE, "", ""));
lengthStatements = Collections.unmodifiableList(constraints);
patterns = Collections.emptyList();
- baseType = this;
+ }
+
+ public static StringType getIntance() {
+ return INSTANCE;
}
/*
*/
@Override
public StringTypeDefinition getBaseType() {
- return baseType;
+ return this;
}
/*
package org.opendaylight.yangtools.yang.model.util;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.type.UnsignedIntegerTypeDefinition;
/**
- * Implementation of Yang uint32 built-in type. <br>
+ * Implementation of Yang uint16 built-in type. <br>
* uint16 represents integer values between 0 and 65535, inclusively. The Java
- * counterpart of Yang uint32 built-in type is {@link Integer}.
+ * counterpart of Yang uint16 built-in type is {@link Integer}.
*
*/
public final class Uint16 extends AbstractUnsignedInteger {
public static final int MAX_VALUE = 65535;
- private static final QName name = BaseTypes.constructQName("uint16");
- private Integer defaultValue = null;
- private static final String description = "uint16 represents integer values between 0 and 65535, inclusively.";
- private final UnsignedIntegerTypeDefinition baseType;
+ private static Uint16 INSTANCE;
+ private static final QName NAME = BaseTypes.constructQName("uint16");
+ private static final String DESCRIPTION = "uint16 represents integer values between 0 and 65535, inclusively.";
- public Uint16(final SchemaPath path) {
- super(path, name, description, MAX_VALUE, "");
- this.baseType = this;
+ private Uint16() {
+ super(NAME, DESCRIPTION, MAX_VALUE, "");
}
- /*
- * (non-Javadoc)
- *
- * @see
- * org.opendaylight.yangtools.yang.model.api.TypeDefinition#getBaseType()
- */
- @Override
- public UnsignedIntegerTypeDefinition getBaseType() {
- return baseType;
- }
-
- /*
- * (non-Javadoc)
- *
- * @see
- * org.opendaylight.yangtools.yang.model.api.TypeDefinition#getDefaultValue
- * ()
- */
- @Override
- public Object getDefaultValue() {
- return defaultValue;
+ public static Uint16 getInstance() {
+ if (INSTANCE == null) {
+ INSTANCE = new Uint16();
+ }
+ return INSTANCE;
}
@Override
- public int hashCode() {
- final int prime = 31;
- int result = super.hashCode();
- result = prime * result + ((defaultValue == null) ? 0 : defaultValue.hashCode());
- return result;
+ public UnsignedIntegerTypeDefinition getBaseType() {
+ return this;
}
@Override
- public boolean equals(Object obj) {
- if (this == obj) {
- return true;
- }
- if (!super.equals(obj)) {
- return false;
- }
- if (getClass() != obj.getClass()) {
- return false;
- }
- Uint16 other = (Uint16) obj;
- if (defaultValue == null) {
- if (other.defaultValue != null) {
- return false;
- }
- } else if (!defaultValue.equals(other.defaultValue)) {
- return false;
- }
- return true;
+ public Object getDefaultValue() {
+ return null;
}
@Override
public String toString() {
- StringBuilder builder = new StringBuilder();
- builder.append("Uint16 [defaultValue=");
- builder.append(defaultValue);
- builder.append(", AbstractInteger=");
- builder.append(super.toString());
- builder.append("]");
- return builder.toString();
+ return "type " + NAME;
}
}
package org.opendaylight.yangtools.yang.model.util;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.type.UnsignedIntegerTypeDefinition;
/**
*/
public final class Uint32 extends AbstractUnsignedInteger {
public static final long MAX_VALUE = 4294967295L;
- private static final QName name = BaseTypes.constructQName("uint32");
- private final Long defaultValue = null;
- private static final String description = "uint32 represents integer values between 0 and 4294967295, inclusively.";
- private final UnsignedIntegerTypeDefinition baseType;
+ private static Uint32 INSTANCE;
+ private static final QName NAME = BaseTypes.constructQName("uint32");
+ private static final String DESCRIPTION = "uint32 represents integer values between 0 and 4294967295, inclusively.";
- public Uint32(final SchemaPath path) {
- super(path, name, description, MAX_VALUE, "");
- this.baseType = this;
+ private Uint32() {
+ super(NAME, DESCRIPTION, MAX_VALUE, "");
}
- /*
- * (non-Javadoc)
- *
- * @see
- * org.opendaylight.yangtools.yang.model.api.TypeDefinition#getBaseType()
- */
- @Override
- public UnsignedIntegerTypeDefinition getBaseType() {
- return baseType;
- }
-
- /*
- * (non-Javadoc)
- *
- * @see
- * org.opendaylight.yangtools.yang.model.api.TypeDefinition#getDefaultValue
- * ()
- */
- @Override
- public Object getDefaultValue() {
- return defaultValue;
+ public static Uint32 getInstance() {
+ if (INSTANCE == null) {
+ INSTANCE = new Uint32();
+ }
+ return INSTANCE;
}
@Override
- public int hashCode() {
- final int prime = 31;
- int result = super.hashCode();
- result = prime * result + ((defaultValue == null) ? 0 : defaultValue.hashCode());
- return result;
+ public UnsignedIntegerTypeDefinition getBaseType() {
+ return this;
}
@Override
- public boolean equals(Object obj) {
- if (this == obj) {
- return true;
- }
- if (!super.equals(obj)) {
- return false;
- }
- if (getClass() != obj.getClass()) {
- return false;
- }
- Uint32 other = (Uint32) obj;
- if (defaultValue == null) {
- if (other.defaultValue != null) {
- return false;
- }
- } else if (!defaultValue.equals(other.defaultValue)) {
- return false;
- }
- return true;
+ public Object getDefaultValue() {
+ return null;
}
@Override
public String toString() {
- StringBuilder builder = new StringBuilder();
- builder.append("Uint32 [defaultValue=");
- builder.append(defaultValue);
- builder.append(", AbstractInteger=");
- builder.append(super.toString());
- builder.append("]");
- return builder.toString();
+ return "type " + NAME;
}
}
import java.math.BigInteger;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.type.UnsignedIntegerTypeDefinition;
/**
*/
public final class Uint64 extends AbstractUnsignedInteger {
public static final BigInteger MAX_VALUE = new BigInteger("18446744073709551615");
- private static final QName name = BaseTypes.constructQName("uint64");
- private final BigInteger defaultValue = null;
- private static final String description = "uint64 represents integer values between 0 and 18446744073709551615, inclusively.";
- private final UnsignedIntegerTypeDefinition baseType;
+ private static Uint64 INSTANCE;
+ private static final QName NAME = BaseTypes.constructQName("uint64");
+ private static final String DESCRIPTION = "uint64 represents integer values between 0 and 18446744073709551615, inclusively.";
- public Uint64(final SchemaPath path) {
- super(path, name, description, MAX_VALUE, "");
- this.baseType = this;
+ private Uint64() {
+ super(NAME, DESCRIPTION, MAX_VALUE, "");
}
- /*
- * (non-Javadoc)
- *
- * @see
- * org.opendaylight.yangtools.yang.model.api.TypeDefinition#getBaseType()
- */
- @Override
- public UnsignedIntegerTypeDefinition getBaseType() {
- return baseType;
- }
-
- /*
- * (non-Javadoc)
- *
- * @see
- * org.opendaylight.yangtools.yang.model.api.TypeDefinition#getDefaultValue
- * ()
- */
- @Override
- public Object getDefaultValue() {
- return defaultValue;
+ public static Uint64 getInstance() {
+ if (INSTANCE == null) {
+ INSTANCE = new Uint64();
+ }
+ return INSTANCE;
}
@Override
- public int hashCode() {
- final int prime = 31;
- int result = super.hashCode();
- result = prime * result + ((defaultValue == null) ? 0 : defaultValue.hashCode());
- return result;
+ public UnsignedIntegerTypeDefinition getBaseType() {
+ return this;
}
@Override
- public boolean equals(Object obj) {
- if (this == obj) {
- return true;
- }
- if (!super.equals(obj)) {
- return false;
- }
- if (getClass() != obj.getClass()) {
- return false;
- }
- Uint64 other = (Uint64) obj;
- if (defaultValue == null) {
- if (other.defaultValue != null) {
- return false;
- }
- } else if (!defaultValue.equals(other.defaultValue)) {
- return false;
- }
- return true;
+ public Object getDefaultValue() {
+ return null;
}
@Override
public String toString() {
- StringBuilder builder = new StringBuilder();
- builder.append("Uint64 [defaultValue=");
- builder.append(defaultValue);
- builder.append(", AbstractInteger=");
- builder.append(super.toString());
- builder.append("]");
- return builder.toString();
+ return "type " + NAME;
}
}
package org.opendaylight.yangtools.yang.model.util;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.type.UnsignedIntegerTypeDefinition;
/**
*/
public final class Uint8 extends AbstractUnsignedInteger {
public static final int MAX_VALUE = 255;
- private static final QName name = BaseTypes.constructQName("uint8");
- private final Short defaultValue = null;
- private static final String description = "uint8 represents integer values between 0 and 255, inclusively.";
- private final UnsignedIntegerTypeDefinition baseType;
+ private static Uint8 INSTANCE;
+ private static final QName NAME = BaseTypes.constructQName("uint8");
+ private static final String DESCRIPTION = "uint8 represents integer values between 0 and 255, inclusively.";
- public Uint8(final SchemaPath path) {
- super(path, name, description, MAX_VALUE, "");
- this.baseType = this;
+ private Uint8() {
+ super(NAME, DESCRIPTION, MAX_VALUE, "");
}
- /*
- * (non-Javadoc)
- *
- * @see
- * org.opendaylight.yangtools.yang.model.api.TypeDefinition#getBaseType()
- */
- @Override
- public UnsignedIntegerTypeDefinition getBaseType() {
- return baseType;
- }
-
- /*
- * (non-Javadoc)
- *
- * @see
- * org.opendaylight.yangtools.yang.model.api.TypeDefinition#getDefaultValue
- * ()
- */
- @Override
- public Object getDefaultValue() {
- return defaultValue;
+ public static Uint8 getInstance() {
+ if (INSTANCE == null) {
+ INSTANCE = new Uint8();
+ }
+ return INSTANCE;
}
@Override
- public int hashCode() {
- final int prime = 31;
- int result = super.hashCode();
- result = prime * result + ((defaultValue == null) ? 0 : defaultValue.hashCode());
- return result;
+ public UnsignedIntegerTypeDefinition getBaseType() {
+ return this;
}
@Override
- public boolean equals(Object obj) {
- if (this == obj) {
- return true;
- }
- if (!super.equals(obj)) {
- return false;
- }
- if (getClass() != obj.getClass()) {
- return false;
- }
- Uint8 other = (Uint8) obj;
- if (defaultValue == null) {
- if (other.defaultValue != null) {
- return false;
- }
- } else if (!defaultValue.equals(other.defaultValue)) {
- return false;
- }
- return true;
+ public Object getDefaultValue() {
+ return null;
}
@Override
public String toString() {
- StringBuilder builder = new StringBuilder();
- builder.append("Uint8 [defaultValue=");
- builder.append(defaultValue);
- builder.append(", AbstractInteger=");
- builder.append(super.toString());
- builder.append("]");
- return builder.toString();
+ return "type " + NAME;
}
}
import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
public final class UnionType implements UnionTypeDefinition {
-
private final QName name = BaseTypes.constructQName("union");
- private final SchemaPath path;
+ private final SchemaPath path = BaseTypes.schemaPath(name);
private final String description = "The union built-in type represents a value that corresponds to one of its member types.";
private final String reference = "https://tools.ietf.org/html/rfc6020#section-9.12";
- private final UnionTypeDefinition baseType;
private final List<TypeDefinition<?>> types;
- private UnionType(List<TypeDefinition<?>> types) {
- if (types == null) {
- throw new NullPointerException(
- "When the type is 'union', the 'type' statement MUST be present.");
- }
- path = BaseTypes.schemaPath(name);
- this.types = types;
- this.baseType = this;
- }
-
- public UnionType(final SchemaPath path, List<TypeDefinition<?>> types) {
+ public UnionType(List<TypeDefinition<?>> types) {
if (types == null) {
throw new NullPointerException(
"When the type is 'union', the 'type' statement MUST be present.");
}
- this.path = path;
this.types = types;
- this.baseType = new UnionType(types);
}
@Override
public UnionTypeDefinition getBaseType() {
- return baseType;
+ return this;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
- result = prime * result + ((name == null) ? 0 : name.hashCode());
- result = prime * result + ((path == null) ? 0 : path.hashCode());
result = prime * result + ((types == null) ? 0 : types.hashCode());
return result;
}
return false;
}
UnionType other = (UnionType) obj;
- if (types == null) {
- if (other.types != null) {
- return false;
- }
- } else if (!types.equals(other.types)) {
+ if (!types.equals(other.types)) {
return false;
}
return true;
@Override
public String toString() {
StringBuilder builder = new StringBuilder();
- builder.append("UnionType [name=");
+ builder.append("type ");
builder.append(name);
- builder.append(", types=[");
+ builder.append(" (types=[");
for (TypeDefinition<?> td : types) {
builder.append(", " + td.getQName().getLocalName());
}
builder.append("]");
- builder.append("]");
return builder.toString();
}
import java.util.HashSet;\r
import java.util.Set;\r
\r
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;\r
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;\r
\r
public final class YangTypesConverter {\r
return baseYangTypes.contains(type);\r
}\r
\r
- public static TypeDefinition<?> javaTypeForBaseYangType(SchemaPath path, String typeName) {\r
+ public static TypeDefinition<?> javaTypeForBaseYangType(String typeName) {\r
TypeDefinition<?> type = null;\r
\r
if (typeName.startsWith("int")) {\r
if ("int8".equals(typeName)) {\r
- type = new Int8(path);\r
+ type = Int8.getInstance();\r
} else if ("int16".equals(typeName)) {\r
- type = new Int16(path);\r
+ type = Int16.getInstance();\r
} else if ("int32".equals(typeName)) {\r
- type = new Int32(path);\r
+ type = Int32.getInstance();\r
} else if ("int64".equals(typeName)) {\r
- type = new Int64(path);\r
+ type = Int64.getInstance();\r
}\r
} else if (typeName.startsWith("uint")) {\r
if ("uint8".equals(typeName)) {\r
- type = new Uint8(path);\r
+ type = Uint8.getInstance();\r
} else if ("uint16".equals(typeName)) {\r
- type = new Uint16(path);\r
+ type = Uint16.getInstance();\r
} else if ("uint32".equals(typeName)) {\r
- type = new Uint32(path);\r
+ type = Uint32.getInstance();\r
} else if ("uint64".equals(typeName)) {\r
- type = new Uint64(path);\r
+ type = Uint64.getInstance();\r
}\r
} else if ("string".equals(typeName)) {\r
- type = new StringType(path);\r
+ type = StringType.getIntance();\r
} else if("binary".equals(typeName)) {\r
- type = new BinaryType(path);\r
+ type = BinaryType.getInstance();\r
} else if("boolean".equals(typeName)) {\r
- type = new BooleanType(path);\r
+ type = BooleanType.getInstance();\r
} else if("empty".equals(typeName)) {\r
- type = new EmptyType(path);\r
+ type = EmptyType.getInstance();\r
} else if("instance-identifier".equals(typeName)) {\r
- type = new InstanceIdentifier(path, null, true);\r
+ // FIXME\r
+ type = new InstanceIdentifier(null, true);\r
}\r
\r
return type;\r
import java.util.Collections;
import java.util.List;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
*/
public final class UnionTypeBuilder extends AbstractTypeAwareBuilder implements TypeDefinitionBuilder {
private final static String NAME = "union";
+ private final static QName QNAME = BaseTypes.constructQName(NAME);
private final List<TypeDefinition<?>> types;
private final List<TypeDefinitionBuilder> typedefs;
private UnionType instance;
private boolean isBuilt;
- private SchemaPath path;
-
public UnionTypeBuilder(final String moduleName, final int line) {
super(moduleName, line, BaseTypes.constructQName(NAME));
types = new ArrayList<TypeDefinition<?>>();
@Override
public UnionType build() {
if (!isBuilt) {
- instance = new UnionType(path, types);
+ instance = new UnionType(types);
for (TypeDefinitionBuilder tdb : typedefs) {
types.add(tdb.build());
}
@Override
public void setPath(final SchemaPath schemaPath) {
- this.path = schemaPath;
+ throw new YangParseException(moduleName, line, "Can not set path to " + NAME);
}
@Override
@Override
public SchemaPath getPath() {
- return path;
+ return BaseTypes.schemaPath(QNAME);
}
@Override
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
-import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.parser.api.YangModelParser;
import org.opendaylight.yangtools.yang.model.util.IdentityrefType;
import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.TypeAwareBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.DeviationBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.ExtensionBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.ModuleBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.UnionTypeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.util.CopyUtils;
import org.opendaylight.yangtools.yang.parser.util.GroupingUtils;
import org.opendaylight.yangtools.yang.parser.util.ModuleDependencySort;
import org.opendaylight.yangtools.yang.parser.util.ParserUtils;
fixUnresolvedNodes(modules, moduleBuilder);
}
}
- finishResolveDirtyNodes(modules);
resolveAugments(modules);
resolveUses(modules);
resolveDeviations(modules);
fixUnresolvedNodesWithContext(modules, moduleBuilder, context);
}
}
- finishResolveDirtyNodes(modules);
resolveAugmentsWithContext(modules, context);
resolveUsesWithContext(modules, context);
resolveDeviationsWithContext(modules, context);
}
}
- private void finishResolveDirtyNodes(final Map<String, TreeMap<Date, ModuleBuilder>> modules) {
- final Set<TypeAwareBuilder> dirtyNodes = new HashSet<>();
- for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
- for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {
- dirtyNodes.addAll(inner.getValue().getDirtyNodes());
- }
- }
-
- if (!dirtyNodes.isEmpty()) {
- for (TypeAwareBuilder nodeToResolve : dirtyNodes) {
- if (nodeToResolve instanceof UnionTypeBuilder) {
- List<TypeDefinitionBuilder> newTypes = new ArrayList<>();
- List<TypeDefinitionBuilder> oldTypes = ((UnionTypeBuilder) nodeToResolve).getTypedefs();
- for (TypeDefinitionBuilder tdb : oldTypes) {
- TypeDefinitionBuilder newType = CopyUtils.copy(tdb, nodeToResolve, false);
- ParserUtils.correctTypeAwareNodePath(newType);
- newTypes.add(newType);
- }
- oldTypes.clear();
- oldTypes.addAll(newTypes);
- } else if (nodeToResolve.getType() instanceof IdentityrefType) {
- TypeDefinition<?> idRef = ParserUtils.createCorrectTypeDefinition(nodeToResolve.getPath(),
- nodeToResolve.getType());
- nodeToResolve.setType(idRef);
- } else {
- if (nodeToResolve.getType() == null) {
- TypeDefinitionBuilder tdb = CopyUtils.copy(nodeToResolve.getTypedef(), nodeToResolve, false);
- ParserUtils.correctTypeAwareNodePath(tdb);
- nodeToResolve.setTypedef(tdb);
- } else {
- TypeDefinition<?> td = ParserUtils.createCorrectTypeDefinition(nodeToResolve.getPath(),
- nodeToResolve.getType());
- nodeToResolve.setType(td);
- }
- }
- }
- }
- }
-
private void resolveDirtyNodesWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
final ModuleBuilder module, SchemaContext context) {
final Set<TypeAwareBuilder> dirtyNodes = module.getDirtyNodes();
// check for types which must have body
checkMissingBody(typeName, moduleName, line);
// if there are no constraints, just grab default base yang type
- QName qname = BaseTypes.constructQName(typeName);
- addNodeToPath(qname);
- SchemaPath path = createActualSchemaPath(actualPath.peek());
- type = YangTypesConverter.javaTypeForBaseYangType(path, typeName);
+ type = YangTypesConverter.javaTypeForBaseYangType(typeName);
+ addNodeToPath(type.getQName());
moduleBuilder.setType(type);
} else {
if ("union".equals(typeName)) {
QName qname = BaseTypes.constructQName("union");
addNodeToPath(qname);
- SchemaPath path = createActualSchemaPath(actualPath.peek());
UnionTypeBuilder unionBuilder = moduleBuilder.addUnionType(line, namespace, revision);
Builder parent = moduleBuilder.getActualNode();
unionBuilder.setParent(parent);
moduleBuilder.enterNode(unionBuilder);
- unionBuilder.setPath(path);
} else if ("identityref".equals(typeName)) {
QName qname = BaseTypes.constructQName("identityref");
addNodeToPath(qname);
if (old.getType() == null) {
copy.setTypedef(copy(old.getTypedef(), copy, updateQName));
} else {
- copy.setType(ParserUtils.createCorrectTypeDefinition(copy.getPath(), old.getType()));
+ copy.setType(old.getType());
}
copy.setDefaultStr(old.getDefaultStr());
if (old.getType() == null) {
copy.setTypedef(copy(old.getTypedef(), copy, updateQName));
} else {
- copy.setType(ParserUtils.createCorrectTypeDefinition(copy.getPath(), old.getType()));
+ copy.setType(old.getType());
}
copy.setUserOrdered(old.isUserOrdered());
UnionTypeBuilder oldUnion = (UnionTypeBuilder)old;
type = new UnionTypeBuilder(newParent.getModuleName(), newParent.getLine());
type.setParent(newParent);
- type.setPath(newSchemaPath);
for(TypeDefinition<?> td : oldUnion.getTypes()) {
- type.setType(ParserUtils.createCorrectTypeDefinition(type.getPath(), td));
+ type.setType(td);
}
for(TypeDefinitionBuilder tdb : oldUnion.getTypedefs()) {
type.setTypedef(copy(tdb, type, updateQName));
if (old.getType() == null) {
type.setTypedef(copy(old.getTypedef(), type, updateQName));
} else {
- type.setType(ParserUtils.createCorrectTypeDefinition(type.getPath(), old.getType()));
+ type.setType(old.getType());
}
for (UnknownSchemaNodeBuilder un : old.getUnknownNodeBuilders()) {
} else {
unknownType.setReferenceOnly(true);
}
-
+
return unknownType.build();
}
} else if (typeName.startsWith("int")) {
IntegerTypeDefinition intType = null;
if ("int8".equals(typeName)) {
- intType = new Int8(extBaseTypePath);
+ intType = Int8.getInstance();
} else if ("int16".equals(typeName)) {
- intType = new Int16(extBaseTypePath);
+ intType = Int16.getInstance();
} else if ("int32".equals(typeName)) {
- intType = new Int32(extBaseTypePath);
+ intType = Int32.getInstance();
} else if ("int64".equals(typeName)) {
- intType = new Int64(extBaseTypePath);
+ intType = Int64.getInstance();
}
if (intType == null) {
throw new YangParseException(moduleName, line, "Unknown yang type " + typeName);
} else if (typeName.startsWith("uint")) {
UnsignedIntegerTypeDefinition uintType = null;
if ("uint8".equals(typeName)) {
- uintType = new Uint8(extBaseTypePath);
+ uintType = Uint8.getInstance();
} else if ("uint16".equals(typeName)) {
- uintType = new Uint16(extBaseTypePath);
+ uintType = Uint16.getInstance();
} else if ("uint32".equals(typeName)) {
- uintType = new Uint32(extBaseTypePath);
+ uintType = Uint32.getInstance();
} else if ("uint64".equals(typeName)) {
- uintType = new Uint64(extBaseTypePath);
+ uintType = Uint64.getInstance();
}
if (uintType == null) {
throw new YangParseException(moduleName, line, "Unknown yang type " + typeName);
List<EnumTypeDefinition.EnumPair> enumConstants = getEnumConstants(typeBody, actualPath, moduleName);
return new EnumerationType(baseTypePath, enumConstants);
} else if ("string".equals(typeName)) {
- StringTypeDefinition stringType = new StringType(extBaseTypePath);
+ StringTypeDefinition stringType = StringType.getIntance();
constraints.addLengths(stringType.getLengthStatements());
baseType = stringType;
} else if ("bits".equals(typeName)) {
RevisionAwareXPath xpath = new RevisionAwareXPathImpl(path, absolute);
return new Leafref(baseTypePath, xpath);
} else if ("binary".equals(typeName)) {
- BinaryTypeDefinition binaryType = new BinaryType(extBaseTypePath);
+ BinaryTypeDefinition binaryType = BinaryType.getInstance();
constraints.addLengths(binaryType.getLengthConstraints());
baseType = binaryType;
} else if ("instance-identifier".equals(typeName)) {
boolean requireInstance = isRequireInstance(typeBody);
- return new InstanceIdentifier(extBaseTypePath, null, requireInstance);
+ return new InstanceIdentifier(null, requireInstance);
}
if (parent instanceof TypeDefinitionBuilder && !(parent instanceof UnionTypeBuilder)) {
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.BinaryTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.BooleanTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.DecimalTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.EmptyTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition.EnumPair;
-import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.InstanceIdentifierTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.IntegerTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.UnsignedIntegerTypeDefinition;
-import org.opendaylight.yangtools.yang.model.util.BinaryType;
-import org.opendaylight.yangtools.yang.model.util.BitsType;
-import org.opendaylight.yangtools.yang.model.util.BooleanType;
-import org.opendaylight.yangtools.yang.model.util.Decimal64;
-import org.opendaylight.yangtools.yang.model.util.EmptyType;
-import org.opendaylight.yangtools.yang.model.util.EnumerationType;
-import org.opendaylight.yangtools.yang.model.util.ExtendedType;
-import org.opendaylight.yangtools.yang.model.util.IdentityrefType;
-import org.opendaylight.yangtools.yang.model.util.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.model.util.Leafref;
-import org.opendaylight.yangtools.yang.model.util.StringType;
-import org.opendaylight.yangtools.yang.model.util.UnionType;
import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationTargetBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.TypeAwareBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceBuilder.ChoiceNodeImpl;
import org.opendaylight.yangtools.yang.parser.builder.impl.ModuleBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.NotificationBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.NotificationBuilder.NotificationDefinitionImpl;
-import org.opendaylight.yangtools.yang.parser.builder.impl.UnionTypeBuilder;
public final class ParserUtils {
correctNodePath(choiceCaseBuilder, node.getPath());
}
}
-
- // if node can contains type, correct path for this type too
- if (node instanceof TypeAwareBuilder) {
- TypeAwareBuilder nodeBuilder = (TypeAwareBuilder) node;
- correctTypeAwareNodePath(nodeBuilder);
- }
- }
-
- /**
- * Repair schema path of node type.
- *
- * @param node
- * node which contains type statement
- * @param parentSchemaPath
- * schema path of parent node
- */
- public static void correctTypeAwareNodePath(final TypeAwareBuilder node) {
- final SchemaPath parentSchemaPath = node.getPath();
- final TypeDefinition<?> nodeType = node.getType();
-
- // handle union type
- if (node instanceof UnionTypeBuilder) {
- for (TypeDefinitionBuilder tdb : ((UnionTypeBuilder) node).getTypedefs()) {
- SchemaPath newSchemaPath = createSchemaPath(node.getPath(), tdb.getQName());
- tdb.setPath(newSchemaPath);
- correctTypeAwareNodePath(tdb);
- }
- List<TypeDefinition<?>> oldTypes = ((UnionTypeBuilder) node).getTypes();
- List<TypeDefinition<?>> newTypes = new ArrayList<>();
- for (TypeDefinition<?> td : oldTypes) {
- TypeDefinition<?> newType = createCorrectTypeDefinition(node.getPath(), td);
- newTypes.add(newType);
- }
- oldTypes.clear();
- oldTypes.addAll(newTypes);
- return;
- }
-
- // handle identityref type
- if (node instanceof IdentityrefTypeBuilder) {
- return;
- }
-
- // default handling
- if (nodeType == null) {
- TypeDefinitionBuilder nodeTypedef = node.getTypedef();
- SchemaPath newSchemaPath = createSchemaPath(parentSchemaPath, nodeTypedef.getQName());
- nodeTypedef.setPath(newSchemaPath);
- correctTypeAwareNodePath(nodeTypedef);
- } else {
- TypeDefinition<?> newType = createCorrectTypeDefinition(parentSchemaPath, nodeType);
- node.setType(newType);
- }
-
- }
-
- public static TypeDefinition<?> createCorrectTypeDefinition(SchemaPath parentSchemaPath, TypeDefinition<?> nodeType) {
- TypeDefinition<?> result = null;
-
- if (nodeType != null) {
- SchemaPath newSchemaPath = createSchemaPath(parentSchemaPath, nodeType.getQName());
-
- if (nodeType instanceof BinaryTypeDefinition) {
- BinaryTypeDefinition binType = (BinaryTypeDefinition) nodeType;
-
- // List<Byte> bytes = (List<Byte>) binType.getDefaultValue();
- // workaround to get rid of 'Unchecked cast' warning
- List<Byte> bytes = new ArrayList<Byte>();
- Object defaultValue = binType.getDefaultValue();
- if (defaultValue instanceof List) {
- for (Object o : List.class.cast(defaultValue)) {
- if (o instanceof Byte) {
- bytes.add((Byte) o);
- }
- }
- }
- result = new BinaryType(newSchemaPath, bytes);
- } else if (nodeType instanceof BitsTypeDefinition) {
- BitsTypeDefinition bitsType = (BitsTypeDefinition) nodeType;
- result = new BitsType(newSchemaPath, bitsType.getBits());
- } else if (nodeType instanceof BooleanTypeDefinition) {
- result = new BooleanType(newSchemaPath);
- } else if (nodeType instanceof DecimalTypeDefinition) {
- DecimalTypeDefinition decimalType = (DecimalTypeDefinition) nodeType;
- result = new Decimal64(newSchemaPath, decimalType.getFractionDigits());
- } else if (nodeType instanceof EmptyTypeDefinition) {
- result = new EmptyType(newSchemaPath);
- } else if (nodeType instanceof EnumTypeDefinition) {
- EnumTypeDefinition enumType = (EnumTypeDefinition) nodeType;
- result = new EnumerationType(newSchemaPath, (EnumPair) enumType.getDefaultValue(), enumType.getValues());
- } else if (nodeType instanceof IdentityrefTypeDefinition) {
- IdentityrefTypeDefinition idrefType = (IdentityrefTypeDefinition) nodeType;
- result = new IdentityrefType(idrefType.getIdentity(), newSchemaPath);
- } else if (nodeType instanceof InstanceIdentifierTypeDefinition) {
- InstanceIdentifierTypeDefinition instIdType = (InstanceIdentifierTypeDefinition) nodeType;
- return new InstanceIdentifier(newSchemaPath, instIdType.getPathStatement(),
- instIdType.requireInstance());
- } else if (nodeType instanceof StringTypeDefinition) {
- result = new StringType(newSchemaPath);
- } else if (nodeType instanceof IntegerTypeDefinition) {
- result = TypeUtils.createNewIntType(newSchemaPath, (IntegerTypeDefinition) nodeType);
- } else if (nodeType instanceof UnsignedIntegerTypeDefinition) {
- result = TypeUtils.createNewUintType(newSchemaPath, (UnsignedIntegerTypeDefinition) nodeType);
- } else if (nodeType instanceof LeafrefTypeDefinition) {
- result = new Leafref(newSchemaPath, ((LeafrefTypeDefinition) nodeType).getPathStatement());
- } else if (nodeType instanceof UnionTypeDefinition) {
- UnionTypeDefinition unionType = (UnionTypeDefinition) nodeType;
- return new UnionType(newSchemaPath, unionType.getTypes());
- } else if (nodeType instanceof ExtendedType) {
- ExtendedType extType = (ExtendedType) nodeType;
- result = TypeUtils.createNewExtendedType(extType, newSchemaPath);
- }
- }
- return result;
}
/**
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.BinaryTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.DecimalTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.IntegerTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.UnsignedIntegerTypeDefinition;
import org.opendaylight.yangtools.yang.model.util.ExtendedType;
-import org.opendaylight.yangtools.yang.model.util.Int16;
-import org.opendaylight.yangtools.yang.model.util.Int32;
-import org.opendaylight.yangtools.yang.model.util.Int64;
-import org.opendaylight.yangtools.yang.model.util.Int8;
-import org.opendaylight.yangtools.yang.model.util.Uint16;
-import org.opendaylight.yangtools.yang.model.util.Uint32;
-import org.opendaylight.yangtools.yang.model.util.Uint64;
-import org.opendaylight.yangtools.yang.model.util.Uint8;
import org.opendaylight.yangtools.yang.model.util.UnknownType;
import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
import org.opendaylight.yangtools.yang.parser.builder.api.DataNodeContainerBuilder;
}
}
- /**
- * Create new ExtendedType based on given type and with schema path.
- *
- * @param newPath
- * schema path for new type
- * @param oldType
- * type based
- * @return
- */
- static ExtendedType createNewExtendedType(final ExtendedType oldType, final SchemaPath newPath) {
- QName qname = oldType.getQName();
- TypeDefinition<?> newBaseType = ParserUtils.createCorrectTypeDefinition(newPath, oldType.getBaseType());
- String desc = oldType.getDescription();
- String ref = oldType.getReference();
- ExtendedType.Builder builder = new ExtendedType.Builder(qname, newBaseType, desc, ref, newPath);
- builder.status(oldType.getStatus());
- builder.lengths(oldType.getLengths());
- builder.patterns(oldType.getPatterns());
- builder.ranges(oldType.getRanges());
- builder.fractionDigits(oldType.getFractionDigits());
- builder.unknownSchemaNodes(oldType.getUnknownSchemaNodes());
- return builder.build();
- }
-
- static IntegerTypeDefinition createNewIntType(final SchemaPath newSchemaPath,
- final IntegerTypeDefinition type) {
- final String localName = type.getQName().getLocalName();
- if ("int8".equals(localName)) {
- return new Int8(newSchemaPath);
- } else if ("int16".equals(localName)) {
- return new Int16(newSchemaPath);
- } else if ("int32".equals(localName)) {
- return new Int32(newSchemaPath);
- } else if ("int64".equals(localName)) {
- return new Int64(newSchemaPath);
- } else {
- return null;
- }
- }
-
- static UnsignedIntegerTypeDefinition createNewUintType(final SchemaPath newSchemaPath,
- final UnsignedIntegerTypeDefinition type) {
- final String localName = type.getQName().getLocalName();
- if ("uint8".equals(localName)) {
- return new Uint8(newSchemaPath);
- } else if ("uint16".equals(localName)) {
- return new Uint16(newSchemaPath);
- } else if ("uint32".equals(localName)) {
- return new Uint32(newSchemaPath);
- } else if ("uint64".equals(localName)) {
- return new Uint64(newSchemaPath);
- } else {
- return null;
- }
- }
-
/**
* Create new type builder based on old type with new base type.
*
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
-import java.util.ArrayList;
import java.util.Arrays;
+import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.Set;
assertEquals(expectedPath, ds0ChannelNumber.getPath());
// type of leaf ds0ChannelNumber
QName typeQName = BaseTypes.constructQName("string");
- List<QName> typePath = new ArrayList<>(Arrays.asList(qnames));
- typePath.add(typeQName);
+ List<QName> typePath = Collections.singletonList(typeQName);
expectedPath = new SchemaPath(typePath, true);
assertEquals(expectedPath, ds0ChannelNumber.getType().getPath());
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.util.BaseTypes;
+import org.opendaylight.yangtools.yang.model.util.BooleanType;
+import org.opendaylight.yangtools.yang.model.util.Uint32;
+import org.opendaylight.yangtools.yang.model.util.Uint8;
import org.opendaylight.yangtools.yang.model.util.UnionType;
import com.google.common.collect.Lists;
assertNotNull(version);
assertEquals(createPath("pcreq", "version"), version.getPath());
assertEquals(createPath("pcreq", "version", "protocol-version"), version.getType().getPath());
- assertEquals(createPathForYangType("pcreq", "version", "protocol-version", "uint8"), version.getType()
- .getBaseType().getPath());
+ assertEquals(Uint8.getInstance(), version.getType().getBaseType());
assertTrue(version.isAddedByUses());
// * |-- leaf type (U)
LeafSchemaNode type = (LeafSchemaNode) pcreq.getDataChildByName("type");
assertEquals(createPath("pcreq", "type"), type.getPath());
assertEquals(createPath("pcreq", "type", "int-ext"), type.getType().getPath());
UnionType union = (UnionType)type.getType().getBaseType();
- assertEquals(createPathForYangType("pcreq", "type", "int-ext", "union"), union.getPath());
+ assertEquals(BaseTypes.schemaPath(BaseTypes.constructQName("union")), union.getPath());
assertEquals(2, union.getTypes().size());
// * |-- list requests
ListSchemaNode requests = (ListSchemaNode) pcreq.getDataChildByName("requests");
LeafSchemaNode priority = (LeafSchemaNode) rp.getDataChildByName("priority");
assertNotNull(priority);
assertEquals(createPath("pcreq", "requests", "rp", "priority"), priority.getPath());
- assertEquals(createPath("pcreq", "requests", "rp", "priority", "uint8"), priority.getType().getPath());
- assertEquals(createPathForYangType("pcreq", "requests", "rp", "priority", "uint8", "uint8"), priority.getType()
- .getBaseType().getPath());
+ assertEquals(createPath("rp-object", "priority", "uint8"), priority.getType().getPath());
+ assertEquals(Uint8.getInstance(), priority.getType().getBaseType());
assertTrue(priority.isAddedByUses());
// * |-- |-- |-- container box (U)
ContainerSchemaNode box = (ContainerSchemaNode) rp.getDataChildByName("box");
LeafSchemaNode delete = (LeafSchemaNode) order.getDataChildByName("delete");
assertNotNull(delete);
assertEquals(createPath("pcreq", "requests", "rp", "box", "order", "delete"), delete.getPath());
- assertEquals(createPathForYangType("pcreq", "requests", "rp", "box", "order", "delete", "uint32"), delete
- .getType().getPath());
+ assertEquals(Uint32.getInstance(), delete.getType());
assertTrue(delete.isAddedByUses());
// * |-- |-- |-- |-- |-- leaf ignore (U)
LeafSchemaNode setup = (LeafSchemaNode) order.getDataChildByName("setup");
assertNotNull(setup);
assertEquals(createPath("pcreq", "requests", "rp", "box", "order", "setup"), setup.getPath());
- assertEquals(createPathForYangType("pcreq", "requests", "rp", "box", "order", "setup", "uint32"), setup
- .getType().getPath());
+ assertEquals(Uint32.getInstance(), setup.getType());
assertTrue(setup.isAddedByUses());
// * |-- |-- |-- leaf processing-rule (U)
LeafSchemaNode processingRule = (LeafSchemaNode) rp.getDataChildByName("processing-rule");
assertNotNull(processingRule);
assertEquals(createPath("pcreq", "requests", "rp", "processing-rule"), processingRule.getPath());
- assertEquals(createPathForYangType("pcreq", "requests", "rp", "processing-rule", "boolean"), processingRule
- .getType().getPath());
+ assertEquals(BooleanType.getInstance(), processingRule.getType());
assertTrue(processingRule.isAddedByUses());
// * |-- |-- |-- leaf ignore (U)
LeafSchemaNode ignore = (LeafSchemaNode) rp.getDataChildByName("ignore");
assertNotNull(ignore);
assertEquals(createPath("pcreq", "requests", "rp", "ignore"), ignore.getPath());
- assertEquals(createPathForYangType("pcreq", "requests", "rp", "ignore", "boolean"), ignore.getType().getPath());
+ assertEquals(BooleanType.getInstance(), ignore.getType());
assertTrue(ignore.isAddedByUses());
// * |-- |-- path-key-expansion
ContainerSchemaNode pke = (ContainerSchemaNode) requests.getDataChildByName("path-key-expansion");
assertEquals(
createPath("pcreq", "requests", "path-key-expansion", "path-key", "path-keys", "version",
"protocol-version"), version.getType().getPath());
- assertEquals(
- createPathForYangType("pcreq", "requests", "path-key-expansion", "path-key", "path-keys", "version",
- "protocol-version", "uint8"), version.getType().getBaseType().getPath());
+ assertEquals(Uint8.getInstance(), version.getType().getBaseType());
assertTrue(version.isAddedByUses());
assertFalse(version.isAugmenting());
// * |-- |-- |-- |-- |-- leaf type (U)
assertEquals(
createPath("pcreq", "requests", "path-key-expansion", "path-key", "path-keys", "type",
"int-ext"), type.getType().getPath());
- assertEquals(
- createPathForYangType("pcreq", "requests", "path-key-expansion", "path-key", "path-keys", "type",
- "int-ext", "union"), type.getType().getBaseType().getPath());
assertTrue(type.isAddedByUses());
assertFalse(type.isAugmenting());
// * |-- |-- |-- |-- |-- leaf processing-rule (U)
assertNotNull(processingRule);
assertEquals(createPath("pcreq", "requests", "path-key-expansion", "path-key", "processing-rule"),
processingRule.getPath());
- assertEquals(
- createPathForYangType("pcreq", "requests", "path-key-expansion", "path-key", "processing-rule",
- "boolean"), processingRule.getType().getPath());
+ assertEquals(BooleanType.getInstance(), processingRule.getType());
assertTrue(processingRule.isAddedByUses());
// * |-- |-- |-- |-- |-- leaf ignore (U)
ignore = (LeafSchemaNode) pathKey.getDataChildByName("ignore");
assertNotNull(ignore);
assertEquals(createPath("pcreq", "requests", "path-key-expansion", "path-key", "ignore"), ignore.getPath());
- assertEquals(createPathForYangType("pcreq", "requests", "path-key-expansion", "path-key", "ignore", "boolean"),
- ignore.getType().getPath());
+ assertEquals(BooleanType.getInstance(), ignore.getType());
assertTrue(ignore.isAddedByUses());
// * |-- |-- container segment-computation
ContainerSchemaNode sc = (ContainerSchemaNode) requests.getDataChildByName("segment-computation");
assertNotNull(processingRule);
assertEquals(createPath("pcreq", "requests", "segment-computation", "p2p", "endpoints", "processing-rule"),
processingRule.getPath());
- assertEquals(
- createPathForYangType("pcreq", "requests", "segment-computation", "p2p", "endpoints",
- "processing-rule", "boolean"), processingRule.getType().getPath());
+ assertEquals(BooleanType.getInstance(), processingRule.getType());
assertTrue(processingRule.isAddedByUses());
// * |-- |-- |-- |-- |-- leaf ignore (U)
ignore = (LeafSchemaNode) endpoints.getDataChildByName("ignore");
assertNotNull(ignore);
assertEquals(createPath("pcreq", "requests", "segment-computation", "p2p", "endpoints", "ignore"),
ignore.getPath());
- assertEquals(
- createPathForYangType("pcreq", "requests", "segment-computation", "p2p", "endpoints", "ignore",
- "boolean"), ignore.getType().getPath());
+ assertEquals(BooleanType.getInstance(), ignore.getType());
assertTrue(ignore.isAddedByUses());
// * |-- |-- |-- |-- |-- container box
box = (ContainerSchemaNode) endpoints.getDataChildByName("box");
assertEquals(
createPath("pcreq", "requests", "segment-computation", "p2p", "reported-route", "processing-rule"),
processingRule.getPath());
- assertEquals(
- createPathForYangType("pcreq", "requests", "segment-computation", "p2p", "reported-route",
- "processing-rule", "boolean"), processingRule.getType().getPath());
+ assertEquals(BooleanType.getInstance(), processingRule.getType());
assertTrue(processingRule.isAddedByUses());
// * |-- |-- |-- |-- |-- leaf ignore (U)
ignore = (LeafSchemaNode) reportedRoute.getDataChildByName("ignore");
assertNotNull(ignore);
assertEquals(createPath("pcreq", "requests", "segment-computation", "p2p", "reported-route", "ignore"),
ignore.getPath());
- assertEquals(
- createPathForYangType("pcreq", "requests", "segment-computation", "p2p", "reported-route", "ignore",
- "boolean"), ignore.getType().getPath());
+ assertEquals(BooleanType.getInstance(), ignore.getType());
assertTrue(ignore.isAddedByUses());
// * |-- |-- |-- |-- container bandwidth (U)
bandwidth = (ContainerSchemaNode) p2p.getDataChildByName("bandwidth");
assertNotNull(processingRule);
assertEquals(createPath("pcreq", "requests", "segment-computation", "p2p", "bandwidth", "processing-rule"),
processingRule.getPath());
- assertEquals(
- createPathForYangType("pcreq", "requests", "segment-computation", "p2p", "bandwidth",
- "processing-rule", "boolean"), processingRule.getType().getPath());
+ assertEquals(BooleanType.getInstance(), processingRule.getType());
assertTrue(processingRule.isAddedByUses());
// * |-- |-- |-- |-- |-- leaf ignore (U)
ignore = (LeafSchemaNode) bandwidth.getDataChildByName("ignore");
assertNotNull(ignore);
assertEquals(createPath("pcreq", "requests", "segment-computation", "p2p", "bandwidth", "ignore"),
ignore.getPath());
- assertEquals(
- createPathForYangType("pcreq", "requests", "segment-computation", "p2p", "bandwidth", "ignore",
- "boolean"), ignore.getType().getPath());
+ assertEquals(BooleanType.getInstance(), ignore.getType());
assertTrue(ignore.isAddedByUses());
// * |-- list svec
ListSchemaNode svec = (ListSchemaNode) pcreq.getDataChildByName("svec");
LeafSchemaNode metricType = (LeafSchemaNode) metric.getDataChildByName("metric-type");
assertNotNull(metricType);
assertEquals(createPath("pcreq", "svec", "metric", "metric-type"), metricType.getPath());
- assertEquals(createPathForYangType("pcreq", "svec", "metric", "metric-type", "uint8"), metricType.getType()
- .getPath());
+ assertEquals(Uint8.getInstance(), metricType.getType());
assertTrue(metricType.isAddedByUses());
// * |-- |-- |-- box (U)
box = (ContainerSchemaNode) metric.getDataChildByName("box");
processingRule = (LeafSchemaNode) metric.getDataChildByName("processing-rule");
assertNotNull(processingRule);
assertEquals(createPath("pcreq", "svec", "metric", "processing-rule"), processingRule.getPath());
- assertEquals(createPathForYangType("pcreq", "svec", "metric", "processing-rule", "boolean"), processingRule
- .getType().getPath());
+ assertEquals(BooleanType.getInstance(), processingRule.getType());
assertTrue(processingRule.isAddedByUses());
// * |-- |-- |-- leaf ignore (U)
ignore = (LeafSchemaNode) metric.getDataChildByName("ignore");
assertNotNull(ignore);
assertEquals(createPath("pcreq", "svec", "metric", "ignore"), ignore.getPath());
- assertEquals(createPathForYangType("pcreq", "svec", "metric", "ignore", "boolean"), ignore.getType().getPath());
+ assertEquals(BooleanType.getInstance(), ignore.getType());
assertTrue(ignore.isAddedByUses());
// * |-- |-- leaf link-diverse (U)
LeafSchemaNode linkDiverse = (LeafSchemaNode) svec.getDataChildByName("link-diverse");
assertNotNull(linkDiverse);
assertEquals(createPath("pcreq", "svec", "link-diverse"), linkDiverse.getPath());
- assertEquals(createPathForYangType("pcreq", "svec", "link-diverse", "boolean"), linkDiverse.getType().getPath());
+ assertEquals(BooleanType.getInstance(), linkDiverse.getType());
assertTrue(linkDiverse.isAddedByUses());
// * |-- |-- leaf processing-rule (U)
processingRule = (LeafSchemaNode) svec.getDataChildByName("processing-rule");
assertNotNull(processingRule);
assertEquals(createPath("pcreq", "svec", "processing-rule"), processingRule.getPath());
- assertEquals(createPathForYangType("pcreq", "svec", "processing-rule", "boolean"), processingRule.getType()
- .getPath());
+ assertEquals(BooleanType.getInstance(), processingRule.getType());
assertTrue(processingRule.isAddedByUses());
// * |-- |-- leaf ignore (U)
ignore = (LeafSchemaNode) svec.getDataChildByName("ignore");
assertNotNull(ignore);
assertEquals(createPath("pcreq", "svec", "ignore"), ignore.getPath());
- assertEquals(createPathForYangType("pcreq", "svec", "ignore", "boolean"), ignore.getType().getPath());
+ assertEquals(BooleanType.getInstance(), ignore.getType());
assertTrue(ignore.isAddedByUses());
}
return new SchemaPath(path, true);
}
- private SchemaPath createPathForYangType(String... names) {
- List<QName> path = new ArrayList<>();
- for (int i = 0; i < names.length - 1; i++) {
- path.add(new QName(ns, rev, prefix, names[i]));
- }
- path.add(new QName(URI.create("urn:ietf:params:xml:ns:yang:1"), names[names.length - 1]));
- return new SchemaPath(path, true);
- }
-
@Test
public void testTypedefs() throws FileNotFoundException {
modules = TestUtils.loadModules(getClass().getResource("/grouping-test").getPath());
assertNotNull(pv);
SchemaPath expectedPath = null;
- QName q0 = new QName(ns, rev, prefix, "int-ext");
QName q1 = BaseTypes.constructQName("union");
- expectedPath = new SchemaPath(Lists.newArrayList(q0, q1), true);
+ expectedPath = new SchemaPath(Lists.newArrayList(q1), true);
assertEquals(expectedPath, union.getPath());
}
LeafListSchemaNode added = (LeafListSchemaNode)nodes.getDataChildByName("added");
assertNotNull(added);
assertEquals(createPath("nodes", "added"), added.getPath());
- assertEquals(createPath("nodes", "added", "mytype"), added.getType().getPath());
+ assertEquals(createPath("mytype"), added.getType().getPath());
ListSchemaNode links = (ListSchemaNode) nodes.getDataChildByName("links");
assertNotNull(links);
Set<TypeDefinition<?>> types = test.getTypeDefinitions();
// int32-ext1
- ExtendedType int32Typedef = (ExtendedType) TestUtils.findTypedef(types, "int32-ext1");
- QName int32TypedefQName = int32Typedef.getQName();
+ ExtendedType int32ext1 = (ExtendedType) TestUtils.findTypedef(types, "int32-ext1");
+ QName int32TypedefQName = int32ext1.getQName();
assertEquals(typesNS, int32TypedefQName.getNamespace());
assertEquals(typesRev, int32TypedefQName.getRevision());
assertEquals("t", int32TypedefQName.getPrefix());
assertEquals("int32-ext1", int32TypedefQName.getLocalName());
- SchemaPath typeSchemaPath = int32Typedef.getPath();
+ SchemaPath typeSchemaPath = int32ext1.getPath();
List<QName> typePath = typeSchemaPath.getPath();
assertEquals(1, typePath.size());
assertEquals(int32TypedefQName, typePath.get(0));
// int32-ext1/int32
- Int32 int32 = (Int32) int32Typedef.getBaseType();
- QName int32QName = int32.getQName();
- assertEquals(URI.create("urn:ietf:params:xml:ns:yang:1"), int32QName.getNamespace());
- assertNull(int32QName.getRevision());
- assertEquals("", int32QName.getPrefix());
- assertEquals("int32", int32QName.getLocalName());
-
- SchemaPath int32SchemaPath = int32.getPath();
- List<QName> int32Path = int32SchemaPath.getPath();
- assertEquals(2, int32Path.size());
- assertEquals(int32TypedefQName, int32Path.get(0));
- assertEquals(int32QName, int32Path.get(1));
+ Int32 int32 = (Int32) int32ext1.getBaseType();
+ assertEquals(Int32.getInstance(), int32);
}
@Test
Code Review / yangtools.git / commitdiff