* <code>idref</code>
*/
private Type provideTypeForIdentityref(IdentityrefTypeDefinition idref) {
- QName baseIdQName = idref.getIdentity();
+ QName baseIdQName = idref.getIdentity().getQName();
Module module = schemaContext.findModuleByNamespaceAndRevision(baseIdQName.getNamespace(),
baseIdQName.getRevision());
IdentitySchemaNode identity = null;
*/\r
package org.opendaylight.yangtools.yang.model.api;\r
\r
+import java.util.Set;\r
+\r
/**\r
* Interface describing YANG 'identity' statement.\r
* <p>\r
*/\r
IdentitySchemaNode getBaseIdentity();\r
\r
+ /**\r
+ * Get identities derived from this identity.\r
+ * \r
+ * @return collection of identities derived from this identity\r
+ */\r
+ Set<IdentitySchemaNode> getDerivedIdentities();\r
+\r
}\r
*/
package org.opendaylight.yangtools.yang.model.api.type;
-import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
/**
public interface IdentityrefTypeDefinition extends TypeDefinition<IdentityrefTypeDefinition> {
/**
- * Returns QName of the identity to which the instance of this type refers.
+ * Returns identity to which the instance of this type refers.
*
- * @return QName of referenced identity which is specified with the
- * <code>identity</code> YANG statement
+ * @return identity which is specified with the <code>identity</code> YANG
+ * statement
*/
- QName getIdentity();
+ IdentitySchemaNode getIdentity();
}
import java.util.List;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
private final SchemaPath path;
private static final String DESCRIPTION = "The identityref type is used to reference an existing identity.";
private static final String REFERENCE = "https://tools.ietf.org/html/rfc6020#section-9.10";
- private final QName identity;
+ private final IdentitySchemaNode identity;
private static final String UNITS = "";
- public IdentityrefType(QName identity, SchemaPath schemaPath) {
+ public IdentityrefType(IdentitySchemaNode identity, SchemaPath schemaPath) {
this.identity = identity;
this.path = schemaPath;
}
}
@Override
- public QName getIdentity() {
+ public IdentitySchemaNode getIdentity() {
return identity;
}
@Override
public String toString() {
- return "identityref " + identity.getLocalName();
+ return "identityref " + identity.getQName().getLocalName();
}
}
import java.util.ArrayList;
import java.util.Collections;
+import java.util.HashSet;
import java.util.List;
+import java.util.Set;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
public final class IdentitySchemaNodeBuilder extends AbstractSchemaNodeBuilder {
private boolean isBuilt;
private final IdentitySchemaNodeImpl instance;
- private IdentitySchemaNodeBuilder baseIdentityBuilder;
private IdentitySchemaNode baseIdentity;
+ private IdentitySchemaNodeBuilder baseIdentityBuilder;
+ private final Set<IdentitySchemaNode> derivedIdentities = new HashSet<>();
private String baseIdentityName;
IdentitySchemaNodeBuilder(final String moduleName, final int line, final QName qname) {
instance.setReference(reference);
instance.setStatus(status);
- if (baseIdentity == null) {
- if (baseIdentityBuilder != null) {
- instance.setBaseIdentity(baseIdentityBuilder.build());
- }
- } else {
+ if (baseIdentity == null && baseIdentityBuilder != null) {
+ baseIdentity = baseIdentityBuilder.build();
+ }
+ if (baseIdentity != null) {
instance.setBaseIdentity(baseIdentity);
}
+ instance.setDerivedIdentities(derivedIdentities);
+
// UNKNOWN NODES
if (unknownNodes == null) {
- unknownNodes = new ArrayList<UnknownSchemaNode>();
+ unknownNodes = new ArrayList<>();
for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
unknownNodes.add(b.build());
}
this.baseIdentity = baseType;
}
+ public void addDerivedIdentity(IdentitySchemaNode derived) {
+ derivedIdentities.add(derived);
+ }
+
@Override
public String toString() {
return "identity " + qname.getLocalName();
}
- private final class IdentitySchemaNodeImpl implements IdentitySchemaNode {
+ public final class IdentitySchemaNodeImpl implements IdentitySchemaNode {
private final QName qname;
private IdentitySchemaNode baseIdentity;
+ private Set<IdentitySchemaNode> derivedIdentities = Collections.emptySet();
private String description;
private String reference;
private Status status = Status.CURRENT;
this.baseIdentity = baseIdentity;
}
+ @Override
+ public Set<IdentitySchemaNode> getDerivedIdentities() {
+ return derivedIdentities;
+ }
+
+ private void setDerivedIdentities(Set<IdentitySchemaNode> derivedIdentities) {
+ if (derivedIdentities != null) {
+ this.derivedIdentities = derivedIdentities;
+ }
+ }
+
@Override
public String getDescription() {
return description;
}
}
+ public IdentitySchemaNodeBuilder toBuilder() {
+ return IdentitySchemaNodeBuilder.this;
+ }
+
@Override
public int hashCode() {
final int prime = 31;
private final String baseString;
private final SchemaPath schemaPath;
- private QName baseQName;
+ private IdentitySchemaNodeBuilder baseIdentity;
public IdentityrefTypeBuilder(final String moduleName, final int line, final String baseString,
final SchemaPath schemaPath) {
@Override
public IdentityrefType build() {
- return new IdentityrefType(baseQName, schemaPath);
+ return new IdentityrefType(baseIdentity.build(), schemaPath);
}
public String getBaseString() {
return baseString;
}
- public void setBaseQName(QName baseQName) {
- this.baseQName = baseQName;
+ public void setBaseIdentity(IdentitySchemaNodeBuilder baseIdentity) {
+ this.baseIdentity = baseIdentity;
}
@Override
final StringBuilder result = new StringBuilder(IdentityrefTypeBuilder.class.getSimpleName());
result.append("[");
result.append(", base=");
- result.append(baseQName);
+ result.append(baseIdentity);
result.append("]");
return result.toString();
}
List<ModuleBuilder> sorted = ModuleDependencySort.sort(builders);
final LinkedHashMap<String, TreeMap<Date, ModuleBuilder>> modules = orderModules(sorted);
- return new LinkedHashSet<>(buildWithContext(modules, null).values());
+ return new LinkedHashSet<>(build(modules).values());
}
@Override
for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
for (Map.Entry<Date, ModuleBuilder> childEntry : entry.getValue().entrySet()) {
final ModuleBuilder module = childEntry.getValue();
- resolveDirtyNodes(modules, module);
resolveIdentities(modules, module);
+ resolveDirtyNodes(modules, module);
resolveUnknownNodes(modules, module);
}
}
for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
for (Map.Entry<Date, ModuleBuilder> childEntry : entry.getValue().entrySet()) {
final ModuleBuilder module = childEntry.getValue();
- resolveDirtyNodesWithContext(modules, module, context);
resolveIdentitiesWithContext(modules, module, context);
+ resolveDirtyNodesWithContext(modules, module, context);
resolveUnknownNodesWithContext(modules, module, context);
}
}
} else if (nodeToResolve.getTypedef() instanceof IdentityrefTypeBuilder) {
// special handling for identityref types
IdentityrefTypeBuilder idref = (IdentityrefTypeBuilder) nodeToResolve.getTypedef();
- nodeToResolve.setType(new IdentityrefType(findFullQName(modules, module, idref), idref.getPath()));
+ IdentitySchemaNodeBuilder identity = findBaseIdentity(modules, module, idref.getBaseString(),
+ idref.getLine());
+ if (identity == null) {
+ throw new YangParseException(module.getName(), idref.getLine(), "Failed to find base identity");
+ }
+ idref.setBaseIdentity(identity);
+ nodeToResolve.setType(idref.build());
} else {
resolveType(nodeToResolve, modules, module);
}
} else if (nodeToResolve.getTypedef() instanceof IdentityrefTypeBuilder) {
// special handling for identityref types
IdentityrefTypeBuilder idref = (IdentityrefTypeBuilder) nodeToResolve.getTypedef();
- nodeToResolve.setType(new IdentityrefType(findFullQName(modules, module, idref), idref.getPath()));
+ IdentitySchemaNodeBuilder identity = findBaseIdentity(modules, module, idref.getBaseString(),
+ idref.getLine());
+ idref.setBaseIdentity(identity);
+ nodeToResolve.setType(idref.build());
} else {
resolveTypeWithContext(nodeToResolve, modules, module, context);
}
final Set<IdentitySchemaNodeBuilder> identities = module.getIdentities();
for (IdentitySchemaNodeBuilder identity : identities) {
final String baseIdentityName = identity.getBaseIdentityName();
+ final int line = identity.getLine();
if (baseIdentityName != null) {
- String baseIdentityPrefix;
- String baseIdentityLocalName;
- if (baseIdentityName.contains(":")) {
- final String[] splitted = baseIdentityName.split(":");
- baseIdentityPrefix = splitted[0];
- baseIdentityLocalName = splitted[1];
- } else {
- baseIdentityPrefix = module.getPrefix();
- baseIdentityLocalName = baseIdentityName;
- }
- final ModuleBuilder dependentModule = findModuleFromBuilders(modules, module, baseIdentityPrefix,
- identity.getLine());
-
- IdentitySchemaNodeBuilder baseIdentity = null;
- final Set<IdentitySchemaNodeBuilder> dependentModuleIdentities = dependentModule.getIdentities();
- for (IdentitySchemaNodeBuilder idBuilder : dependentModuleIdentities) {
- if (idBuilder.getQName().getLocalName().equals(baseIdentityLocalName)) {
- baseIdentity = idBuilder;
- break;
- }
- }
+ IdentitySchemaNodeBuilder baseIdentity = findBaseIdentity(modules, module, baseIdentityName, line);
if (baseIdentity == null) {
- throw new YangParseException(module.getName(), identity.getLine(),
- "Base identity " + baseIdentityName + " not found");
+ throw new YangParseException(module.getName(), identity.getLine(), "Failed to find base identity");
} else {
identity.setBaseIdentity(baseIdentity);
+ IdentitySchemaNode built = identity.build();
+ baseIdentity.addDerivedIdentity(built);
}
-
}
}
}
final Set<IdentitySchemaNodeBuilder> identities = module.getIdentities();
for (IdentitySchemaNodeBuilder identity : identities) {
final String baseIdentityName = identity.getBaseIdentityName();
+ final int line = identity.getLine();
if (baseIdentityName != null) {
- String baseIdentityPrefix;
- String baseIdentityLocalName;
- if (baseIdentityName.contains(":")) {
- final String[] splitted = baseIdentityName.split(":");
- baseIdentityPrefix = splitted[0];
- baseIdentityLocalName = splitted[1];
- } else {
- baseIdentityPrefix = module.getPrefix();
- baseIdentityLocalName = baseIdentityName;
- }
- final ModuleBuilder dependentModuleBuilder = findModuleFromBuilders(modules, module,
- baseIdentityPrefix, identity.getLine());
-
- if (dependentModuleBuilder == null) {
- final Module dependentModule = findModuleFromContext(context, module, baseIdentityPrefix,
- identity.getLine());
- final Set<IdentitySchemaNode> dependentModuleIdentities = dependentModule.getIdentities();
- for (IdentitySchemaNode idNode : dependentModuleIdentities) {
- if (idNode.getQName().getLocalName().equals(baseIdentityLocalName)) {
- identity.setBaseIdentity(idNode);
- }
+ IdentitySchemaNodeBuilder baseIdentity = findBaseIdentity(modules, module, baseIdentityName, line);
+ if (baseIdentity == null) {
+ IdentitySchemaNode baseId = findBaseIdentityFromContext(modules, module, baseIdentityName, line,
+ context);
+ identity.setBaseIdentity(baseId);
+ IdentitySchemaNode built = identity.build();
+ if (baseId instanceof IdentitySchemaNodeBuilder.IdentitySchemaNodeImpl) {
+ ((IdentitySchemaNodeBuilder.IdentitySchemaNodeImpl) baseId).toBuilder().addDerivedIdentity(
+ built);
}
} else {
- final Set<IdentitySchemaNodeBuilder> dependentModuleIdentities = dependentModuleBuilder
- .getIdentities();
- for (IdentitySchemaNodeBuilder idBuilder : dependentModuleIdentities) {
- if (idBuilder.getQName().getLocalName().equals(baseIdentityLocalName)) {
- identity.setBaseIdentity(idBuilder);
- }
- }
+ identity.setBaseIdentity(baseIdentity);
+ IdentitySchemaNode built = identity.build();
+ baseIdentity.addDerivedIdentity(built);
}
}
}
*/
public static void performRefine(UsesNodeBuilder usesNode) {
for (RefineHolder refine : usesNode.getRefines()) {
- DataSchemaNodeBuilder nodeToRefine = null;
- for (DataSchemaNodeBuilder dataNode : usesNode.getParent().getChildNodeBuilders()) {
- if (refine.getName().equals(dataNode.getQName().getLocalName())) {
- nodeToRefine = dataNode;
- break;
+ String refineTargetPath = refine.getName();
+
+ String[] splitted = refineTargetPath.split("/");
+ Builder currentNode = usesNode.getParent();
+ for (String pathElement : splitted) {
+ if (currentNode instanceof DataNodeContainerBuilder) {
+ currentNode = ((DataNodeContainerBuilder) currentNode).getDataChildByName(pathElement);
+ } else if (currentNode instanceof ChoiceBuilder) {
+ currentNode = ((ChoiceBuilder) currentNode).getCaseNodeByName(pathElement);
}
}
+
+ DataSchemaNodeBuilder nodeToRefine = (DataSchemaNodeBuilder) currentNode;
if (nodeToRefine == null) {
throw new YangParseException(refine.getModuleName(), refine.getLine(), "Refine target node '"
+ refine.getName() + "' not found");
import java.util.Date;
import java.util.List;
import java.util.Map;
+import java.util.Set;
import java.util.TreeMap;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
+import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.ModuleImport;
import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceCaseBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceCaseBuilder.ChoiceCaseNodeImpl;
import org.opendaylight.yangtools.yang.parser.builder.impl.ContainerSchemaNodeBuilder.ContainerSchemaNodeImpl;
-import org.opendaylight.yangtools.yang.parser.builder.impl.IdentityrefTypeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.impl.IdentitySchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.ListSchemaNodeBuilder.ListSchemaNodeImpl;
import org.opendaylight.yangtools.yang.parser.builder.impl.ModuleBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.NotificationBuilder.NotificationDefinitionImpl;
return true;
}
- public static def QName findFullQName(Map<String, TreeMap<Date, ModuleBuilder>> modules,
- ModuleBuilder module, IdentityrefTypeBuilder idref) {
- var QName result = null;
- val String baseString = idref.getBaseString();
- if (baseString.contains(":")) {
- val String[] splittedBase = baseString.split(":");
- if (splittedBase.length > 2) {
- throw new YangParseException(module.getName(), idref.getLine(),
- "Failed to parse identityref base: " + baseString);
- }
- val prefix = splittedBase.get(0);
- val name = splittedBase.get(1);
- val dependentModule = findModuleFromBuilders(modules, module, prefix, idref.getLine());
- result = new QName(dependentModule.getNamespace(), dependentModule.getRevision(), prefix, name);
- } else {
- result = new QName(module.getNamespace(), module.getRevision(), module.getPrefix(), baseString);
+ public static def IdentitySchemaNodeBuilder findBaseIdentity(Map<String, TreeMap<Date, ModuleBuilder>> modules,
+ ModuleBuilder module, String baseString, int line) {
+ var IdentitySchemaNodeBuilder result = null;
+ if (baseString.contains(":")) {
+ val String[] splittedBase = baseString.split(":");
+ if (splittedBase.length > 2) {
+ throw new YangParseException(module.getName(), line, "Failed to parse identityref base: " +
+ baseString);
+ }
+ val prefix = splittedBase.get(0);
+ val name = splittedBase.get(1);
+ val dependentModule = findModuleFromBuilders(modules, module, prefix, line);
+ if (dependentModule !== null) {
+ result = findIdentity(dependentModule.identities, name);
+ }
+ } else {
+ result = findIdentity(module.identities, baseString);
+ }
+ return result;
+ }
+
+ public static def IdentitySchemaNode findBaseIdentityFromContext(Map<String, TreeMap<Date, ModuleBuilder>> modules,
+ ModuleBuilder module, String baseString, int line, SchemaContext context) {
+ var IdentitySchemaNode result = null;
+
+ val String[] splittedBase = baseString.split(":");
+ if (splittedBase.length > 2) {
+ throw new YangParseException(module.getName(), line, "Failed to parse identityref base: " + baseString);
+ }
+ val prefix = splittedBase.get(0);
+ val name = splittedBase.get(1);
+ val dependentModule = findModuleFromContext(context, module, prefix, line);
+ result = findIdentityNode(dependentModule.identities, name);
+
+ if (result == null) {
+ throw new YangParseException(module.name, line, "Failed to find base identity");
+ }
+ return result;
+ }
+
+ private static def IdentitySchemaNodeBuilder findIdentity(Set<IdentitySchemaNodeBuilder> identities, String name) {
+ for (identity : identities) {
+ if (identity.QName.localName.equals(name)) {
+ return identity;
}
- return result;
}
+ return null;
+ }
+
+ private static def IdentitySchemaNode findIdentityNode(Set<IdentitySchemaNode> identities, String name) {
+ for (identity : identities) {
+ if (identity.QName.localName.equals(name)) {
+ return identity;
+ }
+ }
+ return null;
+ }
/**
* Get module in which this node is defined.
*/
@Override
public void enterRefine_stmt(Refine_stmtContext ctx) {
- BasicValidations.checkIdentifier(ctx);
+ BasicValidations.checkSchemaNodeIdentifier(ctx);
}
/**
assertEquals(1, usesNodes.size());
UsesNode usesNode = usesNodes.iterator().next();
Map<SchemaPath, SchemaNode> refines = usesNode.getRefines();
- assertEquals(3, refines.size());
+ assertEquals(4, refines.size());
LeafSchemaNode refineLeaf = null;
ContainerSchemaNode refineContainer = null;
ListSchemaNode refineList = null;
+ LeafSchemaNode refineInnerLeaf = null;
for (Map.Entry<SchemaPath, SchemaNode> entry : refines.entrySet()) {
SchemaNode value = entry.getValue();
- if (value instanceof LeafSchemaNode) {
+ if ("address".equals(value.getQName().getLocalName())) {
refineLeaf = (LeafSchemaNode) value;
- } else if (value instanceof ContainerSchemaNode) {
+ } else if ("port".equals(value.getQName().getLocalName())) {
refineContainer = (ContainerSchemaNode) value;
- } else if (value instanceof ListSchemaNode) {
+ } else if ("addresses".equals(value.getQName().getLocalName())) {
refineList = (ListSchemaNode) value;
+ } else if ("id".equals(value.getQName().getLocalName())) {
+ refineInnerLeaf = (LeafSchemaNode)value;
}
}
// leaf address
assertNotNull(refineLeaf);
- assertEquals("address", refineLeaf.getQName().getLocalName());
assertEquals("IP address of target node", refineLeaf.getDescription());
assertEquals("address reference added by refine", refineLeaf.getReference());
assertFalse(refineLeaf.isConfiguration());
MustDefinition leafMust = leafMustConstraints.iterator().next();
assertEquals("\"ifType != 'ethernet' or (ifType = 'ethernet' and ifMTU = 1500)\"", leafMust.toString());
+
// container port
assertNotNull(refineContainer);
Set<MustDefinition> mustConstraints = refineContainer.getConstraints().getMustConstraints();
assertFalse(refineList.isConfiguration());
assertEquals(2, (int) refineList.getConstraints().getMinElements());
assertEquals(12, (int) refineList.getConstraints().getMaxElements());
+
+ // leaf id
+ assertNotNull(refineInnerLeaf);
+ assertEquals("id of address", refineInnerLeaf.getDescription());
}
@Test
import java.io.File;
import java.io.FileNotFoundException;
import java.net.URI;
-import java.util.ArrayList;
import java.util.List;
import java.util.Set;
public void testIdentity() {
Module tested = TestUtils.findModule(testedModules, "custom-types-test");
Set<IdentitySchemaNode> identities = tested.getIdentities();
- IdentitySchemaNode testedIdentity = null;
+ assertEquals(5, identities.size());
+ IdentitySchemaNode cryptoAlg = null;
+ IdentitySchemaNode cryptoBase = null;
for (IdentitySchemaNode id : identities) {
if (id.getQName().getLocalName().equals("crypto-alg")) {
- testedIdentity = id;
- IdentitySchemaNode baseIdentity = id.getBaseIdentity();
- assertEquals("crypto-base", baseIdentity.getQName().getLocalName());
- assertNull(baseIdentity.getBaseIdentity());
+ cryptoAlg = id;
+ } else if ("crypto-base".equals(id.getQName().getLocalName())) {
+ cryptoBase = id;
}
}
- assertNotNull(testedIdentity);
+ assertNotNull(cryptoAlg);
+ IdentitySchemaNode baseIdentity = cryptoAlg.getBaseIdentity();
+ assertEquals("crypto-base", baseIdentity.getQName().getLocalName());
+ assertTrue(cryptoAlg.getDerivedIdentities().isEmpty());
+ assertNull(baseIdentity.getBaseIdentity());
+
+
+ assertNotNull(cryptoBase);
+ baseIdentity = cryptoAlg.getBaseIdentity();
+ assertNull(cryptoBase.getBaseIdentity());
+ assertEquals(3, cryptoBase.getDerivedIdentities().size());
}
@Test
Set<TypeDefinition<?>> typedefs = tested.getTypeDefinitions();
TypeDefinition<?> testedType = TestUtils.findTypedef(typedefs, "service-type-ref");
IdentityrefType baseType = (IdentityrefType) testedType.getBaseType();
- QName identity = baseType.getIdentity();
+ QName identity = baseType.getIdentity().getQName();
assertEquals(URI.create("urn:custom.types.demo"), identity.getNamespace());
assertEquals(TestUtils.createDate("2012-04-16"), identity.getRevision());
assertEquals("iit", identity.getPrefix());
config false;
presence "presence is required";
}
- refine addresses {
+ refine "addresses" {
description "description of addresses defined by refine";
reference "addresses reference added by refine";
config false;
min-elements 2;
max-elements 12;
}
+ refine addresses/id {
+ description "id of address";
+ }
}
}
}
type service-type-ref;
}
+ identity crypto-id {
+ base "crypto-base";
+ description "crypto-id description";
+ }
+
identity crypto-base {
description "crypto-base description";
}
description "crypto-alg description";
}
+ identity crypto-def {
+ base "crypto-base";
+ description "crypto-def description";
+ }
+
leaf mybits {
type bits {
bit disable-nagle {
Code Review / yangtools.git / commitdiff