*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
-import static org.opendaylight.yangtools.yang.parser.builder.impl.BuilderUtils.findModuleFromBuilders;
-import static org.opendaylight.yangtools.yang.parser.builder.impl.BuilderUtils.findModuleFromContext;
-
-import java.util.ArrayList;
+import static org.opendaylight.yangtools.yang.parser.builder.impl.BuilderUtils.findBaseIdentity;
+import java.net.URI;
import java.util.Date;
-import java.util.List;
import java.util.Map;
+import java.util.NavigableMap;
import java.util.Set;
-import java.util.TreeMap;
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.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.UnknownType;
import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
import org.opendaylight.yangtools.yang.parser.builder.api.DataNodeContainerBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.TypeAwareBuilder;
/**
* Utility class which contains helper methods for dealing with type operations.
+ *
+ * @deprecated Pre-Beryllium implementation, scheduled for removal.
*/
+@Deprecated
public final class TypeUtils {
private TypeUtils() {
* current module
*/
public static void resolveType(final TypeAwareBuilder nodeToResolve,
- final Map<String, TreeMap<Date, ModuleBuilder>> modules, final ModuleBuilder module) {
- final int line = nodeToResolve.getLine();
- final TypeDefinition<?> nodeToResolveType = nodeToResolve.getType();
- final QName unknownTypeQName = nodeToResolveType.getBaseType().getQName();
- final ModuleBuilder dependentModuleBuilder = findModuleFromBuilders(modules, module,
- unknownTypeQName.getPrefix(), line);
-
+ final Map<URI, NavigableMap<Date, ModuleBuilder>> modules, final ModuleBuilder module) {
+ QName unknownTypeQName = nodeToResolve.getTypeQName();
+ final ModuleBuilder dependentModuleBuilder = BuilderUtils.findModule(unknownTypeQName, modules);
+ if (dependentModuleBuilder == null) {
+ throw new YangParseException(module.getName(), nodeToResolve.getLine(), "Type not found: "
+ + unknownTypeQName);
+ }
TypeDefinitionBuilder resolvedType = findUnknownTypeDefinition(nodeToResolve, dependentModuleBuilder, modules,
module);
nodeToResolve.setTypedef(resolvedType);
}
- /**
- * Resolve unknown type of node. It is assumed that type of node is either
- * UnknownType or ExtendedType with UnknownType as base type.
- *
- * @param nodeToResolve
- * node with type to resolve
- * @param modules
- * all loaded modules
- * @param module
- * current module
- * @param context
- * SchemaContext containing already resolved modules
- */
- public static void resolveTypeWithContext(final TypeAwareBuilder nodeToResolve,
- final Map<String, TreeMap<Date, ModuleBuilder>> modules, final ModuleBuilder module,
- final SchemaContext context) {
- final int line = nodeToResolve.getLine();
- final TypeDefinition<?> nodeToResolveType = nodeToResolve.getType();
- final QName unknownTypeQName = nodeToResolveType.getBaseType().getQName();
- final ModuleBuilder dependentModuleBuilder = findModuleFromBuilders(modules, module,
- unknownTypeQName.getPrefix(), line);
-
- if (dependentModuleBuilder == null) {
- final Module dependentModule = findModuleFromContext(context, module, unknownTypeQName.getPrefix(), line);
- final Set<TypeDefinition<?>> types = dependentModule.getTypeDefinitions();
- final TypeDefinition<?> type = findTypeByName(types, unknownTypeQName.getLocalName());
-
- if (nodeToResolveType instanceof ExtendedType) {
- final ExtendedType extType = (ExtendedType) nodeToResolveType;
- final TypeDefinitionBuilder newType = extendedTypeWithNewBase(null, type, extType, modules, module,
- nodeToResolve.getLine());
-
- nodeToResolve.setTypedef(newType);
- } else {
- if (nodeToResolve instanceof TypeDefinitionBuilder) {
- TypeDefinitionBuilder tdb = (TypeDefinitionBuilder) nodeToResolve;
- TypeConstraints tc = findConstraintsFromTypeBuilder(nodeToResolve,
- new TypeConstraints(module.getName(), nodeToResolve.getLine()), modules, module, context);
- tdb.setLengths(tc.getLength());
- tdb.setPatterns(tc.getPatterns());
- tdb.setRanges(tc.getRange());
- tdb.setFractionDigits(tc.getFractionDigits());
- }
- nodeToResolve.setType(type);
- }
-
- } else {
- TypeDefinitionBuilder resolvedType = findUnknownTypeDefinition(nodeToResolve, dependentModuleBuilder,
- modules, module);
- nodeToResolve.setTypedef(resolvedType);
- }
- }
-
- public static void resolveTypeUnion(final UnionTypeBuilder union,
- final Map<String, TreeMap<Date, ModuleBuilder>> modules, final ModuleBuilder builder) {
- final List<TypeDefinition<?>> unionTypes = union.getTypes();
- final List<TypeDefinition<?>> toRemove = new ArrayList<>();
- for (TypeDefinition<?> unionType : unionTypes) {
- if (unionType instanceof UnknownType) {
- final ModuleBuilder dependentModule = findModuleFromBuilders(modules, builder, unionType.getQName()
- .getPrefix(), union.getLine());
- final TypeDefinitionBuilder resolvedType = findTypeDefinitionBuilder(union, dependentModule, unionType
- .getQName().getLocalName(), builder.getName(), union.getLine());
- union.setTypedef(resolvedType);
- toRemove.add(unionType);
- } else if (unionType instanceof ExtendedType && unionType.getBaseType() instanceof UnknownType) {
- final UnknownType ut = (UnknownType) unionType.getBaseType();
- final ModuleBuilder dependentModule = findModuleFromBuilders(modules, builder, ut.getQName()
- .getPrefix(), union.getLine());
- final TypeDefinitionBuilder targetTypeBuilder = findTypeDefinitionBuilder(union, dependentModule, ut
- .getQName().getLocalName(), builder.getName(), union.getLine());
- final TypeDefinitionBuilder newType = extendedTypeWithNewBase(targetTypeBuilder, null,
- (ExtendedType) unionType, modules, builder, union.getLine());
- union.setTypedef(newType);
- toRemove.add(unionType);
- }
- }
- unionTypes.removeAll(toRemove);
- }
-
/**
* Resolve union type which contains one or more unresolved types.
*
* all loaded modules
* @param module
* current module
- * @param context
- * SchemaContext containing already resolved modules
*/
- public static void resolveTypeUnionWithContext(final UnionTypeBuilder union,
- final Map<String, TreeMap<Date, ModuleBuilder>> modules, final ModuleBuilder module,
- final SchemaContext context) {
- final List<TypeDefinition<?>> unionTypes = union.getTypes();
- final List<TypeDefinition<?>> toRemove = new ArrayList<>();
- for (TypeDefinition<?> unionType : unionTypes) {
- if (unionType instanceof UnknownType) {
- resolveUnionUnknownType(union, (UnknownType) unionType, modules, module, context);
- toRemove.add(unionType);
- } else if (unionType instanceof ExtendedType && unionType.getBaseType() instanceof UnknownType) {
- resolveUnionUnknownType(union, (ExtendedType) unionType, modules, module, context);
- toRemove.add(unionType);
+ public static void resolveTypeUnion(final UnionTypeBuilder union,
+ final Map<URI, NavigableMap<Date, ModuleBuilder>> modules, final ModuleBuilder module) {
+ // special handling for identityref types under union
+ for (TypeDefinitionBuilder unionType : union.getTypedefs()) {
+ if (unionType instanceof IdentityrefTypeBuilder) {
+ IdentityrefTypeBuilder idref = (IdentityrefTypeBuilder) unionType;
+ IdentitySchemaNodeBuilder identity = findBaseIdentity(module, idref.getBaseString(),
+ idref.getLine());
+ if (identity == null) {
+ throw new YangParseException(module.getName(), idref.getLine(), "Failed to find base identity");
+ }
+ idref.setBaseIdentity(identity);
}
}
- unionTypes.removeAll(toRemove);
- }
-
- private static void resolveUnionUnknownType(final UnionTypeBuilder union, final UnknownType ut,
- final Map<String, TreeMap<Date, ModuleBuilder>> modules, final ModuleBuilder module,
- final SchemaContext context) {
- final int line = union.getLine();
- final QName utQName = ut.getQName();
- final ModuleBuilder dependentModuleBuilder = findModuleFromBuilders(modules, module, utQName.getPrefix(), line);
-
- if (dependentModuleBuilder == null) {
- Module dependentModule = findModuleFromContext(context, module, utQName.getPrefix(), line);
- Set<TypeDefinition<?>> types = dependentModule.getTypeDefinitions();
- TypeDefinition<?> type = findTypeByName(types, utQName.getLocalName());
- union.setType(type);
- } else {
- final TypeDefinitionBuilder resolvedType = findTypeDefinitionBuilder(union, dependentModuleBuilder,
- utQName.getLocalName(), module.getName(), union.getLine());
- union.setTypedef(resolvedType);
- }
- }
-
- private static void resolveUnionUnknownType(final UnionTypeBuilder union, final ExtendedType extType,
- final Map<String, TreeMap<Date, ModuleBuilder>> modules, final ModuleBuilder module,
- final SchemaContext context) {
- final int line = union.getLine();
- final TypeDefinition<?> extTypeBase = extType.getBaseType();
- final UnknownType ut = (UnknownType) extTypeBase;
- final QName utQName = ut.getQName();
- final ModuleBuilder dependentModuleBuilder = findModuleFromBuilders(modules, module, utQName.getPrefix(), line);
+ for (QName unknownTypeQName : union.getBaseTypeQNames()) {
+ final ModuleBuilder dependentModuleBuilder = BuilderUtils.findModule(unknownTypeQName, modules);
+ if (dependentModuleBuilder == null) {
+ throw new YangParseException(module.getName(), union.getLine(), "Type not found: " + unknownTypeQName);
+ }
- if (dependentModuleBuilder == null) {
- final Module dependentModule = findModuleFromContext(context, module, utQName.getPrefix(), line);
- Set<TypeDefinition<?>> types = dependentModule.getTypeDefinitions();
- TypeDefinition<?> type = findTypeByName(types, utQName.getLocalName());
- final TypeDefinitionBuilder newType = extendedTypeWithNewBase(null, type, extType, modules, module, 0);
- union.setTypedef(newType);
- } else {
final TypeDefinitionBuilder targetTypeBuilder = findTypeDefinitionBuilder(union, dependentModuleBuilder,
- utQName.getLocalName(), module.getName(), line);
- final TypeDefinitionBuilder newType = extendedTypeWithNewBase(targetTypeBuilder, null, extType, modules,
- module, line);
- union.setTypedef(newType);
+ unknownTypeQName.getLocalName(), module.getName(), union.getLine());
+ union.setTypedef(targetTypeBuilder);
}
}
* @return TypeDefinitionBuilder of node type
*/
private static TypeDefinitionBuilder findUnknownTypeDefinition(final TypeAwareBuilder nodeToResolve,
- final ModuleBuilder dependentModuleBuilder, final Map<String, TreeMap<Date, ModuleBuilder>> modules,
+ final ModuleBuilder dependentModuleBuilder, final Map<URI, NavigableMap<Date, ModuleBuilder>> modules,
final ModuleBuilder module) {
final int line = nodeToResolve.getLine();
- final TypeDefinition<?> nodeToResolveType = nodeToResolve.getType();
- final QName unknownTypeQName = nodeToResolveType.getBaseType().getQName();
+ final QName unknownTypeQName = nodeToResolve.getTypeQName();
final TypeDefinitionBuilder targetTypeBuilder = findTypeDefinitionBuilder(nodeToResolve,
dependentModuleBuilder, unknownTypeQName.getLocalName(), module.getName(), line);
- TypeDefinitionBuilder resolvedType;
- if (nodeToResolveType instanceof ExtendedType) {
- final ExtendedType extType = (ExtendedType) nodeToResolveType;
- resolvedType = extendedTypeWithNewBase(targetTypeBuilder, null, extType, modules, module,
- nodeToResolve.getLine());
- } else {
- resolvedType = targetTypeBuilder;
- }
-
// validate constraints
final TypeConstraints constraints = findConstraintsFromTypeBuilder(nodeToResolve,
- new TypeConstraints(module.getName(), nodeToResolve.getLine()), modules, module, null);
+ new TypeConstraints(module.getName(), nodeToResolve.getLine()), modules, module);
constraints.validateConstraints();
- return resolvedType;
+ return targetTypeBuilder;
}
/**
* name of type
* @return type with given name if present in collection, null otherwise
*/
- private static TypeDefinitionBuilder findTypedefBuilderByName(Set<TypeDefinitionBuilder> types, String name) {
+ private static TypeDefinitionBuilder findTypedefBuilderByName(final Set<TypeDefinitionBuilder> types, final String name) {
for (TypeDefinitionBuilder td : types) {
if (td.getQName().getLocalName().equals(name)) {
return td;
return null;
}
- /**
- * Find type by name.
- *
- * @param types
- * collection of types
- * @param typeName
- * type name
- * @return type with given name if it is present in collection, null
- * otherwise
- */
- private static TypeDefinition<?> findTypeByName(Set<TypeDefinition<?>> types, String typeName) {
- for (TypeDefinition<?> type : types) {
- if (type.getQName().getLocalName().equals(typeName)) {
- return type;
- }
- }
- return null;
- }
-
/**
* Pull restriction from type and add them to constraints.
*
return constraints;
}
- /**
- * Create new type builder based on old type with new base type. Note: only
- * one of newBaseTypeBuilder or newBaseType can be specified.
- *
- * @param newBaseTypeBuilder
- * new base type builder or null
- * @param newBaseType
- * new base type or null
- * @param oldExtendedType
- * old type
- * @param modules
- * all loaded modules
- * @param module
- * current module
- * @param line
- * current line in module
- * @return new type builder based on old type with new base type
- */
- private static TypeDefinitionBuilder extendedTypeWithNewBase(final TypeDefinitionBuilder newBaseTypeBuilder,
- final TypeDefinition<?> newBaseType, final ExtendedType oldExtendedType,
- final Map<String, TreeMap<Date, ModuleBuilder>> modules, final ModuleBuilder module, final int line) {
- if ((newBaseTypeBuilder == null && newBaseType == null) || (newBaseTypeBuilder != null && newBaseType != null)) {
- throw new YangParseException(module.getName(), line,
- "only one of newBaseTypeBuilder or newBaseType can be specified");
- }
-
- final TypeDefinitionBuilderImpl newType = new TypeDefinitionBuilderImpl(module.getModuleName(), line,
- oldExtendedType.getQName(), oldExtendedType.getPath());
- final TypeConstraints tc = new TypeConstraints(module.getName(), line);
- TypeConstraints constraints;
- if (newBaseType == null) {
- tc.addFractionDigits(oldExtendedType.getFractionDigits());
- tc.addLengths(oldExtendedType.getLengthConstraints());
- tc.addPatterns(oldExtendedType.getPatternConstraints());
- tc.addRanges(oldExtendedType.getRangeConstraints());
- constraints = findConstraintsFromTypeBuilder(newBaseTypeBuilder, tc, modules, module, null);
- newType.setTypedef(newBaseTypeBuilder);
- } else {
- constraints = findConstraintsFromTypeDefinition(newBaseType, tc);
- newType.setType(newBaseType);
- }
-
- newType.setDescription(oldExtendedType.getDescription());
- newType.setReference(oldExtendedType.getReference());
- newType.setStatus(oldExtendedType.getStatus());
- newType.setLengths(constraints.getLength());
- newType.setPatterns(constraints.getPatterns());
- newType.setRanges(constraints.getRange());
- newType.setFractionDigits(constraints.getFractionDigits());
- newType.setUnits(oldExtendedType.getUnits());
- newType.setDefaultValue(oldExtendedType.getDefaultValue());
- return newType;
- }
-
- /**
- * Pull restrictions from type and add them to constraints.
- *
- * @param typeToResolve
- * type from which constraints will be read
- * @param constraints
- * constraints object to which constraints will be added
- * @return constraints contstraints object containing constraints from given
- * type
- */
- private static TypeConstraints findConstraintsFromTypeDefinition(final TypeDefinition<?> typeToResolve,
- final TypeConstraints constraints) {
- // union type cannot be restricted
- if (typeToResolve instanceof UnionTypeDefinition) {
- return constraints;
- }
- if (typeToResolve instanceof ExtendedType) {
- ExtendedType extType = (ExtendedType) typeToResolve;
- constraints.addFractionDigits(extType.getFractionDigits());
- constraints.addLengths(extType.getLengthConstraints());
- constraints.addPatterns(extType.getPatternConstraints());
- constraints.addRanges(extType.getRangeConstraints());
- return findConstraintsFromTypeDefinition(extType.getBaseType(), constraints);
- } else {
- mergeConstraints(typeToResolve, constraints);
- return constraints;
- }
- }
-
private static TypeConstraints findConstraintsFromTypeBuilder(final TypeAwareBuilder nodeToResolve,
- final TypeConstraints constraints, final Map<String, TreeMap<Date, ModuleBuilder>> modules,
- final ModuleBuilder builder, final SchemaContext context) {
+ final TypeConstraints constraints, final Map<URI, NavigableMap<Date, ModuleBuilder>> modules,
+ final ModuleBuilder builder) {
// union and identityref types cannot be restricted
if (nodeToResolve instanceof UnionTypeBuilder || nodeToResolve instanceof IdentityrefTypeBuilder) {
TypeDefinition<?> type = nodeToResolve.getType();
if (type == null) {
- return findConstraintsFromTypeBuilder(nodeToResolve.getTypedef(), constraints, modules, builder, context);
+ final QName unknownTypeQName = nodeToResolve.getTypeQName();
+ if (unknownTypeQName == null) {
+ return constraints;
+ }
+ final ModuleBuilder dependentModuleBuilder = BuilderUtils.findModule(unknownTypeQName, modules);
+ final TypeDefinitionBuilder targetTypeBuilder = findTypeDefinitionBuilder(nodeToResolve,
+ dependentModuleBuilder, unknownTypeQName.getLocalName(), builder.getName(), 0);
+ return findConstraintsFromTypeBuilder(targetTypeBuilder, constraints, modules, dependentModuleBuilder);
} else {
- QName qname = type.getQName();
- if (type instanceof UnknownType) {
- ModuleBuilder dependentModuleBuilder = BuilderUtils.findModuleFromBuilders(modules, builder,
- qname.getPrefix(), nodeToResolve.getLine());
- if (dependentModuleBuilder == null) {
- if (context == null) {
- throw new YangParseException(builder.getName(), nodeToResolve.getLine(),
- "Failed to resolved type constraints.");
- }
- Module dm = BuilderUtils.findModuleFromContext(context, builder, qname.getPrefix(),
- nodeToResolve.getLine());
- TypeDefinition<?> t = findTypeByName(dm.getTypeDefinitions(), qname.getLocalName());
- return mergeConstraints(t, constraints);
-
- } else {
- TypeDefinitionBuilder tdb = findTypeDefinitionBuilder(nodeToResolve, dependentModuleBuilder,
- qname.getLocalName(), builder.getName(), nodeToResolve.getLine());
- return findConstraintsFromTypeBuilder(tdb, constraints, modules, dependentModuleBuilder, context);
- }
- } else if (type instanceof ExtendedType) {
+ if (type instanceof ExtendedType) {
mergeConstraints(type, constraints);
-
- TypeDefinition<?> base = ((ExtendedType) type).getBaseType();
- if (base instanceof UnknownType) {
- ModuleBuilder dependentModule = BuilderUtils.findModuleFromBuilders(modules, builder, base
- .getQName().getPrefix(), nodeToResolve.getLine());
- TypeDefinitionBuilder tdb = findTypeDefinitionBuilder(nodeToResolve, dependentModule, base
- .getQName().getLocalName(), builder.getName(), nodeToResolve.getLine());
- return findConstraintsFromTypeBuilder(tdb, constraints, modules, dependentModule, context);
- } else {
- // it has to be base yang type
- return mergeConstraints(type, constraints);
- }
+ // it has to be base yang type
+ return mergeConstraints(type, constraints);
} else {
// it is base yang type
return mergeConstraints(type, constraints);
Code Review / yangtools.git / blobdiff