import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
+import java.util.Set;
import org.opendaylight.controller.yang.common.QName;
import org.opendaylight.controller.yang.model.api.ModuleImport;
import org.opendaylight.controller.yang.model.api.type.InstanceIdentifierTypeDefinition;
import org.opendaylight.controller.yang.model.api.type.IntegerTypeDefinition;
import org.opendaylight.controller.yang.model.api.type.LeafrefTypeDefinition;
+import org.opendaylight.controller.yang.model.api.type.LengthConstraint;
+import org.opendaylight.controller.yang.model.api.type.PatternConstraint;
+import org.opendaylight.controller.yang.model.api.type.RangeConstraint;
import org.opendaylight.controller.yang.model.api.type.StringTypeDefinition;
import org.opendaylight.controller.yang.model.api.type.UnionTypeDefinition;
import org.opendaylight.controller.yang.model.api.type.UnsignedIntegerTypeDefinition;
/**
* Get module import referenced by given prefix.
- *
+ *
* @param builder
* module to search
* @param prefix
/**
* Parse uses path.
- *
+ *
* @param usesPath
* as String
* @return SchemaPath from given String
/**
* Add all augment's child nodes to given target.
- *
+ *
* @param augment
* @param target
*/
final DataNodeContainerBuilder target) {
for (DataSchemaNodeBuilder builder : augment.getChildNodes()) {
builder.setAugmenting(true);
- correctAugmentChildPath(augment, target.getPath());
+ correctAugmentChildPath(builder, target.getPath());
target.addChildNode(builder);
}
}
public static void fillAugmentTarget(
- final AugmentationSchemaBuilder augment,
- final ChoiceBuilder target) {
+ final AugmentationSchemaBuilder augment, final ChoiceBuilder target) {
for (DataSchemaNodeBuilder builder : augment.getChildNodes()) {
builder.setAugmenting(true);
- correctAugmentChildPath(augment, target.getPath());
+ correctAugmentChildPath(builder, target.getPath());
target.addChildNode(builder);
}
}
- private static void correctAugmentChildPath(final DataNodeContainerBuilder node,
+ private static void correctAugmentChildPath(
+ final DataSchemaNodeBuilder childNode,
final SchemaPath parentSchemaPath) {
- for (DataSchemaNodeBuilder builder : node.getChildNodes()) {
-
- // add correct path
- List<QName> targetNodePath = new ArrayList<QName>(
- parentSchemaPath.getPath());
- targetNodePath.add(builder.getQName());
- builder.setPath(new SchemaPath(targetNodePath, true));
- if (builder instanceof DataNodeContainerBuilder) {
- DataNodeContainerBuilder cnb = (DataNodeContainerBuilder) builder;
- correctAugmentChildPath(cnb, builder.getPath());
+ // set correct path
+ List<QName> targetNodePath = new ArrayList<QName>(
+ parentSchemaPath.getPath());
+ targetNodePath.add(childNode.getQName());
+ childNode.setPath(new SchemaPath(targetNodePath, true));
+
+ // set correct path for all child nodes
+ if (childNode instanceof DataNodeContainerBuilder) {
+ DataNodeContainerBuilder dataNodeContainer = (DataNodeContainerBuilder) childNode;
+ for (DataSchemaNodeBuilder child : dataNodeContainer
+ .getChildNodes()) {
+ correctAugmentChildPath(child, childNode.getPath());
}
+ }
- // if child can contains type, correct path for this type too
- if (builder instanceof TypeAwareBuilder) {
- TypeAwareBuilder nodeBuilder = (TypeAwareBuilder) builder;
- QName nodeBuilderQName = nodeBuilder.getQName();
- TypeDefinition<?> nodeBuilderType = nodeBuilder.getType();
- if (nodeBuilderType != null) {
- TypeDefinition<?> newType = createCorrectTypeDefinition(
- parentSchemaPath, nodeBuilderQName, nodeBuilderType);
- nodeBuilder.setType(newType);
- } else {
- TypeDefinitionBuilder nodeBuilderTypedef = nodeBuilder
- .getTypedef();
- SchemaPath newSchemaPath = createNewSchemaPath(
- nodeBuilderTypedef.getPath(), nodeBuilderQName,
- nodeBuilderTypedef.getQName());
- nodeBuilderTypedef.setPath(newSchemaPath);
+ // if node can contains type, correct path for this type too
+ if (childNode instanceof TypeAwareBuilder) {
+ TypeAwareBuilder nodeBuilder = (TypeAwareBuilder) childNode;
+ correctTypeAwareNodePath(nodeBuilder, parentSchemaPath);
+ }
+ }
+
+ /**
+ * Repair schema path of node type.
+ *
+ * @param node
+ * node which contains type statement
+ * @param parentSchemaPath
+ * schema path of parent node
+ */
+ private static void correctTypeAwareNodePath(
+ TypeAwareBuilder node, SchemaPath parentSchemaPath) {
+ final QName nodeBuilderQName = node.getQName();
+ final TypeDefinition<?> nodeType = node.getType();
+
+ Integer fd = null;
+ List<LengthConstraint> lengths = null;
+ List<PatternConstraint> patterns = null;
+ List<RangeConstraint> ranges = null;
+
+ if (nodeType != null) {
+ if (nodeType instanceof ExtendedType) {
+ ExtendedType et = (ExtendedType) nodeType;
+ if (nodeType
+ .getQName()
+ .getLocalName()
+ .equals(nodeType.getBaseType().getQName()
+ .getLocalName())) {
+ fd = et.getFractionDigits();
+ lengths = et.getLengths();
+ patterns = et.getPatterns();
+ ranges = et.getRanges();
+ if (!hasConstraints(fd, lengths, patterns, ranges)) {
+ return;
+ }
}
}
+ TypeDefinition<?> newType = createCorrectTypeDefinition(
+ parentSchemaPath, nodeBuilderQName, nodeType);
+ node.setType(newType);
+ } else {
+ TypeDefinitionBuilder nodeBuilderTypedef = node.getTypedef();
+
+ fd = nodeBuilderTypedef.getFractionDigits();
+ lengths = nodeBuilderTypedef.getLengths();
+ patterns = nodeBuilderTypedef.getPatterns();
+ ranges = nodeBuilderTypedef.getRanges();
+
+ String tdbTypeName = nodeBuilderTypedef.getQName().getLocalName();
+ String baseTypeName = null;
+ if (nodeBuilderTypedef.getType() == null) {
+ baseTypeName = nodeBuilderTypedef.getTypedef().getQName()
+ .getLocalName();
+ } else {
+ baseTypeName = nodeBuilderTypedef.getType().getQName()
+ .getLocalName();
+ }
+ if (!(tdbTypeName.equals(baseTypeName))) {
+ return;
+ }
+
+ if (!hasConstraints(fd, lengths, patterns, ranges)) {
+ return;
+ }
+
+ SchemaPath newSchemaPath = createNewSchemaPath(
+ nodeBuilderTypedef.getPath(), nodeBuilderQName,
+ nodeBuilderTypedef.getQName());
+ nodeBuilderTypedef.setPath(newSchemaPath);
+ }
+ }
+
+ /**
+ * Check if there are some constraints.
+ *
+ * @param fd
+ * fraction digits
+ * @param lengths
+ * length constraints
+ * @param patterns
+ * pattern constraints
+ * @param ranges
+ * range constraints
+ * @return true, if any of constraints are present, false otherwise
+ */
+ private static boolean hasConstraints(final Integer fd,
+ final List<LengthConstraint> lengths,
+ final List<PatternConstraint> patterns,
+ final List<RangeConstraint> ranges) {
+ if (fd == null && (lengths == null || lengths.isEmpty())
+ && (patterns == null || patterns.isEmpty())
+ && (ranges == null || ranges.isEmpty())) {
+ return false;
+ } else {
+ return true;
}
}
DecimalTypeDefinition decimalType = (DecimalTypeDefinition) nodeType;
newSchemaPath = createNewSchemaPath(parentSchemaPath,
nodeQName, decimalType.getQName());
- result = new Decimal64(newSchemaPath, decimalType.getFractionDigits());
+ result = new Decimal64(newSchemaPath,
+ decimalType.getFractionDigits());
} else if (nodeType instanceof EmptyTypeDefinition) {
newSchemaPath = createNewSchemaPath(parentSchemaPath,
nodeQName, nodeType.getQName());
newSchemaPath = createNewSchemaPath(parentSchemaPath,
nodeQName, unionType.getQName());
return new UnionType(newSchemaPath, unionType.getTypes());
- } else if(nodeType instanceof ExtendedType) {
- ExtendedType extType = (ExtendedType)nodeType;
+ } else if (nodeType instanceof ExtendedType) {
+ ExtendedType extType = (ExtendedType) nodeType;
newSchemaPath = createNewSchemaPath(parentSchemaPath,
nodeQName, extType.getQName());
result = createNewExtendedType(newSchemaPath, extType);
TypeDefinition<?> baseType = oldExtendedType.getBaseType();
String desc = oldExtendedType.getDescription();
String ref = oldExtendedType.getReference();
- ExtendedType.Builder builder = new ExtendedType.Builder(qname, baseType, desc, ref, newSchemaPath);
+ ExtendedType.Builder builder = new ExtendedType.Builder(qname,
+ baseType, desc, ref, newSchemaPath);
builder.status(oldExtendedType.getStatus());
builder.lengths(oldExtendedType.getLengths());
builder.patterns(oldExtendedType.getPatterns());
* <li>reference</li>
* <li>config</li>
* </ul>
- *
+ *
* These parameters may be refined for any node.
- *
+ *
* @param node
* node to refine
* @param refine
Leafref ifcIdType = (Leafref) ifcId.getType();
SchemaPath ifcIdTypeSchemaPath = ifcIdType.getPath();
List<QName> ifcIdTypePath = ifcIdTypeSchemaPath.getPath();
- QName q0 = new QName(new URI("urn:simple.types.data.demo"),
- simpleDateFormat.parse("2013-02-27"), "data", "interfaces");
- QName q1 = new QName(new URI("urn:simple.types.data.demo"),
- simpleDateFormat.parse("2013-02-27"), "data", "ifEntry");
- QName q2 = new QName(new URI("urn:simple.container.demo.test"),
- simpleDateFormat.parse("2013-02-27"), "data", "augment-holder");
- QName q3 = new QName(new URI("urn:simple.container.demo"),
- simpleDateFormat.parse("2013-02-27"), "data", "interface-id");
+
+ URI types1URI = URI.create("urn:simple.container.demo");
+ URI types2URI = URI.create("urn:simple.types.data.demo");
+ URI types3URI = URI.create("urn:simple.container.demo.test");
+ Date expectedDate = simpleDateFormat.parse("2013-02-27");
+
+ QName q0 = new QName(types2URI,
+ expectedDate, "data", "interfaces");
+ QName q1 = new QName(types2URI,
+ expectedDate, "data", "ifEntry");
+ QName q2 = new QName(types3URI,
+ expectedDate, "data", "augment-holder");
+ QName q3 = new QName(types1URI,
+ expectedDate, "data", "interface-id");
assertEquals(q0, ifcIdTypePath.get(0));
assertEquals(q1, ifcIdTypePath.get(1));
assertEquals(q2, ifcIdTypePath.get(2));
assertEquals(q0, higherLayerTypePath.get(0));
assertEquals(q1, higherLayerTypePath.get(1));
assertEquals(q2, higherLayerTypePath.get(2));
- q3 = new QName(new URI("urn:simple.container.demo"),
- simpleDateFormat.parse("2013-02-27"), "data", "higher-layer-if");
+ q3 = new QName(types1URI,
+ expectedDate, "data", "higher-layer-if");
assertEquals(q3, higherLayerTypePath.get(3));
+
+ LeafSchemaNode myType = (LeafSchemaNode) augment
+ .getDataChildByName("my-type");
+ ExtendedType leafType = (ExtendedType)myType.getType();
+
+ testModule = TestUtils.findModule(modules, "types2");
+ TypeDefinition<?> typedef = TestUtils.findTypedef(testModule.getTypeDefinitions(), "my-type1");
+
+ assertEquals(typedef, leafType);
}
@Test