*/\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
import java.util.ArrayList;
import java.util.Collections;
-import java.util.HashSet;
import java.util.List;
import java.util.Set;
private final IdentitySchemaNodeImpl instance;
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.setBaseIdentity(baseIdentity);
}
- instance.setDerivedIdentities(derivedIdentities);
-
// UNKNOWN NODES
if (unknownNodes == null) {
unknownNodes = new ArrayList<>();
this.baseIdentity = baseType;
}
- public void addDerivedIdentity(IdentitySchemaNode derived) {
- derivedIdentities.add(derived);
- }
-
@Override
public String toString() {
return "identity " + qname.getLocalName();
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;
for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
for (Map.Entry<Date, ModuleBuilder> childEntry : entry.getValue().entrySet()) {
final ModuleBuilder module = childEntry.getValue();
+ resolveUnknownNodes(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();
+ resolveUnknownNodesWithContext(modules, module, context);
resolveIdentitiesWithContext(modules, module, context);
resolveDirtyNodesWithContext(modules, module, context);
- resolveUnknownNodesWithContext(modules, module, context);
}
}
}
throw new YangParseException(module.getName(), identity.getLine(), "Failed to find base identity");
} else {
identity.setBaseIdentity(baseIdentity);
- IdentitySchemaNode built = identity.build();
- baseIdentity.addDerivedIdentity(built);
}
}
}
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 {
identity.setBaseIdentity(baseIdentity);
- IdentitySchemaNode built = identity.build();
- baseIdentity.addDerivedIdentity(built);
}
}
}
assertNotNull(cryptoAlg);
IdentitySchemaNode baseIdentity = cryptoAlg.getBaseIdentity();
assertEquals("crypto-base", baseIdentity.getQName().getLocalName());
- assertTrue(cryptoAlg.getDerivedIdentities().isEmpty());
+ //assertTrue(cryptoAlg.getDerivedIdentities().isEmpty());
assertNull(baseIdentity.getBaseIdentity());
assertNotNull(cryptoBase);
baseIdentity = cryptoAlg.getBaseIdentity();
assertNull(cryptoBase.getBaseIdentity());
- assertEquals(3, cryptoBase.getDerivedIdentities().size());
+ //assertEquals(3, cryptoBase.getDerivedIdentities().size());
}
@Test