import org.opendaylight.yangtools.yang.binding.util.BindingReflections;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifierWithPredicates;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.Node;
import org.opendaylight.yangtools.yang.data.impl.CompositeNodeTOImpl;
import org.opendaylight.yangtools.yang.data.impl.SimpleNodeTOImpl;
@Override
public InstanceIdentifier<? extends Object> deserialize(
- final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier input) {
+ final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier input) {
Class<?> baType = null;
- List<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument> biArgs = input.getPath();
+ List<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument> biArgs = input.getPath();
List<QName> scannedPath = new ArrayList<>(biArgs.size());
List<InstanceIdentifier.PathArgument> baArgs = new ArrayList<InstanceIdentifier.PathArgument>(biArgs.size());
- for (org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument biArg : biArgs) {
+ for (org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument biArg : biArgs) {
scannedPath.add(biArg.getNodeType());
org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument baArg = deserializePathArgument(
@Override
public InstanceIdentifier<? extends Object> deserialize(
- final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier input,
+ final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier input,
final InstanceIdentifier<?> bindingIdentifier) {
return deserialize(input);
}
}
@Override
- public org.opendaylight.yangtools.yang.data.api.InstanceIdentifier serialize(final InstanceIdentifier<?> input) {
+ public org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier serialize(final InstanceIdentifier<?> input) {
Class<?> previousAugmentation = null;
Iterable<InstanceIdentifier.PathArgument> pathArgs = input.getPathArguments();
QName previousQName = null;
ensureAugmentation(qnamePath,previousQName,baArg.getType());
}
}
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier ret =
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.create(components);
+ org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier ret =
+ org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.create(components);
LOG.debug("Binding Instance Identifier {} serialized to DOM InstanceIdentifier {}", input, ret);
return ret;
}
}
private PathArgument serializePathArgumentAndUpdateMapping(final List<QName> parentPath, final InstanceIdentifier.PathArgument baArg, final QName previousQName, final Class<?> previousAugmentation) {
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument biArg = serializePathArgument(baArg, previousQName);
+ org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument biArg = serializePathArgument(baArg, previousQName);
List<QName> qnamePath = new ArrayList<>(parentPath);
qnamePath.add(biArg.getNodeType());
ImmutableList<QName> currentPath = ImmutableList.copyOf(qnamePath);
InstanceIdentifier augPath = augTarget.augmentation(augType);
try {
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier domPath = getRegistry().getInstanceIdentifierCodec()
+ org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier domPath = getRegistry().getInstanceIdentifierCodec()
.serialize(augPath);
if (domPath == null) {
LOG.error("Unable to serialize instance identifier for {}", augPath);
import org.opendaylight.yangtools.yang.binding.RpcService;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifierWithPredicates;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.Node;
import org.opendaylight.yangtools.yang.data.impl.CompositeNodeTOImpl;
import org.opendaylight.yangtools.yang.data.impl.SimpleNodeTOImpl;
}
@Override
- public Entry<InstanceIdentifier, CompositeNode> toDataDom(
+ public Entry<YangInstanceIdentifier, CompositeNode> toDataDom(
final Entry<org.opendaylight.yangtools.yang.binding.InstanceIdentifier<? extends DataObject>, DataObject> entry) {
try {
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier key = toDataDom(entry.getKey());
+ org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier key = toDataDom(entry.getKey());
CompositeNode data;
if (Augmentation.class.isAssignableFrom(entry.getKey().getTargetType())) {
data = toCompositeNodeImplAugument(key, entry.getValue());
} else {
data = toCompositeNodeImpl(key, entry.getValue());
}
- return new SimpleEntry<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode>(key,
+ return new SimpleEntry<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, CompositeNode>(key,
data);
} catch (Exception e) {
return codec.serialize(new ValueWithQName<DataObject>(null, object));
}
- private CompositeNode toCompositeNodeImpl(final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier identifier,
+ private CompositeNode toCompositeNodeImpl(final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier identifier,
final DataObject object) {
PathArgument last = identifier.getLastPathArgument();
Class<? extends DataContainer> cls = object.getImplementedInterface();
}
private CompositeNode toCompositeNodeImplAugument(
- final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier identifier, final DataObject object) {
+ final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier identifier, final DataObject object) {
// val cls = object.implementedInterface;
// waitForSchema(cls);
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument last = identifier.getLastPathArgument();
+ org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument last = identifier.getLastPathArgument();
AugmentationCodec codec = registry.getCodecForAugmentation((Class) object.getImplementedInterface());
CompositeNode ret = codec.serialize(new ValueWithQName<DataObject>(last.getNodeType(), object));
if (last instanceof NodeIdentifierWithPredicates) {
}
@Override
- public InstanceIdentifier toDataDom(
+ public YangInstanceIdentifier toDataDom(
final org.opendaylight.yangtools.yang.binding.InstanceIdentifier<? extends DataObject> path) {
for (final org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument arg : path.getPathArguments()) {
this.waitForSchema(arg.getType());
}
@Override
- public org.opendaylight.yangtools.yang.binding.InstanceIdentifier<? extends Object> fromDataDom(final InstanceIdentifier entry) throws DeserializationException {
+ public org.opendaylight.yangtools.yang.binding.InstanceIdentifier<? extends Object> fromDataDom(final YangInstanceIdentifier entry) throws DeserializationException {
try {
final InstanceIdentifierCodec c = registry.getInstanceIdentifierCodec();
Preconditions.checkState(c != null, "InstanceIdentifierCodec not present");
import java.util.Map
import java.util.Set
import org.opendaylight.yangtools.yang.common.QName
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifierWithPredicates
import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode
import org.opendaylight.yangtools.yang.model.api.AugmentationTarget
import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode
import org.slf4j.LoggerFactory
import org.sonatype.plexus.build.incremental.BuildContext
import org.sonatype.plexus.build.incremental.DefaultBuildContext
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier
class GeneratorImpl {
def CharSequence tree(Module module) '''
«strong(module.name)»
- «module.childNodes.treeSet(InstanceIdentifier.builder.toInstance())»
+ «module.childNodes.treeSet(YangInstanceIdentifier.builder.toInstance())»
'''
- private def dispatch CharSequence tree(ChoiceNode node,InstanceIdentifier path) '''
+ private def dispatch CharSequence tree(ChoiceNode node,YangInstanceIdentifier path) '''
«node.nodeName» (choice)
«casesTree(node.cases,path)»
'''
- def casesTree(Set<ChoiceCaseNode> nodes,InstanceIdentifier path) '''
+ def casesTree(Set<ChoiceCaseNode> nodes,YangInstanceIdentifier path) '''
<ul>
«FOR node : nodes»
<li>
</ul>
'''
- private def dispatch CharSequence tree(DataSchemaNode node,InstanceIdentifier path) '''
+ private def dispatch CharSequence tree(DataSchemaNode node,YangInstanceIdentifier path) '''
«node.nodeName»
'''
- private def dispatch CharSequence tree(ListSchemaNode node,InstanceIdentifier path) '''
+ private def dispatch CharSequence tree(ListSchemaNode node,YangInstanceIdentifier path) '''
«val newPath = path.append(node)»
«localLink(newPath,node.nodeName)»
«node.childNodes.treeSet(newPath)»
'''
- private def dispatch CharSequence tree(ContainerSchemaNode node,InstanceIdentifier path) '''
+ private def dispatch CharSequence tree(ContainerSchemaNode node,YangInstanceIdentifier path) '''
«val newPath = path.append(node)»
«localLink(newPath,node.nodeName)»
«node.childNodes.treeSet(newPath)»
«IF !childNodes.nullOrEmpty»
<h2>Child nodes</h2>
- «childNodes.printChildren(3,InstanceIdentifier.builder().toInstance())»
+ «childNodes.printChildren(3,YangInstanceIdentifier.builder().toInstance())»
«ENDIF»
'''
'''
}
- def CharSequence printChildren(Iterable<DataSchemaNode> nodes, int level, InstanceIdentifier path) {
+ def CharSequence printChildren(Iterable<DataSchemaNode> nodes, int level, YangInstanceIdentifier path) {
val anyxmlNodes = nodes.filter(AnyXmlSchemaNode)
val leafNodes = nodes.filter(LeafSchemaNode)
val leafListNodes = nodes.filter(LeafListSchemaNode)
'''
}
- def CharSequence xmlExample(Iterable<DataSchemaNode> nodes, QName name,InstanceIdentifier path) '''
+ def CharSequence xmlExample(Iterable<DataSchemaNode> nodes, QName name,YangInstanceIdentifier path) '''
<pre>
«xmlExampleTag(name,nodes.xmplExampleTags(path))»
</pre>
'''
- def CharSequence xmplExampleTags(Iterable<DataSchemaNode> nodes, InstanceIdentifier identifier) '''
+ def CharSequence xmplExampleTags(Iterable<DataSchemaNode> nodes, YangInstanceIdentifier identifier) '''
<!-- Child nodes -->
«FOR node : nodes»
<!-- «node.QName.localName» -->
'''
- private def dispatch CharSequence asXmlExampleTag(LeafSchemaNode node, InstanceIdentifier identifier) '''
+ private def dispatch CharSequence asXmlExampleTag(LeafSchemaNode node, YangInstanceIdentifier identifier) '''
«node.QName.xmlExampleTag("...")»
'''
- private def dispatch CharSequence asXmlExampleTag(LeafListSchemaNode node, InstanceIdentifier identifier) '''
+ private def dispatch CharSequence asXmlExampleTag(LeafListSchemaNode node, YangInstanceIdentifier identifier) '''
<!-- This node could appear multiple times -->
«node.QName.xmlExampleTag("...")»
'''
- private def dispatch CharSequence asXmlExampleTag(ContainerSchemaNode node, InstanceIdentifier identifier) '''
+ private def dispatch CharSequence asXmlExampleTag(ContainerSchemaNode node, YangInstanceIdentifier identifier) '''
<!-- See «localLink(identifier.append(node),"definition")» for child nodes. -->
«node.QName.xmlExampleTag("...")»
'''
- private def dispatch CharSequence asXmlExampleTag(ListSchemaNode node, InstanceIdentifier identifier) '''
+ private def dispatch CharSequence asXmlExampleTag(ListSchemaNode node, YangInstanceIdentifier identifier) '''
<!-- See «localLink(identifier.append(node),"definition")» for child nodes. -->
<!-- This node could appear multiple times -->
«node.QName.xmlExampleTag("...")»
'''
- private def dispatch CharSequence asXmlExampleTag(DataSchemaNode node, InstanceIdentifier identifier) '''
+ private def dispatch CharSequence asXmlExampleTag(DataSchemaNode node, YangInstanceIdentifier identifier) '''
<!-- noop -->
'''
def header(int level,QName name) '''<h«level»>«name.localName»</h«level»>'''
- def header(int level,InstanceIdentifier name) '''
+ def header(int level,YangInstanceIdentifier name) '''
<h«level» id="«FOR cmp : name.path SEPARATOR "/"»«cmp.nodeType.localName»«ENDFOR»">
«FOR cmp : name.path SEPARATOR "/"»«cmp.nodeType.localName»«ENDFOR»
</h«level»>
- private def dispatch CharSequence printInfo(DataSchemaNode node, int level, InstanceIdentifier path) '''
+ private def dispatch CharSequence printInfo(DataSchemaNode node, int level, YangInstanceIdentifier path) '''
«header(level+1,node.QName)»
'''
- private def dispatch CharSequence printInfo(ContainerSchemaNode node, int level, InstanceIdentifier path) '''
+ private def dispatch CharSequence printInfo(ContainerSchemaNode node, int level, YangInstanceIdentifier path) '''
«val newPath = path.append(node)»
«header(level,newPath)»
<dl>
«node.childNodes.printChildren(level,newPath)»
'''
- private def dispatch CharSequence printInfo(ListSchemaNode node, int level, InstanceIdentifier path) '''
+ private def dispatch CharSequence printInfo(ListSchemaNode node, int level, YangInstanceIdentifier path) '''
«val newPath = path.append(node)»
«header(level,newPath)»
<dl>
«node.childNodes.printChildren(level,newPath)»
'''
- private def dispatch CharSequence printInfo(ChoiceNode node, int level, InstanceIdentifier path) '''
+ private def dispatch CharSequence printInfo(ChoiceNode node, int level, YangInstanceIdentifier path) '''
«val Set<DataSchemaNode> choiceCases = new HashSet(node.cases)»
«choiceCases.printChildren(level,path)»
'''
- private def dispatch CharSequence printInfo(ChoiceCaseNode node, int level, InstanceIdentifier path) '''
+ private def dispatch CharSequence printInfo(ChoiceCaseNode node, int level, YangInstanceIdentifier path) '''
«node.childNodes.printChildren(level,path)»
'''
- def CharSequence printShortInfo(ContainerSchemaNode node, int level, InstanceIdentifier path) {
+ def CharSequence printShortInfo(ContainerSchemaNode node, int level, YangInstanceIdentifier path) {
val newPath = path.append(node);
return '''
<li>«strong(localLink(newPath,node.QName.localName))» (container)
'''
}
- def CharSequence printShortInfo(ListSchemaNode node, int level, InstanceIdentifier path) {
+ def CharSequence printShortInfo(ListSchemaNode node, int level, YangInstanceIdentifier path) {
val newPath = path.append(node);
return '''
<li>«strong(localLink(newPath,node.QName.localName))» (list)
'''
}
- def CharSequence printShortInfo(AnyXmlSchemaNode node, int level, InstanceIdentifier path) {
+ def CharSequence printShortInfo(AnyXmlSchemaNode node, int level, YangInstanceIdentifier path) {
return '''
<li>«strong((node.QName.localName))» (anyxml)
<ul>
'''
}
- def CharSequence printShortInfo(LeafSchemaNode node, int level, InstanceIdentifier path) {
+ def CharSequence printShortInfo(LeafSchemaNode node, int level, YangInstanceIdentifier path) {
return '''
<li>«strong((node.QName.localName))» (leaf)
<ul>
'''
}
- def CharSequence printShortInfo(LeafListSchemaNode node, int level, InstanceIdentifier path) {
+ def CharSequence printShortInfo(LeafListSchemaNode node, int level, YangInstanceIdentifier path) {
return '''
<li>«strong((node.QName.localName))» (leaf-list)
<ul>
'''
}
- def CharSequence localLink(InstanceIdentifier identifier, CharSequence text) '''
+ def CharSequence localLink(YangInstanceIdentifier identifier, CharSequence text) '''
<a href="#«FOR cmp : identifier.path SEPARATOR "/"»«cmp.nodeType.localName»«ENDFOR»">«text»</a>
'''
- private def dispatch InstanceIdentifier append(InstanceIdentifier identifier, ContainerSchemaNode node) {
+ private def dispatch YangInstanceIdentifier append(YangInstanceIdentifier identifier, ContainerSchemaNode node) {
return identifier.node(node.QName);
}
- private def dispatch InstanceIdentifier append(InstanceIdentifier identifier, ListSchemaNode node) {
+ private def dispatch YangInstanceIdentifier append(YangInstanceIdentifier identifier, ListSchemaNode node) {
val keyValues = new LinkedHashMap<QName,Object>();
if(node.keyDefinition !== null) {
for(definition : node.keyDefinition) {
}
- def asXmlPath(InstanceIdentifier identifier) {
+ def asXmlPath(YangInstanceIdentifier identifier) {
return "";
}
- def asRestconfPath(InstanceIdentifier identifier) {
+ def asRestconfPath(YangInstanceIdentifier identifier) {
val it = new StringBuilder();
append(currentModule.name)
append(":")
previous = true;
if(arg instanceof NodeIdentifierWithPredicates) {
val nodeIdentifier = arg as NodeIdentifierWithPredicates;
- for(qname : nodeIdentifier.keyValues.keySet) {
+ for(qname : nodeIdentifier.getKeyValues.keySet) {
append("/{");
append(qname.localName)
append("}")
«ENDIF»
'''
- private def CharSequence treeSet(Collection<DataSchemaNode> childNodes, InstanceIdentifier path) '''
+ private def CharSequence treeSet(Collection<DataSchemaNode> childNodes, YangInstanceIdentifier path) '''
«IF childNodes !== null && !childNodes.empty»
<ul>
«FOR child : childNodes»
</ul>
'''
- private def dispatch CharSequence tree(Void obj, InstanceIdentifier path) '''
+ private def dispatch CharSequence tree(Void obj, YangInstanceIdentifier path) '''
'''
.build()) //
.build();
- Entry<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> result = mappingService
+ Entry<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, CompositeNode> result = mappingService
.toDataDom(new SimpleEntry(GROUPING_AUGMENTATIONS_PATH, caseData));
assertNotNull(result);
}
import org.opendaylight.yangtools.yang.binding.RpcService;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.Node;
import org.opendaylight.yangtools.yang.data.impl.ImmutableCompositeNode;
import org.opendaylight.yangtools.yang.data.impl.codec.BindingIndependentMappingService;
public static Entry<String, DataSchemaNode> toRestconfIdentifier(
final org.opendaylight.yangtools.yang.binding.InstanceIdentifier<?> bindingIdentifier,
final BindingIndependentMappingService mappingService, final SchemaContext schemaContext) {
- InstanceIdentifier domIdentifier = mappingService.toDataDom(bindingIdentifier);
+ YangInstanceIdentifier domIdentifier = mappingService.toDataDom(bindingIdentifier);
return toRestconfIdentifier(domIdentifier, schemaContext);
}
- public static Entry<String, DataSchemaNode> toRestconfIdentifier(final InstanceIdentifier xmlInstanceIdentifier,
+ public static Entry<String, DataSchemaNode> toRestconfIdentifier(final YangInstanceIdentifier xmlInstanceIdentifier,
final SchemaContext schemaContext) {
- final Iterable<InstanceIdentifier.PathArgument> elements = xmlInstanceIdentifier.getPathArguments();
+ final Iterable<YangInstanceIdentifier.PathArgument> elements = xmlInstanceIdentifier.getPathArguments();
final StringBuilder ret = new StringBuilder();
final QName startQName = elements.iterator().next().getNodeType();
URI namespace = startQName.getNamespace();
final Module initialModule = schemaContext.findModuleByNamespaceAndRevision(namespace, revision);
DataNodeContainer node = (initialModule);
DataSchemaNode schemaNode = null;
- for (final InstanceIdentifier.PathArgument element : elements) {
+ for (final YangInstanceIdentifier.PathArgument element : elements) {
final DataSchemaNode potentialNode = node.getDataChildByName(element.getNodeType());
if (!isListOrContainer(potentialNode)) {
return null;
return new SimpleEntry<>(ret.toString(), schemaNode);
}
- private static CharSequence convertContainerToRestconfIdentifier(final InstanceIdentifier.NodeIdentifier argument,
+ private static CharSequence convertContainerToRestconfIdentifier(final YangInstanceIdentifier.NodeIdentifier argument,
final SchemaContext schemaContext) {
return "/" + toRestconfIdentifier(argument.getNodeType(), schemaContext);
}
private static CharSequence convertListToRestconfIdentifier(
- final InstanceIdentifier.NodeIdentifierWithPredicates argument, final ListSchemaNode node,
+ final YangInstanceIdentifier.NodeIdentifierWithPredicates argument, final ListSchemaNode node,
final SchemaContext schemaContext) {
QName _nodeType = argument.getNodeType();
final CharSequence nodeIdentifier = toRestconfIdentifier(_nodeType, schemaContext);
return module + ':' + qname.getLocalName();
}
- private static CharSequence convertToRestconfIdentifier(final InstanceIdentifier.PathArgument argument,
+ private static CharSequence convertToRestconfIdentifier(final YangInstanceIdentifier.PathArgument argument,
final DataNodeContainer node, final SchemaContext schemaContext) {
- if (argument instanceof InstanceIdentifier.NodeIdentifier) {
+ if (argument instanceof YangInstanceIdentifier.NodeIdentifier) {
return convertContainerToRestconfIdentifier((NodeIdentifier) argument, schemaContext);
- } else if (argument instanceof InstanceIdentifier.NodeIdentifierWithPredicates
+ } else if (argument instanceof YangInstanceIdentifier.NodeIdentifierWithPredicates
&& node instanceof ListSchemaNode) {
return convertListToRestconfIdentifier((NodeIdentifierWithPredicates) argument, (ListSchemaNode) node,
schemaContext);
VsTlv vsTlv = tlvs.getVsTlv();
assertNotNull(vsTlv.getVendorPayload());
- Entry<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> domPcc = mappingService.toDataDom(new SimpleEntry<InstanceIdentifier<?>,DataObject>(PATH_TO_CLIENT,pcc));
+ Entry<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, CompositeNode> domPcc = mappingService.toDataDom(new SimpleEntry<InstanceIdentifier<?>,DataObject>(PATH_TO_CLIENT,pcc));
CompositeNode domPccValue = domPcc.getValue();
assertNotNull(domPccValue);
CompositeNode domPccTlvs = getFirstReportedLspVsTlvs(domPccValue);
VsTlv vsTlv = tlvs.getVsTlv();
assertNotNull(vsTlv.getVendorPayload());
- Entry<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> domPcc = mappingService.toDataDom(new SimpleEntry<InstanceIdentifier<?>,DataObject>(PATH_TO_CLIENT,pcc));
+ Entry<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, CompositeNode> domPcc = mappingService.toDataDom(new SimpleEntry<InstanceIdentifier<?>,DataObject>(PATH_TO_CLIENT,pcc));
CompositeNode domPccValue = domPcc.getValue();
assertNotNull(domPccValue);
CompositeNode domPccTlvs = getFirstReportedLspVsTlvs(domPccValue);
*
* @see http://tools.ietf.org/html/rfc6020#section-9.13
*/
-public final class InstanceIdentifier implements Path<InstanceIdentifier>, Immutable, Serializable {
- private static final InstanceIdentifier EMPTY = trustedCreate(Collections.<PathArgument>emptyList());
+public final class YangInstanceIdentifier implements Path<YangInstanceIdentifier>, Immutable, Serializable {
+ private static final
YangInstanceIdentifier EMPTY = trustedCreate(Collections.<PathArgument>emptyList());
private static final long serialVersionUID = 2L;
private final Iterable<PathArgument> pathArguments;
return Iterables.getFirst(getReversePathArguments(), null);
}
- private InstanceIdentifier(final Iterable<PathArgument> path, final int hash) {
+ private
YangInstanceIdentifier(final Iterable<PathArgument> path, final int hash) {
this.pathArguments = Preconditions.checkNotNull(path, "path must not be null.");
this.hash = hash;
}
- private static final InstanceIdentifier trustedCreate(final Iterable<PathArgument> path) {
+ private static final
YangInstanceIdentifier trustedCreate(final Iterable<PathArgument> path) {
final HashCodeBuilder<PathArgument> hash = new HashCodeBuilder<>();
for (PathArgument a : path) {
hash.addArgument(a);
}
- return new InstanceIdentifier(path, hash.toInstance());
+ return new YangInstanceIdentifier(path, hash.toInstance());
}
- public static final InstanceIdentifier create(final Iterable<? extends PathArgument> path) {
+ public static final YangInstanceIdentifier create(final Iterable<? extends PathArgument> path) {
if (Iterables.isEmpty(path)) {
return EMPTY;
}
return trustedCreate(ImmutableList.copyOf(path));
}
- public static final InstanceIdentifier create(final PathArgument... path) {
+ public static final YangInstanceIdentifier create(final PathArgument... path) {
// We are forcing a copy, since we cannot trust the user
return create(Arrays.asList(path));
}
if (getClass() != obj.getClass()) {
return false;
}
- InstanceIdentifier other = (InstanceIdentifier) obj;
+ YangInstanceIdentifier other = (YangInstanceIdentifier) obj;
if (this.hashCode() != obj.hashCode()) {
return false;
}
* @param name QName of {@link NodeIdentifier}
* @return Instance Identifier with additional path argument added to the end.
*/
- public InstanceIdentifier node(final QName name) {
+ public YangInstanceIdentifier node(final QName name) {
return node(new NodeIdentifier(name));
}
* @param arg Path argument which should be added to the end
* @return Instance Identifier with additional path argument added to the end.
*/
- public InstanceIdentifier node(final PathArgument arg) {
- return new InstanceIdentifier(Iterables.concat(pathArguments, Collections.singleton(arg)), HashCodeBuilder.nextHashCode(hash, arg));
+ public YangInstanceIdentifier node(final PathArgument arg) {
+ return new YangInstanceIdentifier(Iterables.concat(pathArguments, Collections.singleton(arg)), HashCodeBuilder.nextHashCode(hash, arg));
}
/**
* @return This object's relative path from parent, or Optional.absent() if
* the specified parent is not in fact an ancestor of this object.
*/
- public Optional<InstanceIdentifier> relativeTo(final InstanceIdentifier ancestor) {
+ public Optional<YangInstanceIdentifier> relativeTo(final YangInstanceIdentifier ancestor) {
final Iterator<?> lit = pathArguments.iterator();
final Iterator<?> oit = ancestor.pathArguments.iterator();
int common = 0;
* @param name QName of first node identifier
* @return Instance Identifier with only one path argument of type {@link NodeIdentifier}
*/
- public static InstanceIdentifier of(final QName name) {
+ public static YangInstanceIdentifier of(final QName name) {
return create(new NodeIdentifier(name));
}
* @param origin Instace Identifier from which path arguments are copied.
* @return new builder for InstanceIdentifier with path arguments copied from original instance identifier.
*/
- static public InstanceIdentifierBuilder builder(final InstanceIdentifier origin) {
+ static public InstanceIdentifierBuilder builder(final YangInstanceIdentifier origin) {
return new BuilderImpl(origin.getPathArguments(), origin.hashCode());
}
* @
*
*/
- public interface InstanceIdentifierBuilder extends Builder<InstanceIdentifier> {
+ public interface InstanceIdentifierBuilder extends Builder<YangInstanceIdentifier> {
/**
* Adds {@link NodeIdentifier} with supplied QName to path arguments of resulting instance identifier.
*
/**
*
- * Builds an {@link InstanceIdentifier} with path arguments from this builder
+ * Builds an {@link YangInstanceIdentifier} with path arguments from this builder
*
- * @return {@link InstanceIdentifier}
+ * @return {@link YangInstanceIdentifier}
*/
- InstanceIdentifier build();
+ YangInstanceIdentifier build();
}
/**
result = prime * result;
for (Entry<QName, Object> entry : keyValues.entrySet()) {
- result += Objects.hashCode(entry.getKey()) + InstanceIdentifier.hashCode(entry.getValue());
+ result += Objects.hashCode(entry.getKey()) + YangInstanceIdentifier.hashCode(entry.getValue());
}
return result;
}
public int hashCode() {
final int prime = 31;
int result = super.hashCode();
- result = prime * result + ((value == null) ? 0 : InstanceIdentifier.hashCode(value));
+ result = prime * result + ((value == null) ? 0 : YangInstanceIdentifier.hashCode(value));
return result;
}
@Override
@Deprecated
- public InstanceIdentifier toInstance() {
+ public YangInstanceIdentifier toInstance() {
return build();
}
@Override
- public InstanceIdentifier build() {
- return new InstanceIdentifier(ImmutableList.copyOf(path), hash.toInstance());
+ public YangInstanceIdentifier build() {
+ return new YangInstanceIdentifier(ImmutableList.copyOf(path), hash.toInstance());
}
}
@Override
- public boolean contains(final InstanceIdentifier other) {
+ public boolean contains(final YangInstanceIdentifier other) {
Preconditions.checkArgument(other != null, "other should not be null");
final Iterator<?> lit = pathArguments.iterator();
package org.opendaylight.yangtools.yang.data.api.codec;
import org.opendaylight.yangtools.concepts.Codec;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
/**
*
* Codec which serializes / deserializes InstanceIdentifier
*
* @param <T> Target type
*/
-public interface InstanceIdentifierCodec<T> extends Codec<T,InstanceIdentifier> {
+public interface InstanceIdentifierCodec<T> extends Codec<T,YangInstanceIdentifier> {
@Override
- T serialize(InstanceIdentifier data);
+ T serialize(YangInstanceIdentifier data);
@Override
- InstanceIdentifier deserialize(T data);
+ YangInstanceIdentifier deserialize(T data);
}
package org.opendaylight.yangtools.yang.data.api.schema;
import org.opendaylight.yangtools.yang.data.api.AttributesContainer;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.Node;
/**
*/
package org.opendaylight.yangtools.yang.data.api.schema;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.AugmentationIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
public interface AugmentationNode extends //
MixinNode, //
DataContainerNode<AugmentationIdentifier>,
- DataContainerChild<InstanceIdentifier.AugmentationIdentifier, Iterable<DataContainerChild<? extends PathArgument, ?>>> {
+ DataContainerChild<YangInstanceIdentifier.AugmentationIdentifier, Iterable<DataContainerChild<? extends PathArgument, ?>>> {
/**
* Gets identifier of augmentation node
*/
package org.opendaylight.yangtools.yang.data.api.schema;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
/**
*
package org.opendaylight.yangtools.yang.data.api.schema;
import org.opendaylight.yangtools.yang.data.api.AttributesContainer;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
/**
* Data subtree with cardinality 0..1 in the context of parent node
*/
package org.opendaylight.yangtools.yang.data.api.schema;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
/**
*
*/
package org.opendaylight.yangtools.yang.data.api.schema;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
/**
*
package org.opendaylight.yangtools.yang.data.api.schema;
import org.opendaylight.yangtools.yang.data.api.AttributesContainer;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
/**
*
package org.opendaylight.yangtools.yang.data.api.schema;
import org.opendaylight.yangtools.yang.data.api.AttributesContainer;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeWithValue;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
/**
*
*/
package org.opendaylight.yangtools.yang.data.api.schema;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeWithValue;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
/**
*
package org.opendaylight.yangtools.yang.data.api.schema;
import org.opendaylight.yangtools.yang.data.api.AttributesContainer;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
/**
*
* Returns identifier of this node in parent map node
*
* Contents of identifier is defined by <code>key</code> (
- * {@link org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.ListSchemaNode#getKeyDefinition()}
+ * {@link org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.ListSchemaNode#getKeyDefinition()}
* ) statement in YANG schema for associated list item and child {@link LeafNode}s
- * values with {@link org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier}
+ * values with {@link org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier}
* as defined in the schema.
*
* @return identifier of this node in the context of parent node
*/
package org.opendaylight.yangtools.yang.data.api.schema;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
/**
* Containment node, which contains {@link MapEntryNode} of the same type, which may
import org.opendaylight.yangtools.concepts.Identifiable;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
/**
*
* Node which is normalized according to the YANG schema
- * is identifiable by {@link InstanceIdentifier}.
+ * is identifiable by {@link YangInstanceIdentifier}.
*
* See subinterfaces of this interface for concretization
* of node.
* @param <K> Local identifier of node
* @param <V> Value of node
*/
-public interface NormalizedNode<K extends InstanceIdentifier.PathArgument, V> extends Identifiable<K> {
+public interface NormalizedNode<K extends YangInstanceIdentifier.PathArgument, V> extends Identifiable<K> {
/**
* QName of the node as defined in YANG schema.
*
*/
package org.opendaylight.yangtools.yang.data.api.schema;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import com.google.common.base.Optional;
*/
package org.opendaylight.yangtools.yang.data.api.schema;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
/**
*
*/
package org.opendaylight.yangtools.yang.data.api.schema;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
/**
* List entry node, which does not have value, but child nodes.
*/
package org.opendaylight.yangtools.yang.data.api.schema;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
/**
* <h3>Tree / subtree structure</h3> <h4>Grammar representation</h4>
*
* <pre>
- * {@link org.opendaylight.yangtools.yang.data.api.InstanceIdentifier} = {@link org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument}*
- * {@link org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument} = {@link org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier}| {@link org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifierWithPredicates}| {@link org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeWithValue} | {@link org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.AugmentationIdentifier}
+ * {@link org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier} = {@link org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument}*
+ * {@link org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument} = {@link org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier}| {@link org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates}| {@link org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue} | {@link org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier}
*
* TreeRoot = {@link org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode}
* {@link org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode} = ( {@link org.opendaylight.yangtools.yang.data.api.schema.LeafNode} | {@link org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode} | {@link org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode} | {@link org.opendaylight.yangtools.yang.data.api.schema.MapNode} | {@link org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode})*
- * ContainerDataNode = {@link org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier} {@link org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode}
+ * ContainerDataNode = {@link org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier} {@link org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode}
*
- * {@link org.opendaylight.yangtools.yang.data.api.schema.LeafNode} = {@link org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier} SimpleValue
- * {@link org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode} = {@link org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.AugmentationIdentifier} {@link org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode}
- * {@link org.opendaylight.yangtools.yang.data.api.schema.MapNode} = {@link org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier} {@link org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode}
- * {@link org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode} = {@link org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifierWithPredicates} {@link org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode}
+ * {@link org.opendaylight.yangtools.yang.data.api.schema.LeafNode} = {@link org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier} SimpleValue
+ * {@link org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode} = {@link org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier} {@link org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode}
+ * {@link org.opendaylight.yangtools.yang.data.api.schema.MapNode} = {@link org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier} {@link org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode}
+ * {@link org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode} = {@link org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates} {@link org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode}
*
* // Special nodes
- * {@link org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode} = {@link org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier} {@link org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode}*
- * {@link org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode} = {@link org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier} {@link org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode}
- * {@link org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode} = {@link org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeWithValue} SimpleValue
+ * {@link org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode} = {@link org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier} {@link org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode}*
+ * {@link org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode} = {@link org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier} {@link org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode}
+ * {@link org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode} = {@link org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue} SimpleValue
* </pre>
*
* The resulting tree organization is following:
*/
package org.opendaylight.yangtools.yang.data.api.schema.tree;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
/**
* Exception thrown when a proposed change fails validation before being
*/
private static final long serialVersionUID = 1L;
- public ConflictingModificationAppliedException(final InstanceIdentifier path, final String message, final Throwable cause) {
+ public ConflictingModificationAppliedException(final YangInstanceIdentifier path, final String message, final Throwable cause) {
super(path, message, cause);
}
- public ConflictingModificationAppliedException(final InstanceIdentifier path, final String message) {
+ public ConflictingModificationAppliedException(final YangInstanceIdentifier path, final String message) {
super(path, message);
}
*/
package org.opendaylight.yangtools.yang.data.api.schema.tree;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
/**
* An encapsulation of a validated data tree modification. This candidate
*
* @return Relative path of the root node
*/
- InstanceIdentifier getRootPath();
+ YangInstanceIdentifier getRootPath();
}
*/
package org.opendaylight.yangtools.yang.data.api.schema.tree;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import com.google.common.base.Optional;
*/
package org.opendaylight.yangtools.yang.data.api.schema.tree;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
/**
*
* @param path Node path
*/
- void delete(InstanceIdentifier path);
+ void delete(YangInstanceIdentifier path);
/**
* Merge the specified data with the currently-present data
* @param path Node path
* @param data Data to be merged
*/
- void merge(InstanceIdentifier path, NormalizedNode<?, ?> data);
+ void merge(YangInstanceIdentifier path, NormalizedNode<?, ?> data);
/**
* Replace the data at specified path with supplied data.
* @param path Node path
* @param data New node data
*/
- void write(InstanceIdentifier path, NormalizedNode<?, ?> data);
+ void write(YangInstanceIdentifier path, NormalizedNode<?, ?> data);
/**
* Finish creation of a modification, making it ready for application
*/
package org.opendaylight.yangtools.yang.data.api.schema.tree;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import com.google.common.base.Optional;
* @param path Path of the node
* @return Optional result encapsulating the presence and value of the node
*/
- Optional<NormalizedNode<?, ?>> readNode(InstanceIdentifier path);
+ Optional<NormalizedNode<?, ?>> readNode(YangInstanceIdentifier path);
/**
* Create a new data tree modification based on this snapshot, using the
*/
package org.opendaylight.yangtools.yang.data.api.schema.tree;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import com.google.common.base.Preconditions;
*/
public class DataValidationFailedException extends Exception {
private static final long serialVersionUID = 1L;
- private final InstanceIdentifier path;
+ private final YangInstanceIdentifier path;
/**
* Create a new instance.
* @param path Object path which caused this exception
* @param message Specific message describing the failure
*/
- public DataValidationFailedException(final InstanceIdentifier path, final String message) {
+ public DataValidationFailedException(final YangInstanceIdentifier path, final String message) {
this(path, message, null);
}
/**
* @param message Specific message describing the failure
* @param cause Exception which triggered this failure, may be null
*/
- public DataValidationFailedException(final InstanceIdentifier path, final String message, final Throwable cause) {
+ public DataValidationFailedException(final YangInstanceIdentifier path, final String message, final Throwable cause) {
super(message, cause);
this.path = Preconditions.checkNotNull(path);
}
*
* @return Path of the offending object
*/
- public InstanceIdentifier getPath() {
+ public YangInstanceIdentifier getPath() {
return path;
}
}
*/
package org.opendaylight.yangtools.yang.data.api.schema.tree;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
/**
* Exception thrown when a proposed change fails validation before being
*/
private static final long serialVersionUID = 1L;
- public IncorrectDataStructureException(final InstanceIdentifier path, final String message, final Throwable cause) {
+ public IncorrectDataStructureException(final YangInstanceIdentifier path, final String message, final Throwable cause) {
super(path, message, cause);
}
- public IncorrectDataStructureException(final InstanceIdentifier path, final String message) {
+ public IncorrectDataStructureException(final YangInstanceIdentifier path, final String message) {
super(path, message);
}
*/
package org.opendaylight.yangtools.yang.data.api.schema.tree;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
/**
* Exception thrown when a proposed change fails validation before being
*/
private static final long serialVersionUID = 1L;
- public ModifiedNodeDoesNotExistException(final InstanceIdentifier path, final String message, final Throwable cause) {
+ public ModifiedNodeDoesNotExistException(final YangInstanceIdentifier path, final String message, final Throwable cause) {
super(path, message, cause);
}
- public ModifiedNodeDoesNotExistException(final InstanceIdentifier path, final String message) {
+ public ModifiedNodeDoesNotExistException(final YangInstanceIdentifier path, final String message) {
super(path, message);
}
*/
package org.opendaylight.yangtools.yang.data.api.schema.tree;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import com.google.common.base.Optional;
*/
package org.opendaylight.yangtools.yang.data.api.schema.tree.spi;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import com.google.common.base.Preconditions;
import java.util.Map;
import org.opendaylight.yangtools.util.MapAdaptor;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer;
import org.opendaylight.yangtools.yang.data.api.schema.OrderedNodeContainer;
package org.opendaylight.yangtools.yang.data.api.schema.tree.spi;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.StoreTreeNode;
import org.opendaylight.yangtools.concepts.Identifiable;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.StoreTreeNode;
*/
package org.opendaylight.yangtools.yang.data.api.schema.tree.spi;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.AugmentationIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifierWithPredicates;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeWithValue;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
/**
* Unit tests for InstanceIdentifier.
@Test
public void testHashCodeEquals() {
- InstanceIdentifier id1 = InstanceIdentifier.create(new NodeIdentifier(nodeName1), new NodeIdentifier(nodeName2));
- InstanceIdentifier id2 = InstanceIdentifier.create(new NodeIdentifier(nodeName1), new NodeIdentifier(nodeName2));
- InstanceIdentifier id3 = InstanceIdentifier.create(new NodeIdentifier(nodeName2), new NodeIdentifier(nodeName1));
- InstanceIdentifier id4 = InstanceIdentifier.create(new NodeIdentifier(nodeName1));
+ YangInstanceIdentifier id1 = YangInstanceIdentifier.create(new NodeIdentifier(nodeName1), new NodeIdentifier(nodeName2));
+ YangInstanceIdentifier id2 = YangInstanceIdentifier.create(new NodeIdentifier(nodeName1), new NodeIdentifier(nodeName2));
+ YangInstanceIdentifier id3 = YangInstanceIdentifier.create(new NodeIdentifier(nodeName2), new NodeIdentifier(nodeName1));
+ YangInstanceIdentifier id4 = YangInstanceIdentifier.create(new NodeIdentifier(nodeName1));
assertEquals( "hashCode", id1.hashCode(), id2.hashCode() );
assertEquals( "equals", true, id1.equals( id2 ) );
@Test
public void testNode() {
- InstanceIdentifier id = InstanceIdentifier.create(new NodeIdentifier(nodeName1), new NodeIdentifier(nodeName2));
+ YangInstanceIdentifier id = YangInstanceIdentifier.create(new NodeIdentifier(nodeName1), new NodeIdentifier(nodeName2));
- InstanceIdentifier newID = id.node( nodeName3 );
+ YangInstanceIdentifier newID = id.node( nodeName3 );
assertNotNull( "InstanceIdentifier is null", newID );
assertEquals( "Path size", 3, Iterables.size(newID.getPathArguments()) );
@Test
public void testRelativeTo() {
- InstanceIdentifier id1 = InstanceIdentifier.create(new NodeIdentifier(nodeName1), new NodeIdentifier(nodeName2),
+ YangInstanceIdentifier id1 = YangInstanceIdentifier.create(new NodeIdentifier(nodeName1), new NodeIdentifier(nodeName2),
new NodeIdentifier(nodeName3), new NodeIdentifier(nodeName4));
- InstanceIdentifier id2 = InstanceIdentifier.create(new NodeIdentifier(nodeName1), new NodeIdentifier(nodeName2));
- InstanceIdentifier id3 = InstanceIdentifier.create(
+ YangInstanceIdentifier id2 = YangInstanceIdentifier.create(new NodeIdentifier(nodeName1), new NodeIdentifier(nodeName2));
+ YangInstanceIdentifier id3 = YangInstanceIdentifier.create(
Lists.newArrayList(new NodeIdentifier(nodeName1), new NodeIdentifier(nodeName2)));
- Optional<InstanceIdentifier> relative = id1.relativeTo( id2 );
+ Optional<YangInstanceIdentifier> relative = id1.relativeTo( id2 );
assertEquals( "isPresent", true, relative.isPresent() );
@Test
public void testContains() {
- InstanceIdentifier id1 = InstanceIdentifier.create(new NodeIdentifier(nodeName1), new NodeIdentifier(nodeName2),
+ YangInstanceIdentifier id1 = YangInstanceIdentifier.create(new NodeIdentifier(nodeName1), new NodeIdentifier(nodeName2),
new NodeIdentifier(nodeName3), new NodeIdentifier(nodeName4));
- InstanceIdentifier id2 = InstanceIdentifier.create(new NodeIdentifier(nodeName1), new NodeIdentifier(nodeName2));
- InstanceIdentifier id3 = InstanceIdentifier.create(new NodeIdentifier(nodeName1), new NodeIdentifier(nodeName2));
- InstanceIdentifier id4 = InstanceIdentifier.create(new NodeIdentifier(nodeName1), new NodeIdentifier(nodeName3));
+ YangInstanceIdentifier id2 = YangInstanceIdentifier.create(new NodeIdentifier(nodeName1), new NodeIdentifier(nodeName2));
+ YangInstanceIdentifier id3 = YangInstanceIdentifier.create(new NodeIdentifier(nodeName1), new NodeIdentifier(nodeName2));
+ YangInstanceIdentifier id4 = YangInstanceIdentifier.create(new NodeIdentifier(nodeName1), new NodeIdentifier(nodeName3));
assertEquals( "contains", true, id2.contains( id1 ) );
assertEquals( "contains", true, id2.contains( id3 ) );
@Test
public void testOf() {
- InstanceIdentifier newID = InstanceIdentifier.of( nodeName1 );
+ YangInstanceIdentifier newID = YangInstanceIdentifier.of( nodeName1 );
assertNotNull( "InstanceIdentifier is null", newID );
assertEquals( "Path size", 1, Iterables.size(newID.getPathArguments()) );
@Test
public void testBuilder() {
- InstanceIdentifier newID = InstanceIdentifier.builder()
+ YangInstanceIdentifier newID = YangInstanceIdentifier.builder()
.node( nodeName1 )
.nodeWithKey( nodeName2, Collections.<QName,Object>singletonMap( key1, "foo" ) )
.nodeWithKey( nodeName3, key2, "bar" ).build();
verifyNodeIdentifierWithPredicates( "PathArg 2", it.next(), nodeName2, key1, "foo" );
verifyNodeIdentifierWithPredicates( "PathArg 3", it.next(), nodeName3, key2, "bar" );
- newID = InstanceIdentifier.builder( newID ).node( nodeName4 ).build();
+ newID = YangInstanceIdentifier.builder( newID ).node( nodeName4 ).build();
assertNotNull( "InstanceIdentifier is null", newID );
assertEquals( "Path size", 4, Iterables.size(newID.getPathArguments()) );
assertEquals( "PathArg 3 node type", nodeName3, it.next().getNodeType() );
assertEquals( "PathArg 4 node type", nodeName4, it.next().getNodeType() );
- newID = InstanceIdentifier.builder( nodeName1 ).build();
+ newID = YangInstanceIdentifier.builder( nodeName1 ).build();
assertNotNull( "InstanceIdentifier is null", newID );
assertEquals( "Path size", 1, Iterables.size(newID.getPathArguments()) );
* class object
* @return data schema node identifier
*/
- Entry<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> toDataDom(
+ Entry<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, CompositeNode> toDataDom(
Entry<InstanceIdentifier<? extends DataObject>, DataObject> entry);
/**
* class object identifier
* @return data schema node identifier
*/
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier toDataDom(InstanceIdentifier<? extends DataObject> path);
+ org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier toDataDom(InstanceIdentifier<? extends DataObject> path);
/**
* Create DataObject instance from CompositeNode data based on given path.
* data schema node identifier
* @return class object identifier
*/
- InstanceIdentifier<?> fromDataDom(org.opendaylight.yangtools.yang.data.api.InstanceIdentifier entry)
+ InstanceIdentifier<?> fromDataDom(org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier entry)
throws DeserializationException;
/**
import org.opendaylight.yangtools.yang.binding.BindingCodec;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-public interface InstanceIdentifierCodec extends BindingCodec<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier,InstanceIdentifier<?>> {
+public interface InstanceIdentifierCodec extends BindingCodec<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier,InstanceIdentifier<?>> {
@Override
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier serialize(InstanceIdentifier<?> input);
+ org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier serialize(InstanceIdentifier<?> input);
@Override
- InstanceIdentifier<?> deserialize(org.opendaylight.yangtools.yang.data.api.InstanceIdentifier input);
+ InstanceIdentifier<?> deserialize(org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier input);
}
import java.util.regex.Pattern;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.w3c.dom.Element;
throw new UnsupportedOperationException("Utility class");
}
- public static InstanceIdentifier deserialize(final Element element, final SchemaContext schemaContext) {
+ public static YangInstanceIdentifier deserialize(final Element element, final SchemaContext schemaContext) {
Preconditions.checkNotNull(element, "Value of element for deserialization can't be null");
Preconditions.checkNotNull(schemaContext,
"Schema context for deserialization of instance identifier type can't be null");
result.add(pathArgument);
}
}
- return InstanceIdentifier.create(result);
+ return YangInstanceIdentifier.create(result);
}
- public static Element serialize(final InstanceIdentifier id, final Element element) {
+ public static Element serialize(final YangInstanceIdentifier id, final Element element) {
Preconditions.checkNotNull(id, "Variable should contain instance of instance identifier and can't be null");
Preconditions.checkNotNull(element, "DOM element can't be null");
}
if (predicates.isEmpty()) {
- return new InstanceIdentifier.NodeIdentifier(mainQName);
+ return new YangInstanceIdentifier.NodeIdentifier(mainQName);
} else {
- return new InstanceIdentifier.NodeIdentifierWithPredicates(mainQName, predicates);
+ return new YangInstanceIdentifier.NodeIdentifierWithPredicates(mainQName, predicates);
}
}
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.AttributesContainer;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.Node;
import org.opendaylight.yangtools.yang.data.api.SimpleNode;
import org.opendaylight.yangtools.yang.data.impl.codec.TypeDefinitionAwareCodec;
* @param id InstanceIdentifier
* @throws XMLStreamException
*/
- public static void write(final @Nonnull XMLStreamWriter writer, final @Nonnull InstanceIdentifier id) throws XMLStreamException {
+ public static void write(final @Nonnull XMLStreamWriter writer, final @Nonnull YangInstanceIdentifier id) throws XMLStreamException {
Preconditions.checkNotNull(writer, "Writer may not be null");
Preconditions.checkNotNull(id, "Variable should contain instance of instance identifier and can't be null");
}
private static void write(final @Nonnull XMLStreamWriter writer, final @Nonnull InstanceIdentifierTypeDefinition type, final @Nonnull Object value) throws XMLStreamException {
- if (value instanceof InstanceIdentifier) {
- write(writer, (InstanceIdentifier)value);
+ if (value instanceof YangInstanceIdentifier) {
+ write(writer, (YangInstanceIdentifier)value);
} else {
LOG.debug("Value of {}:{} is not an InstanceIdentifier but {}", type.getQName().getNamespace(), type.getQName().getLocalName(), value.getClass());
writer.writeCharacters(String.valueOf(value));
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifierWithPredicates;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeWithValue;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.impl.codec.TypeDefinitionAwareCodec;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
return superType;
}
- static String encodeIdentifier(final RandomPrefix prefixes, final InstanceIdentifier id) {
+ static String encodeIdentifier(final RandomPrefix prefixes, final YangInstanceIdentifier id) {
StringBuilder textContent = new StringBuilder();
for (PathArgument pathArgument : id.getPathArguments()) {
textContent.append('/');
*/
package org.opendaylight.yangtools.yang.data.impl.schema;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.Node;
import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
throw new UnsupportedOperationException("Utilities class should not be instantiated");
}
- public static <T> NormalizedNodeAttrBuilder<InstanceIdentifier.NodeIdentifier, T, LeafNode<T>> leafBuilder() {
+ public static <T> NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, T, LeafNode<T>> leafBuilder() {
return ImmutableLeafNodeBuilder.create();
}
- public static <T> NormalizedNodeAttrBuilder<InstanceIdentifier.NodeIdentifier, T, LeafNode<T>> leafBuilder(
+ public static <T> NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, T, LeafNode<T>> leafBuilder(
final LeafSchemaNode schema) {
return ImmutableLeafNodeSchemaAwareBuilder.create(schema);
}
- public static <T> NormalizedNodeAttrBuilder<InstanceIdentifier.NodeWithValue, T, LeafSetEntryNode<T>> leafSetEntryBuilder() {
+ public static <T> NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeWithValue, T, LeafSetEntryNode<T>> leafSetEntryBuilder() {
return ImmutableLeafSetEntryNodeBuilder.create();
}
- public static <T> NormalizedNodeAttrBuilder<InstanceIdentifier.NodeWithValue, T, LeafSetEntryNode<T>> leafSetEntryBuilder(
+ public static <T> NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeWithValue, T, LeafSetEntryNode<T>> leafSetEntryBuilder(
final LeafListSchemaNode schema) {
return ImmutableLeafSetEntryNodeSchemaAwareBuilder.create(schema);
}
- public static <T> NormalizedNodeAttrBuilder<InstanceIdentifier.NodeIdentifier, Node<?>, AnyXmlNode> anyXmlBuilder() {
+ public static <T> NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, Node<?>, AnyXmlNode> anyXmlBuilder() {
return ImmutableAnyXmlNodeBuilder.create();
}
- public static <T> NormalizedNodeAttrBuilder<InstanceIdentifier.NodeIdentifier, Node<?>, AnyXmlNode> anyXmlBuilder(
+ public static <T> NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, Node<?>, AnyXmlNode> anyXmlBuilder(
final AnyXmlSchemaNode schema) {
return ImmutableAnyXmlNodeSchemaAwareBuilder.create(schema);
}
return ImmutableLeafSetNodeSchemaAwareBuilder.<T>create(schema, node);
}
- public static DataContainerNodeAttrBuilder<InstanceIdentifier.NodeIdentifier, ContainerNode> containerBuilder() {
+ public static DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode> containerBuilder() {
return ImmutableContainerNodeBuilder.create();
}
- public static DataContainerNodeAttrBuilder<InstanceIdentifier.NodeIdentifier, ContainerNode> containerBuilder(final ContainerNode node) {
+ public static DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode> containerBuilder(final ContainerNode node) {
return ImmutableContainerNodeBuilder.create(node);
}
- public static DataContainerNodeAttrBuilder<InstanceIdentifier.NodeIdentifier, ContainerNode> containerBuilder(
+ public static DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode> containerBuilder(
final ContainerSchemaNode schema) {
return ImmutableContainerNodeSchemaAwareBuilder.create(schema);
}
- public static DataContainerNodeAttrBuilder<InstanceIdentifier.NodeIdentifier, ContainerNode> containerBuilder(
+ public static DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode> containerBuilder(
final ContainerSchemaNode schema, final ContainerNode node) {
return ImmutableContainerNodeSchemaAwareBuilder.create(schema, node);
}
- public static DataContainerNodeAttrBuilder<InstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder() {
+ public static DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder() {
return ImmutableMapEntryNodeBuilder.create();
}
- public static DataContainerNodeAttrBuilder<InstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder(
+ public static DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder(
final ListSchemaNode schema) {
return ImmutableMapEntryNodeSchemaAwareBuilder.create(schema);
}
return ImmutableMapNodeSchemaAwareBuilder.create(schema, node);
}
- public static DataContainerNodeBuilder<InstanceIdentifier.AugmentationIdentifier, AugmentationNode> augmentationBuilder() {
+ public static DataContainerNodeBuilder<YangInstanceIdentifier.AugmentationIdentifier, AugmentationNode> augmentationBuilder() {
return ImmutableAugmentationNodeBuilder.create();
}
- public static DataContainerNodeBuilder<InstanceIdentifier.AugmentationIdentifier, AugmentationNode> augmentationBuilder(final AugmentationSchema schema) {
+ public static DataContainerNodeBuilder<YangInstanceIdentifier.AugmentationIdentifier, AugmentationNode> augmentationBuilder(final AugmentationSchema schema) {
return ImmutableAugmentationNodeSchemaAwareBuilder.create(schema);
}
- public static DataContainerNodeBuilder<InstanceIdentifier.NodeIdentifier, ChoiceNode> choiceBuilder() {
+ public static DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifier, ChoiceNode> choiceBuilder() {
return ImmutableChoiceNodeBuilder.create();
}
- public static DataContainerNodeBuilder<InstanceIdentifier.NodeIdentifier, ChoiceNode> choiceBuilder(final org.opendaylight.yangtools.yang.model.api.ChoiceNode schema) {
+ public static DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifier, ChoiceNode> choiceBuilder(final org.opendaylight.yangtools.yang.model.api.ChoiceNode schema) {
return ImmutableChoiceNodeSchemaAwareBuilder.create(schema);
}
- public static DataContainerNodeAttrBuilder<InstanceIdentifier.NodeIdentifier, UnkeyedListEntryNode> unkeyedListEntryBuilder() {
+ public static DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, UnkeyedListEntryNode> unkeyedListEntryBuilder() {
return ImmutableUnkeyedListEntryNodeBuilder.create();
}
package org.opendaylight.yangtools.yang.data.impl.schema;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
import java.util.Iterator;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifierWithPredicates;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeWithValue;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
throw new UnsupportedOperationException("Utilities class should not be instantiated");
}
- public static Optional<NormalizedNode<?, ?>> findNode(final InstanceIdentifier rootPath, final NormalizedNode<?, ?> rootNode, final InstanceIdentifier childPath) {
- final Optional<InstanceIdentifier> relativePath = childPath.relativeTo(rootPath);
+ public static Optional<NormalizedNode<?, ?>> findNode(final YangInstanceIdentifier rootPath, final NormalizedNode<?, ?> rootNode, final YangInstanceIdentifier childPath) {
+ final Optional<YangInstanceIdentifier> relativePath = childPath.relativeTo(rootPath);
if (relativePath.isPresent()) {
return findNode(rootNode, relativePath.get());
} else {
}
}
- public static Optional<NormalizedNode<?, ?>> findNode(final NormalizedNode<?, ?> tree, final InstanceIdentifier path) {
+ public static Optional<NormalizedNode<?, ?>> findNode(final NormalizedNode<?, ?> tree, final YangInstanceIdentifier path) {
checkNotNull(tree, "Tree must not be null");
checkNotNull(path, "Path must not be null");
import java.util.Set;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
for (ChoiceCaseNode choiceCaseNode : schema.getCases()) {
if (child instanceof AugmentationNode
&& belongsToCaseAugment(choiceCaseNode,
- (InstanceIdentifier.AugmentationIdentifier) child.getIdentifier())) {
+ (YangInstanceIdentifier.AugmentationIdentifier) child.getIdentifier())) {
return Optional.of(choiceCaseNode);
} else if (choiceCaseNode.getDataChildByName(child.getNodeType()) != null) {
return Optional.of(choiceCaseNode);
return Optional.absent();
}
- public static boolean belongsToCaseAugment(final ChoiceCaseNode caseNode, final InstanceIdentifier.AugmentationIdentifier childToProcess) {
+ public static boolean belongsToCaseAugment(final ChoiceCaseNode caseNode, final YangInstanceIdentifier.AugmentationIdentifier childToProcess) {
for (AugmentationSchema augmentationSchema : caseNode.getAvailableAugmentations()) {
Set<QName> currentAugmentChildNodes = Sets.newHashSet();
return false;
}
- public static InstanceIdentifier.AugmentationIdentifier getNodeIdentifierForAugmentation(final AugmentationSchema schema) {
- return new InstanceIdentifier.AugmentationIdentifier(getChildQNames(schema));
+ public static YangInstanceIdentifier.AugmentationIdentifier getNodeIdentifierForAugmentation(final AugmentationSchema schema) {
+ return new YangInstanceIdentifier.AugmentationIdentifier(getChildQNames(schema));
}
public static Set<QName> getChildQNames(final AugmentationSchema schema) {
import java.util.List;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-public interface CollectionNodeBuilder<V extends NormalizedNode<?, ?>, R extends NormalizedNode<InstanceIdentifier.NodeIdentifier, ?>>
+public interface CollectionNodeBuilder<V extends NormalizedNode<?, ?>, R extends NormalizedNode<YangInstanceIdentifier.NodeIdentifier, ?>>
extends NormalizedNodeContainerBuilder<NodeIdentifier,PathArgument, V, R> {
@Override
CollectionNodeBuilder<V, R> withValue(List<V> value);
@Override
- CollectionNodeBuilder<V, R> withNodeIdentifier(InstanceIdentifier.NodeIdentifier nodeIdentifier);
+ CollectionNodeBuilder<V, R> withNodeIdentifier(YangInstanceIdentifier.NodeIdentifier nodeIdentifier);
CollectionNodeBuilder<V, R> withChild(V child);
- CollectionNodeBuilder<V, R> withoutChild(InstanceIdentifier.PathArgument key);
+ CollectionNodeBuilder<V, R> withoutChild(YangInstanceIdentifier.PathArgument key);
}
import java.util.List;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode;
-public interface DataContainerNodeAttrBuilder<I extends InstanceIdentifier.PathArgument, R extends DataContainerNode<I>>
+public interface DataContainerNodeAttrBuilder<I extends YangInstanceIdentifier.PathArgument, R extends DataContainerNode<I>>
extends DataContainerNodeBuilder<I, R>,
AttributesBuilder<DataContainerNodeAttrBuilder<I, R>> {
@Override
- DataContainerNodeAttrBuilder<I, R> withValue(List<DataContainerChild<? extends InstanceIdentifier.PathArgument, ?>> value);
+ DataContainerNodeAttrBuilder<I, R> withValue(List<DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?>> value);
@Override
DataContainerNodeAttrBuilder<I, R> withNodeIdentifier(I nodeIdentifier);
import java.util.List;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode;
-public interface DataContainerNodeBuilder<I extends InstanceIdentifier.PathArgument, R extends DataContainerNode<I>>
+public interface DataContainerNodeBuilder<I extends YangInstanceIdentifier.PathArgument, R extends DataContainerNode<I>>
extends NormalizedNodeContainerBuilder<I, PathArgument, DataContainerChild<? extends PathArgument, ?>, R> {
@Override
- DataContainerNodeBuilder<I, R> withValue(List<DataContainerChild<? extends InstanceIdentifier.PathArgument, ?>> value);
+ DataContainerNodeBuilder<I, R> withValue(List<DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?>> value);
@Override
DataContainerNodeBuilder<I, R> withNodeIdentifier(I nodeIdentifier);
import java.util.Map;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
extends CollectionNodeBuilder<LeafSetEntryNode<T>, LeafSetNode<T>> {
@Override
- ListNodeBuilder<T, V> withNodeIdentifier(InstanceIdentifier.NodeIdentifier nodeIdentifier);
+ ListNodeBuilder<T, V> withNodeIdentifier(YangInstanceIdentifier.NodeIdentifier nodeIdentifier);
@Override
ListNodeBuilder<T, V> withValue(List<LeafSetEntryNode<T>> value);
ListNodeBuilder<T, V> withChild(LeafSetEntryNode<T> child);
@Override
- ListNodeBuilder<T, V> withoutChild(InstanceIdentifier.PathArgument key);
+ ListNodeBuilder<T, V> withoutChild(YangInstanceIdentifier.PathArgument key);
ListNodeBuilder<T, V> withChildValue(T child);
*/
package org.opendaylight.yangtools.yang.data.impl.schema.builder.api;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-public interface NormalizedNodeAttrBuilder<I extends InstanceIdentifier.PathArgument, V, R extends NormalizedNode<I, ?>>
+public interface NormalizedNodeAttrBuilder<I extends YangInstanceIdentifier.PathArgument, V, R extends NormalizedNode<I, ?>>
extends AttributesBuilder<NormalizedNodeAttrBuilder<I, V, R>>,
NormalizedNodeBuilder<I, V, R> {
*/
package org.opendaylight.yangtools.yang.data.impl.schema.builder.api;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-public interface NormalizedNodeBuilder<I extends InstanceIdentifier.PathArgument, V, R extends NormalizedNode<I, ?>> {
+public interface NormalizedNodeBuilder<I extends YangInstanceIdentifier.PathArgument, V, R extends NormalizedNode<I, ?>> {
NormalizedNodeBuilder<I, V, R> withValue(V value);
import java.util.List;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
public interface NormalizedNodeContainerBuilder<K extends PathArgument,CK extends PathArgument,CV extends NormalizedNode<? extends CK, ?>,P extends NormalizedNode<K, ?>>
import java.util.Map;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.nodes.AbstractImmutableDataContainerAttrNode;
-abstract class AbstractImmutableDataContainerNodeAttrBuilder<I extends InstanceIdentifier.PathArgument, R extends DataContainerNode<I>>
+abstract class AbstractImmutableDataContainerNodeAttrBuilder<I extends YangInstanceIdentifier.PathArgument, R extends DataContainerNode<I>>
extends AbstractImmutableDataContainerNodeBuilder<I, R>
implements DataContainerNodeAttrBuilder<I, R> {
}
@Override
- public DataContainerNodeAttrBuilder<I, R> withValue(final List<DataContainerChild<? extends InstanceIdentifier.PathArgument, ?>> value) {
+ public DataContainerNodeAttrBuilder<I, R> withValue(final List<DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?>> value) {
return (DataContainerNodeAttrBuilder<I, R>) super.withValue(value);
}
import java.util.List;
import java.util.Map;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeContainerBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.nodes.AbstractImmutableDataContainerNode;
-abstract class AbstractImmutableDataContainerNodeBuilder<I extends InstanceIdentifier.PathArgument, R extends DataContainerNode<I>>
+abstract class AbstractImmutableDataContainerNodeBuilder<I extends YangInstanceIdentifier.PathArgument, R extends DataContainerNode<I>>
implements DataContainerNodeBuilder<I, R> {
- private Map<InstanceIdentifier.PathArgument, DataContainerChild<? extends InstanceIdentifier.PathArgument, ?>> value;
+ private Map<YangInstanceIdentifier.PathArgument, DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?>> value;
private I nodeIdentifier;
/*
}
@Override
- public DataContainerNodeBuilder<I, R> withValue(final List<DataContainerChild<? extends InstanceIdentifier.PathArgument, ?>> value) {
+ public DataContainerNodeBuilder<I, R> withValue(final List<DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?>> value) {
// TODO Replace or putAll ?
- for (final DataContainerChild<? extends InstanceIdentifier.PathArgument, ?> dataContainerChild : value) {
+ for (final DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataContainerChild : value) {
withChild(dataContainerChild);
}
return this;
import java.util.Map;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeAttrBuilder;
-abstract class AbstractImmutableNormalizedNodeBuilder<I extends InstanceIdentifier.PathArgument, V, R extends NormalizedNode<I, ?>>
+abstract class AbstractImmutableNormalizedNodeBuilder<I extends YangInstanceIdentifier.PathArgument, V, R extends NormalizedNode<I, ?>>
implements NormalizedNodeAttrBuilder<I,V,R> {
private Map<QName, String> attributes = Collections.emptyMap();
import java.util.Map;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.Node;
import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeAttrBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.nodes.AbstractImmutableNormalizedValueAttrNode;
-public class ImmutableAnyXmlNodeBuilder extends AbstractImmutableNormalizedNodeBuilder<InstanceIdentifier.NodeIdentifier, Node<?>, AnyXmlNode> {
+public class ImmutableAnyXmlNodeBuilder extends AbstractImmutableNormalizedNodeBuilder<YangInstanceIdentifier.NodeIdentifier, Node<?>, AnyXmlNode> {
- public static NormalizedNodeAttrBuilder<InstanceIdentifier.NodeIdentifier, Node<?>, AnyXmlNode> create() {
+ public static NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, Node<?>, AnyXmlNode> create() {
return new ImmutableAnyXmlNodeBuilder();
}
return new ImmutableXmlNode(getNodeIdentifier(), getValue(), getAttributes());
}
- private static final class ImmutableXmlNode extends AbstractImmutableNormalizedValueAttrNode<InstanceIdentifier.NodeIdentifier, Node<?>> implements AnyXmlNode {
+ private static final class ImmutableXmlNode extends AbstractImmutableNormalizedValueAttrNode<YangInstanceIdentifier.NodeIdentifier, Node<?>> implements AnyXmlNode {
- ImmutableXmlNode(final InstanceIdentifier.NodeIdentifier nodeIdentifier, final Node<?> value, final Map<QName, String> attributes) {
+ ImmutableXmlNode(final YangInstanceIdentifier.NodeIdentifier nodeIdentifier, final Node<?> value, final Map<QName, String> attributes) {
super(nodeIdentifier, value, attributes);
}
}
*/
package org.opendaylight.yangtools.yang.data.impl.schema.builder.impl;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.Node;
import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeAttrBuilder;
public final class ImmutableAnyXmlNodeSchemaAwareBuilder extends ImmutableAnyXmlNodeBuilder {
private ImmutableAnyXmlNodeSchemaAwareBuilder(AnyXmlSchemaNode schema) {
- super.withNodeIdentifier(new InstanceIdentifier.NodeIdentifier(schema.getQName()));
+ super.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(schema.getQName()));
}
- public static NormalizedNodeAttrBuilder<InstanceIdentifier.NodeIdentifier, Node<?>, AnyXmlNode> create(AnyXmlSchemaNode schema) {
+ public static NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, Node<?>, AnyXmlNode> create(AnyXmlSchemaNode schema) {
return new ImmutableAnyXmlNodeSchemaAwareBuilder(schema);
}
@Override
- public NormalizedNodeAttrBuilder<InstanceIdentifier.NodeIdentifier, Node<?>, AnyXmlNode> withValue(Node<?> value) {
+ public NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, Node<?>, AnyXmlNode> withValue(Node<?> value) {
return super.withValue(value);
}
@Override
- public NormalizedNodeAttrBuilder<InstanceIdentifier.NodeIdentifier, Node<?>, AnyXmlNode> withNodeIdentifier(InstanceIdentifier.NodeIdentifier nodeIdentifier) {
+ public NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, Node<?>, AnyXmlNode> withNodeIdentifier(YangInstanceIdentifier.NodeIdentifier nodeIdentifier) {
throw new UnsupportedOperationException("Node identifier created from schema");
}
}
import java.util.Map;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.AugmentationIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.nodes.AbstractImmutableDataContainerNode;
public class ImmutableAugmentationNodeBuilder
- extends AbstractImmutableDataContainerNodeBuilder<InstanceIdentifier.AugmentationIdentifier, AugmentationNode> {
+ extends AbstractImmutableDataContainerNodeBuilder<YangInstanceIdentifier.AugmentationIdentifier, AugmentationNode> {
protected ImmutableAugmentationNodeBuilder() {
super();
super(node);
}
- public static DataContainerNodeBuilder<InstanceIdentifier.AugmentationIdentifier, AugmentationNode> create() {
+ public static DataContainerNodeBuilder<YangInstanceIdentifier.AugmentationIdentifier, AugmentationNode> create() {
return new ImmutableAugmentationNodeBuilder();
}
- public static DataContainerNodeBuilder<InstanceIdentifier.AugmentationIdentifier, AugmentationNode> create(AugmentationNode node) {
+ public static DataContainerNodeBuilder<YangInstanceIdentifier.AugmentationIdentifier, AugmentationNode> create(AugmentationNode node) {
if (!(node instanceof ImmutableAugmentationNode)) {
throw new UnsupportedOperationException(String.format("Cannot initialize from class %s", node.getClass()));
}
}
@Override
- public DataContainerNodeBuilder<InstanceIdentifier.AugmentationIdentifier, AugmentationNode> withChild(
+ public DataContainerNodeBuilder<YangInstanceIdentifier.AugmentationIdentifier, AugmentationNode> withChild(
final DataContainerChild<?, ?> child) {
// Check nested augments
DataValidationException.checkLegalData(child instanceof AugmentationNode == false,
}
private static final class ImmutableAugmentationNode
- extends AbstractImmutableDataContainerNode<InstanceIdentifier.AugmentationIdentifier>
+ extends AbstractImmutableDataContainerNode<YangInstanceIdentifier.AugmentationIdentifier>
implements AugmentationNode {
- ImmutableAugmentationNode(final InstanceIdentifier.AugmentationIdentifier nodeIdentifier, final Map<InstanceIdentifier.PathArgument, DataContainerChild<? extends InstanceIdentifier.PathArgument, ?>> children) {
+ ImmutableAugmentationNode(final YangInstanceIdentifier.AugmentationIdentifier nodeIdentifier, final Map<YangInstanceIdentifier.PathArgument, DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?>> children) {
super(children, nodeIdentifier);
}
}
*/
package org.opendaylight.yangtools.yang.data.impl.schema.builder.impl;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
}
@Override
- public DataContainerNodeBuilder<InstanceIdentifier.AugmentationIdentifier, AugmentationNode> withNodeIdentifier(InstanceIdentifier.AugmentationIdentifier nodeIdentifier) {
+ public DataContainerNodeBuilder<YangInstanceIdentifier.AugmentationIdentifier, AugmentationNode> withNodeIdentifier(YangInstanceIdentifier.AugmentationIdentifier nodeIdentifier) {
throw new UnsupportedOperationException("Node identifier created from schema");
}
@Override
- public DataContainerNodeBuilder<InstanceIdentifier.AugmentationIdentifier, AugmentationNode> withChild(DataContainerChild<?, ?> child) {
+ public DataContainerNodeBuilder<YangInstanceIdentifier.AugmentationIdentifier, AugmentationNode> withChild(DataContainerChild<?, ?> child) {
return super.withChild(validator.validateChild(child));
}
- public static DataContainerNodeBuilder<InstanceIdentifier.AugmentationIdentifier, AugmentationNode> create(AugmentationSchema schema) {
+ public static DataContainerNodeBuilder<YangInstanceIdentifier.AugmentationIdentifier, AugmentationNode> create(AugmentationSchema schema) {
return new ImmutableAugmentationNodeSchemaAwareBuilder(schema);
}
import java.util.Map;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.nodes.AbstractImmutableDataContainerNode;
-public class ImmutableChoiceNodeBuilder extends AbstractImmutableDataContainerNodeBuilder<InstanceIdentifier.NodeIdentifier, ChoiceNode> {
+public class ImmutableChoiceNodeBuilder extends AbstractImmutableDataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifier, ChoiceNode> {
protected ImmutableChoiceNodeBuilder() {
super();
super(node);
}
- public static DataContainerNodeBuilder<InstanceIdentifier.NodeIdentifier, ChoiceNode> create() {
+ public static DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifier, ChoiceNode> create() {
return new ImmutableChoiceNodeBuilder();
}
- public static DataContainerNodeBuilder<InstanceIdentifier.NodeIdentifier, ChoiceNode> create(final ChoiceNode node) {
+ public static DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifier, ChoiceNode> create(final ChoiceNode node) {
if (!(node instanceof ImmutableChoiceNode)) {
throw new UnsupportedOperationException(String.format("Cannot initialize from class %s", node.getClass()));
}
}
private static final class ImmutableChoiceNode
- extends AbstractImmutableDataContainerNode<InstanceIdentifier.NodeIdentifier>
+ extends AbstractImmutableDataContainerNode<YangInstanceIdentifier.NodeIdentifier>
implements ChoiceNode {
- ImmutableChoiceNode(final InstanceIdentifier.NodeIdentifier nodeIdentifier,
- final Map<InstanceIdentifier.PathArgument, DataContainerChild<? extends InstanceIdentifier.PathArgument, ?>> children) {
+ ImmutableChoiceNode(final YangInstanceIdentifier.NodeIdentifier nodeIdentifier,
+ final Map<YangInstanceIdentifier.PathArgument, DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?>> children) {
super(children, nodeIdentifier);
}
}
package org.opendaylight.yangtools.yang.data.impl.schema.builder.impl;
import com.google.common.base.Optional;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
protected ImmutableChoiceNodeSchemaAwareBuilder(org.opendaylight.yangtools.yang.model.api.ChoiceNode schema) {
this.schema = Preconditions.checkNotNull(schema, "Schema was null");
- super.withNodeIdentifier(new InstanceIdentifier.NodeIdentifier(schema.getQName()));
+ super.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(schema.getQName()));
}
@Override
- public DataContainerNodeBuilder<InstanceIdentifier.NodeIdentifier, ChoiceNode> withNodeIdentifier(InstanceIdentifier.NodeIdentifier nodeIdentifier) {
+ public DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifier, ChoiceNode> withNodeIdentifier(YangInstanceIdentifier.NodeIdentifier nodeIdentifier) {
throw new UnsupportedOperationException("Node identifier created from schema");
}
@Override
- public DataContainerNodeBuilder<InstanceIdentifier.NodeIdentifier, ChoiceNode> withChild(final DataContainerChild<?, ?> child) {
+ public DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifier, ChoiceNode> withChild(final DataContainerChild<?, ?> child) {
if(validator == null) {
Optional<ChoiceCaseNode> detectedCaseOpt = SchemaUtils.detectCase(schema, child);
DataValidationException.checkLegalChild(detectedCaseOpt.isPresent(), child.getIdentifier(), schema);
return super.build();
}
- public static DataContainerNodeBuilder<InstanceIdentifier.NodeIdentifier, ChoiceNode> create(org.opendaylight.yangtools.yang.model.api.ChoiceNode schema) {
+ public static DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifier, ChoiceNode> create(org.opendaylight.yangtools.yang.model.api.ChoiceNode schema) {
return new ImmutableChoiceNodeSchemaAwareBuilder(schema);
}
}
import java.util.Map;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.nodes.AbstractImmutableDataContainerAttrNode;
public class ImmutableContainerNodeBuilder extends
- AbstractImmutableDataContainerNodeAttrBuilder<InstanceIdentifier.NodeIdentifier, ContainerNode> {
+ AbstractImmutableDataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode> {
protected ImmutableContainerNodeBuilder() {
super();
super(node);
}
- public static DataContainerNodeAttrBuilder<InstanceIdentifier.NodeIdentifier, ContainerNode> create() {
+ public static DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode> create() {
return new ImmutableContainerNodeBuilder();
}
- public static DataContainerNodeAttrBuilder<InstanceIdentifier.NodeIdentifier, ContainerNode> create(final ContainerNode node) {
+ public static DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode> create(final ContainerNode node) {
if (!(node instanceof ImmutableContainerNode)) {
throw new UnsupportedOperationException(String.format("Cannot initialize from class %s", node.getClass()));
}
}
protected static final class ImmutableContainerNode extends
- AbstractImmutableDataContainerAttrNode<InstanceIdentifier.NodeIdentifier> implements ContainerNode {
+ AbstractImmutableDataContainerAttrNode<YangInstanceIdentifier.NodeIdentifier> implements ContainerNode {
ImmutableContainerNode(
- final InstanceIdentifier.NodeIdentifier nodeIdentifier,
- final Map<InstanceIdentifier.PathArgument, DataContainerChild<? extends InstanceIdentifier.PathArgument, ?>> children,
+ final YangInstanceIdentifier.NodeIdentifier nodeIdentifier,
+ final Map<YangInstanceIdentifier.PathArgument, DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?>> children,
final Map<QName, String> attributes) {
super(children, nodeIdentifier, attributes);
}
*/
package org.opendaylight.yangtools.yang.data.impl.schema.builder.impl;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
private ImmutableContainerNodeSchemaAwareBuilder(final ContainerSchemaNode schema) {
this.validator = new DataNodeContainerValidator(schema);
- super.withNodeIdentifier(new InstanceIdentifier.NodeIdentifier(schema.getQName()));
+ super.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(schema.getQName()));
}
private ImmutableContainerNodeSchemaAwareBuilder(final ContainerSchemaNode schema, final ImmutableContainerNode node) {
super(node);
this.validator = new DataNodeContainerValidator(schema);
- super.withNodeIdentifier(new InstanceIdentifier.NodeIdentifier(schema.getQName()));
+ super.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(schema.getQName()));
}
- public static DataContainerNodeAttrBuilder<InstanceIdentifier.NodeIdentifier, ContainerNode> create(final ContainerSchemaNode schema) {
+ public static DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode> create(final ContainerSchemaNode schema) {
return new ImmutableContainerNodeSchemaAwareBuilder(schema);
}
- public static DataContainerNodeAttrBuilder<InstanceIdentifier.NodeIdentifier, ContainerNode> create(final ContainerSchemaNode schema, final ContainerNode node) {
+ public static DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode> create(final ContainerSchemaNode schema, final ContainerNode node) {
if (!(node instanceof ImmutableContainerNode)) {
throw new UnsupportedOperationException(String.format("Cannot initialize from class %s", node.getClass()));
}
}
@Override
- public DataContainerNodeAttrBuilder<InstanceIdentifier.NodeIdentifier, ContainerNode> withNodeIdentifier(final InstanceIdentifier.NodeIdentifier nodeIdentifier) {
+ public DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode> withNodeIdentifier(final YangInstanceIdentifier.NodeIdentifier nodeIdentifier) {
throw new UnsupportedOperationException("Node identifier created from schema");
}
@Override
- public DataContainerNodeAttrBuilder<InstanceIdentifier.NodeIdentifier, ContainerNode> withChild(final DataContainerChild<?, ?> child) {
+ public DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode> withChild(final DataContainerChild<?, ?> child) {
validator.validateChild(child.getIdentifier());
return super.withChild(child);
}
import java.util.Map;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeAttrBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.nodes.AbstractImmutableNormalizedValueAttrNode;
-public class ImmutableLeafNodeBuilder<T> extends AbstractImmutableNormalizedNodeBuilder<InstanceIdentifier.NodeIdentifier, T, LeafNode<T>> {
+public class ImmutableLeafNodeBuilder<T> extends AbstractImmutableNormalizedNodeBuilder<YangInstanceIdentifier.NodeIdentifier, T, LeafNode<T>> {
- public static <T> NormalizedNodeAttrBuilder<InstanceIdentifier.NodeIdentifier, T, LeafNode<T>> create() {
+ public static <T> NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, T, LeafNode<T>> create() {
return new ImmutableLeafNodeBuilder<>();
}
return new ImmutableLeafNode<>(getNodeIdentifier(), getValue(), getAttributes());
}
- private static final class ImmutableLeafNode<T> extends AbstractImmutableNormalizedValueAttrNode<InstanceIdentifier.NodeIdentifier, T> implements LeafNode<T> {
+ private static final class ImmutableLeafNode<T> extends AbstractImmutableNormalizedValueAttrNode<YangInstanceIdentifier.NodeIdentifier, T> implements LeafNode<T> {
- ImmutableLeafNode(final InstanceIdentifier.NodeIdentifier nodeIdentifier, final T value, final Map<QName, String> attributes) {
+ ImmutableLeafNode(final YangInstanceIdentifier.NodeIdentifier nodeIdentifier, final T value, final Map<QName, String> attributes) {
super(nodeIdentifier, value, attributes);
}
}
*/
package org.opendaylight.yangtools.yang.data.impl.schema.builder.impl;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeAttrBuilder;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
public final class ImmutableLeafNodeSchemaAwareBuilder<T> extends ImmutableLeafNodeBuilder<T> {
private ImmutableLeafNodeSchemaAwareBuilder(LeafSchemaNode schema) {
- super.withNodeIdentifier(new InstanceIdentifier.NodeIdentifier(schema.getQName()));
+ super.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(schema.getQName()));
}
- public static <T> NormalizedNodeAttrBuilder<InstanceIdentifier.NodeIdentifier, T, LeafNode<T>> create(LeafSchemaNode schema) {
+ public static <T> NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, T, LeafNode<T>> create(LeafSchemaNode schema) {
return new ImmutableLeafNodeSchemaAwareBuilder<>(schema);
}
@Override
- public NormalizedNodeAttrBuilder<InstanceIdentifier.NodeIdentifier, T, LeafNode<T>> withValue(T value) {
+ public NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, T, LeafNode<T>> withValue(T value) {
// TODO check value type
return super.withValue(value);
}
@Override
- public NormalizedNodeAttrBuilder<InstanceIdentifier.NodeIdentifier, T, LeafNode<T>> withNodeIdentifier(InstanceIdentifier.NodeIdentifier nodeIdentifier) {
+ public NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, T, LeafNode<T>> withNodeIdentifier(YangInstanceIdentifier.NodeIdentifier nodeIdentifier) {
throw new UnsupportedOperationException("Node identifier created from schema");
}
}
import java.util.Map;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
import org.opendaylight.yangtools.yang.data.impl.schema.nodes.AbstractImmutableNormalizedValueAttrNode;
import com.google.common.base.Preconditions;
-public class ImmutableLeafSetEntryNodeBuilder<T> extends AbstractImmutableNormalizedNodeBuilder<InstanceIdentifier.NodeWithValue, T, LeafSetEntryNode<T>> {
+public class ImmutableLeafSetEntryNodeBuilder<T> extends AbstractImmutableNormalizedNodeBuilder<YangInstanceIdentifier.NodeWithValue, T, LeafSetEntryNode<T>> {
public static <T> ImmutableLeafSetEntryNodeBuilder<T> create() {
return new ImmutableLeafSetEntryNodeBuilder<>();
return new ImmutableLeafSetEntryNode<>(getNodeIdentifier(), getValue(), getAttributes());
}
- private static final class ImmutableLeafSetEntryNode<T> extends AbstractImmutableNormalizedValueAttrNode<InstanceIdentifier.NodeWithValue, T> implements LeafSetEntryNode<T> {
+ private static final class ImmutableLeafSetEntryNode<T> extends AbstractImmutableNormalizedValueAttrNode<YangInstanceIdentifier.NodeWithValue, T> implements LeafSetEntryNode<T> {
- ImmutableLeafSetEntryNode(final InstanceIdentifier.NodeWithValue nodeIdentifier, final T value, final Map<QName, String> attributes) {
+ ImmutableLeafSetEntryNode(final YangInstanceIdentifier.NodeWithValue nodeIdentifier, final T value, final Map<QName, String> attributes) {
super(nodeIdentifier, value, attributes);
Preconditions.checkArgument(nodeIdentifier.getValue().equals(value),
"Node identifier contains different value: %s than value itself: %s", nodeIdentifier, value);
*/
package org.opendaylight.yangtools.yang.data.impl.schema.builder.impl;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeAttrBuilder;
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
this.schema = Preconditions.checkNotNull(schema);
}
- public static <T> NormalizedNodeAttrBuilder<InstanceIdentifier.NodeWithValue, T, LeafSetEntryNode<T>> create(LeafListSchemaNode schema) {
+ public static <T> NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeWithValue, T, LeafSetEntryNode<T>> create(LeafListSchemaNode schema) {
return new ImmutableLeafSetEntryNodeSchemaAwareBuilder<>(schema);
}
@Override
- public NormalizedNodeAttrBuilder<InstanceIdentifier.NodeWithValue, T, LeafSetEntryNode<T>> withValue(T value) {
- super.withNodeIdentifier(new InstanceIdentifier.NodeWithValue(schema.getQName(), value));
+ public NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeWithValue, T, LeafSetEntryNode<T>> withValue(T value) {
+ super.withNodeIdentifier(new YangInstanceIdentifier.NodeWithValue(schema.getQName(), value));
// TODO check value type using TypeProvider ?
return super.withValue(value);
}
@Override
- public NormalizedNodeAttrBuilder<InstanceIdentifier.NodeWithValue, T, LeafSetEntryNode<T>> withNodeIdentifier(InstanceIdentifier.NodeWithValue nodeIdentifier) {
+ public NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeWithValue, T, LeafSetEntryNode<T>> withNodeIdentifier(YangInstanceIdentifier.NodeWithValue nodeIdentifier) {
throw new UnsupportedOperationException("Node identifier created from schema");
}
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.util.MapAdaptor;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.ListNodeBuilder;
public class ImmutableLeafSetNodeBuilder<T> implements ListNodeBuilder<T, LeafSetEntryNode<T>> {
- private final Map<InstanceIdentifier.NodeWithValue, LeafSetEntryNode<T>> value;
- private InstanceIdentifier.NodeIdentifier nodeIdentifier;
+ private final Map<YangInstanceIdentifier.NodeWithValue, LeafSetEntryNode<T>> value;
+ private YangInstanceIdentifier.NodeIdentifier nodeIdentifier;
protected ImmutableLeafSetNodeBuilder() {
value = new HashMap<>();
@Override
public ListNodeBuilder<T, LeafSetEntryNode<T>> withNodeIdentifier(
- final InstanceIdentifier.NodeIdentifier nodeIdentifier) {
+ final YangInstanceIdentifier.NodeIdentifier nodeIdentifier) {
this.nodeIdentifier = nodeIdentifier;
return this;
}
@Override
public ListNodeBuilder<T, LeafSetEntryNode<T>> withChildValue(final T value, final Map<QName, String> attributes) {
final ImmutableLeafSetEntryNodeBuilder<T> b = ImmutableLeafSetEntryNodeBuilder.create();
- b.withNodeIdentifier(new InstanceIdentifier.NodeWithValue(nodeIdentifier.getNodeType(), value));
+ b.withNodeIdentifier(new YangInstanceIdentifier.NodeWithValue(nodeIdentifier.getNodeType(), value));
b.withValue(value);
b.withAttributes(attributes);
return withChild(b.build());
}
protected final static class ImmutableLeafSetNode<T> extends
- AbstractImmutableNormalizedValueNode<InstanceIdentifier.NodeIdentifier, Iterable<LeafSetEntryNode<T>>> implements
+ AbstractImmutableNormalizedValueNode<YangInstanceIdentifier.NodeIdentifier, Iterable<LeafSetEntryNode<T>>> implements
Immutable, LeafSetNode<T> {
- private final Map<InstanceIdentifier.NodeWithValue, LeafSetEntryNode<T>> children;
+ private final Map<YangInstanceIdentifier.NodeWithValue, LeafSetEntryNode<T>> children;
- ImmutableLeafSetNode(final InstanceIdentifier.NodeIdentifier nodeIdentifier,
- final Map<InstanceIdentifier.NodeWithValue, LeafSetEntryNode<T>> children) {
+ ImmutableLeafSetNode(final YangInstanceIdentifier.NodeIdentifier nodeIdentifier,
+ final Map<YangInstanceIdentifier.NodeWithValue, LeafSetEntryNode<T>> children) {
super(nodeIdentifier, Iterables.unmodifiableIterable(children.values()));
this.children = children;
}
@Override
- public Optional<LeafSetEntryNode<T>> getChild(final InstanceIdentifier.NodeWithValue child) {
+ public Optional<LeafSetEntryNode<T>> getChild(final YangInstanceIdentifier.NodeWithValue child) {
return Optional.fromNullable(children.get(child));
}
package org.opendaylight.yangtools.yang.data.impl.schema.builder.impl;
import com.google.common.collect.Sets;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.ListNodeBuilder;
private ImmutableLeafSetNodeSchemaAwareBuilder(final LeafListSchemaNode schema) {
this.schema = Preconditions.checkNotNull(schema);
- super.withNodeIdentifier(new InstanceIdentifier.NodeIdentifier(schema.getQName()));
+ super.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(schema.getQName()));
}
public ImmutableLeafSetNodeSchemaAwareBuilder(final LeafListSchemaNode schema, final ImmutableLeafSetNode<T> node) {
super(node);
this.schema = Preconditions.checkNotNull(schema);
// FIXME: Preconditions.checkArgument(schema.getQName().equals(node.getIdentifier()));
- super.withNodeIdentifier(new InstanceIdentifier.NodeIdentifier(schema.getQName()));
+ super.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(schema.getQName()));
}
public static <T> ListNodeBuilder<T, LeafSetEntryNode<T>> create(final LeafListSchemaNode schema) {
}
@Override
- public ListNodeBuilder<T, LeafSetEntryNode<T>> withNodeIdentifier(final InstanceIdentifier.NodeIdentifier nodeIdentifier) {
+ public ListNodeBuilder<T, LeafSetEntryNode<T>> withNodeIdentifier(final YangInstanceIdentifier.NodeIdentifier nodeIdentifier) {
throw new UnsupportedOperationException("Node identifier created from schema");
}
}
import java.util.Map;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.nodes.AbstractImmutableDataContainerAttrNode;
public class ImmutableMapEntryNodeBuilder
- extends AbstractImmutableDataContainerNodeAttrBuilder<InstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> {
+ extends AbstractImmutableDataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> {
- protected final Map<QName, InstanceIdentifier.PathArgument> childrenQNamesToPaths;
+ protected final Map<QName, YangInstanceIdentifier.PathArgument> childrenQNamesToPaths;
protected ImmutableMapEntryNodeBuilder() {
this.childrenQNamesToPaths = new LinkedHashMap<>();
fillQnames(node.getValue(), childrenQNamesToPaths);
}
- public static DataContainerNodeAttrBuilder<InstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> create() {
+ public static DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> create() {
return new ImmutableMapEntryNodeBuilder();
}
- public static DataContainerNodeAttrBuilder<InstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> create(final MapEntryNode node) {
+ public static DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> create(final MapEntryNode node) {
if (!(node instanceof ImmutableMapEntryNode)) {
throw new UnsupportedOperationException(String.format("Cannot initialize from class %s", node.getClass()));
}
}
private static void fillQnames(final Iterable<DataContainerChild<? extends PathArgument, ?>> iterable, final Map<QName, PathArgument> out) {
- for (final DataContainerChild<? extends InstanceIdentifier.PathArgument, ?> childId : iterable) {
- final InstanceIdentifier.PathArgument identifier = childId.getIdentifier();
+ for (final DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> childId : iterable) {
+ final YangInstanceIdentifier.PathArgument identifier = childId.getIdentifier();
// Augmentation nodes cannot be keys, and do not have to be present in childrenQNamesToPaths map
if(isAugment(identifier)) {
@Override
- public DataContainerNodeAttrBuilder<InstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> withValue(final List<DataContainerChild<? extends InstanceIdentifier.PathArgument, ?>> value) {
+ public DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> withValue(final List<DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?>> value) {
fillQnames(value, childrenQNamesToPaths);
return super.withValue(value);
}
- private static boolean isAugment(InstanceIdentifier.PathArgument identifier) {
- return identifier instanceof InstanceIdentifier.AugmentationIdentifier;
+ private static boolean isAugment(YangInstanceIdentifier.PathArgument identifier) {
+ return identifier instanceof YangInstanceIdentifier.AugmentationIdentifier;
}
@Override
- public DataContainerNodeAttrBuilder<InstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> withChild(final DataContainerChild<?, ?> child) {
+ public DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> withChild(final DataContainerChild<?, ?> child) {
// Augmentation nodes cannot be keys, and do not have to be present in childrenQNamesToPaths map
if(isAugment(child.getIdentifier()) == false) {
childrenQNamesToPaths.put(child.getNodeType(), child.getIdentifier());
}
}
- private static final class ImmutableMapEntryNode extends AbstractImmutableDataContainerAttrNode<InstanceIdentifier.NodeIdentifierWithPredicates> implements MapEntryNode {
+ private static final class ImmutableMapEntryNode extends AbstractImmutableDataContainerAttrNode<YangInstanceIdentifier.NodeIdentifierWithPredicates> implements MapEntryNode {
- ImmutableMapEntryNode(final InstanceIdentifier.NodeIdentifierWithPredicates nodeIdentifier,
- final Map<InstanceIdentifier.PathArgument, DataContainerChild<? extends InstanceIdentifier.PathArgument, ?>> children, final Map<QName, String> attributes) {
+ ImmutableMapEntryNode(final YangInstanceIdentifier.NodeIdentifierWithPredicates nodeIdentifier,
+ final Map<YangInstanceIdentifier.PathArgument, DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?>> children, final Map<QName, String> attributes) {
super(children, nodeIdentifier, attributes);
}
}
import java.util.Map;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
}
@Override
- public ImmutableMapEntryNodeBuilder withNodeIdentifier(final InstanceIdentifier.NodeIdentifierWithPredicates nodeIdentifier) {
+ public ImmutableMapEntryNodeBuilder withNodeIdentifier(final YangInstanceIdentifier.NodeIdentifierWithPredicates nodeIdentifier) {
throw new UnsupportedOperationException("Node identifier created from schema");
}
@Override
- public DataContainerNodeAttrBuilder<InstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> withChild(final DataContainerChild<?, ?> child) {
+ public DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> withChild(final DataContainerChild<?, ?> child) {
validator.validateChild(child.getIdentifier());
return super.withChild(child);
}
/**
* Build map entry node identifier from schema, and provided children
*/
- private InstanceIdentifier.NodeIdentifierWithPredicates constructNodeIdentifier() {
+ private YangInstanceIdentifier.NodeIdentifierWithPredicates constructNodeIdentifier() {
Collection<QName> keys = schema.getKeyDefinition();
if(keys.isEmpty()) {
final Map<QName, Object> keysToValues = Maps.newHashMap();
for (QName key : keys) {
final DataContainerChild<?, ?> valueForKey = getChild(childrenQNamesToPaths.get(key));
- DataValidationException.checkListKey(valueForKey, key, new InstanceIdentifier.NodeIdentifierWithPredicates(
+ DataValidationException.checkListKey(valueForKey, key, new YangInstanceIdentifier.NodeIdentifierWithPredicates(
schema.getQName(), keysToValues));
keysToValues.put(key, valueForKey.getValue());
}
- return new InstanceIdentifier.NodeIdentifierWithPredicates(schema.getQName(), keysToValues);
+ return new YangInstanceIdentifier.NodeIdentifierWithPredicates(schema.getQName(), keysToValues);
}
- public static DataContainerNodeAttrBuilder<InstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> create(final ListSchemaNode schema) {
+ public static DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> create(final ListSchemaNode schema) {
return new ImmutableMapEntryNodeSchemaAwareBuilder(schema);
}
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.util.MapAdaptor;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
public class ImmutableMapNodeBuilder
implements CollectionNodeBuilder<MapEntryNode, MapNode> {
- private final Map<InstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> value;
- private InstanceIdentifier.NodeIdentifier nodeIdentifier;
+ private final Map<YangInstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> value;
+ private YangInstanceIdentifier.NodeIdentifier nodeIdentifier;
protected ImmutableMapNodeBuilder() {
this.value = new HashMap<>();
}
@Override
- public CollectionNodeBuilder<MapEntryNode, MapNode> withoutChild(final InstanceIdentifier.PathArgument key) {
+ public CollectionNodeBuilder<MapEntryNode, MapNode> withoutChild(final YangInstanceIdentifier.PathArgument key) {
this.value.remove(key);
return this;
}
}
@Override
- public CollectionNodeBuilder<MapEntryNode, MapNode> withNodeIdentifier(final InstanceIdentifier.NodeIdentifier nodeIdentifier) {
+ public CollectionNodeBuilder<MapEntryNode, MapNode> withNodeIdentifier(final YangInstanceIdentifier.NodeIdentifier nodeIdentifier) {
this.nodeIdentifier = nodeIdentifier;
return this;
}
return withoutChild(key);
}
- protected static final class ImmutableMapNode extends AbstractImmutableNormalizedNode<InstanceIdentifier.NodeIdentifier, Iterable<MapEntryNode>> implements Immutable,MapNode {
+ protected static final class ImmutableMapNode extends AbstractImmutableNormalizedNode<YangInstanceIdentifier.NodeIdentifier, Iterable<MapEntryNode>> implements Immutable,MapNode {
- private final Map<InstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> children;
+ private final Map<YangInstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> children;
- ImmutableMapNode(final InstanceIdentifier.NodeIdentifier nodeIdentifier,
- final Map<InstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> children) {
+ ImmutableMapNode(final YangInstanceIdentifier.NodeIdentifier nodeIdentifier,
+ final Map<YangInstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> children) {
super(nodeIdentifier);
this.children = children;
}
@Override
- public Optional<MapEntryNode> getChild(final InstanceIdentifier.NodeIdentifierWithPredicates child) {
+ public Optional<MapEntryNode> getChild(final YangInstanceIdentifier.NodeIdentifierWithPredicates child) {
return Optional.fromNullable(children.get(child));
}
package org.opendaylight.yangtools.yang.data.impl.schema.builder.impl;
import com.google.common.collect.Sets;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
protected ImmutableMapNodeSchemaAwareBuilder(final ListSchemaNode schema) {
this.schema = Preconditions.checkNotNull(schema);
- super.withNodeIdentifier(new InstanceIdentifier.NodeIdentifier(schema.getQName()));
+ super.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(schema.getQName()));
}
protected ImmutableMapNodeSchemaAwareBuilder(final ListSchemaNode schema, final ImmutableMapNode node) {
super(node);
this.schema = Preconditions.checkNotNull(schema);
- super.withNodeIdentifier(new InstanceIdentifier.NodeIdentifier(schema.getQName()));
+ super.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(schema.getQName()));
}
public static CollectionNodeBuilder<MapEntryNode, MapNode> create(final ListSchemaNode schema) {
}
@Override
- public CollectionNodeBuilder<MapEntryNode, MapNode> withNodeIdentifier(final InstanceIdentifier.NodeIdentifier nodeIdentifier) {
+ public CollectionNodeBuilder<MapEntryNode, MapNode> withNodeIdentifier(final YangInstanceIdentifier.NodeIdentifier nodeIdentifier) {
throw new UnsupportedOperationException("Node identifier created from schema");
}
}
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
import org.opendaylight.yangtools.yang.data.api.schema.OrderedLeafSetNode;
public class ImmutableOrderedLeafSetNodeBuilder<T> implements ListNodeBuilder<T, LeafSetEntryNode<T>> {
- private Map<InstanceIdentifier.NodeWithValue, LeafSetEntryNode<T>> value;
- private InstanceIdentifier.NodeIdentifier nodeIdentifier;
+ private Map<YangInstanceIdentifier.NodeWithValue, LeafSetEntryNode<T>> value;
+ private YangInstanceIdentifier.NodeIdentifier nodeIdentifier;
private boolean dirty;
protected ImmutableOrderedLeafSetNodeBuilder() {
@Override
public ListNodeBuilder<T, LeafSetEntryNode<T>> withNodeIdentifier(
- final InstanceIdentifier.NodeIdentifier nodeIdentifier) {
+ final YangInstanceIdentifier.NodeIdentifier nodeIdentifier) {
this.nodeIdentifier = nodeIdentifier;
return this;
}
@Override
public ListNodeBuilder<T, LeafSetEntryNode<T>> withChildValue(final T value, final Map<QName, String> attributes) {
final ImmutableLeafSetEntryNodeBuilder<T> b = ImmutableLeafSetEntryNodeBuilder.create();
- b.withNodeIdentifier(new InstanceIdentifier.NodeWithValue(nodeIdentifier.getNodeType(), value));
+ b.withNodeIdentifier(new YangInstanceIdentifier.NodeWithValue(nodeIdentifier.getNodeType(), value));
b.withValue(value);
b.withAttributes(attributes);
return withChild(b.build());
}
protected final static class ImmutableOrderedLeafSetNode<T> extends
- AbstractImmutableNormalizedNode<InstanceIdentifier.NodeIdentifier, Iterable<LeafSetEntryNode<T>>> implements
+ AbstractImmutableNormalizedNode<YangInstanceIdentifier.NodeIdentifier, Iterable<LeafSetEntryNode<T>>> implements
Immutable, OrderedLeafSetNode<T> {
- private final Map<InstanceIdentifier.NodeWithValue, LeafSetEntryNode<T>> children;
+ private final Map<YangInstanceIdentifier.NodeWithValue, LeafSetEntryNode<T>> children;
- ImmutableOrderedLeafSetNode(final InstanceIdentifier.NodeIdentifier nodeIdentifier,
- final Map<InstanceIdentifier.NodeWithValue, LeafSetEntryNode<T>> children) {
+ ImmutableOrderedLeafSetNode(final YangInstanceIdentifier.NodeIdentifier nodeIdentifier,
+ final Map<YangInstanceIdentifier.NodeWithValue, LeafSetEntryNode<T>> children) {
super(nodeIdentifier);
this.children = children;
}
@Override
- public Optional<LeafSetEntryNode<T>> getChild(final InstanceIdentifier.NodeWithValue child) {
+ public Optional<LeafSetEntryNode<T>> getChild(final YangInstanceIdentifier.NodeWithValue child) {
return Optional.fromNullable(children.get(child));
}
return children.hashCode();
}
- private Map<InstanceIdentifier.NodeWithValue, LeafSetEntryNode<T>> getChildren() {
+ private Map<YangInstanceIdentifier.NodeWithValue, LeafSetEntryNode<T>> getChildren() {
return Collections.unmodifiableMap(children);
}
import java.util.Map;
import org.opendaylight.yangtools.concepts.Immutable;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.OrderedMapNode;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
public class ImmutableOrderedMapNodeBuilder
implements CollectionNodeBuilder<MapEntryNode, OrderedMapNode> {
- private Map<InstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> value;
- private InstanceIdentifier.NodeIdentifier nodeIdentifier;
+ private Map<YangInstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> value;
+ private YangInstanceIdentifier.NodeIdentifier nodeIdentifier;
private boolean dirty = false;
protected ImmutableOrderedMapNodeBuilder() {
}
@Override
- public CollectionNodeBuilder<MapEntryNode, OrderedMapNode> withoutChild(final InstanceIdentifier.PathArgument key) {
+ public CollectionNodeBuilder<MapEntryNode, OrderedMapNode> withoutChild(final YangInstanceIdentifier.PathArgument key) {
checkDirty();
this.value.remove(key);
return this;
}
@Override
- public CollectionNodeBuilder<MapEntryNode, OrderedMapNode> withNodeIdentifier(final InstanceIdentifier.NodeIdentifier nodeIdentifier) {
+ public CollectionNodeBuilder<MapEntryNode, OrderedMapNode> withNodeIdentifier(final YangInstanceIdentifier.NodeIdentifier nodeIdentifier) {
this.nodeIdentifier = nodeIdentifier;
return this;
}
return withoutChild(key);
}
- protected static final class ImmutableOrderedMapNode extends AbstractImmutableNormalizedNode<InstanceIdentifier.NodeIdentifier, Iterable<MapEntryNode>> implements Immutable,OrderedMapNode {
+ protected static final class ImmutableOrderedMapNode extends AbstractImmutableNormalizedNode<YangInstanceIdentifier.NodeIdentifier, Iterable<MapEntryNode>> implements Immutable,OrderedMapNode {
- private final Map<InstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> children;
+ private final Map<YangInstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> children;
- ImmutableOrderedMapNode(final InstanceIdentifier.NodeIdentifier nodeIdentifier,
- final Map<InstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> children) {
+ ImmutableOrderedMapNode(final YangInstanceIdentifier.NodeIdentifier nodeIdentifier,
+ final Map<YangInstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> children) {
super(nodeIdentifier);
this.children = children;
}
@Override
- public Optional<MapEntryNode> getChild(final InstanceIdentifier.NodeIdentifierWithPredicates child) {
+ public Optional<MapEntryNode> getChild(final YangInstanceIdentifier.NodeIdentifierWithPredicates child) {
return Optional.fromNullable(children.get(child));
}
import java.util.Map;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.nodes.AbstractImmutableDataContainerAttrNode;
public class ImmutableUnkeyedListEntryNodeBuilder extends
- AbstractImmutableDataContainerNodeAttrBuilder<InstanceIdentifier.NodeIdentifier, UnkeyedListEntryNode> {
+ AbstractImmutableDataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, UnkeyedListEntryNode> {
protected ImmutableUnkeyedListEntryNodeBuilder() {
super();
super(node);
}
- public static DataContainerNodeAttrBuilder<InstanceIdentifier.NodeIdentifier, UnkeyedListEntryNode> create() {
+ public static DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, UnkeyedListEntryNode> create() {
return new ImmutableUnkeyedListEntryNodeBuilder();
}
- public static DataContainerNodeAttrBuilder<InstanceIdentifier.NodeIdentifier, UnkeyedListEntryNode> create(final UnkeyedListEntryNode node) {
+ public static DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, UnkeyedListEntryNode> create(final UnkeyedListEntryNode node) {
if (!(node instanceof ImmutableUnkeyedListEntryNode)) {
throw new UnsupportedOperationException(String.format("Cannot initialize from class %s", node.getClass()));
}
}
protected static final class ImmutableUnkeyedListEntryNode extends
- AbstractImmutableDataContainerAttrNode<InstanceIdentifier.NodeIdentifier> implements UnkeyedListEntryNode {
+ AbstractImmutableDataContainerAttrNode<YangInstanceIdentifier.NodeIdentifier> implements UnkeyedListEntryNode {
ImmutableUnkeyedListEntryNode(
- final InstanceIdentifier.NodeIdentifier nodeIdentifier,
- final Map<InstanceIdentifier.PathArgument, DataContainerChild<? extends InstanceIdentifier.PathArgument, ?>> children,
+ final YangInstanceIdentifier.NodeIdentifier nodeIdentifier,
+ final Map<YangInstanceIdentifier.PathArgument, DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?>> children,
final Map<QName, String> attributes) {
super(children, nodeIdentifier, attributes);
}
import java.util.List;
import org.opendaylight.yangtools.concepts.Immutable;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
public class ImmutableUnkeyedListNodeBuilder implements CollectionNodeBuilder<UnkeyedListEntryNode, UnkeyedListNode> {
private List<UnkeyedListEntryNode> value;
- private InstanceIdentifier.NodeIdentifier nodeIdentifier;
+ private YangInstanceIdentifier.NodeIdentifier nodeIdentifier;
private boolean dirty = false;
protected ImmutableUnkeyedListNodeBuilder() {
@Override
public CollectionNodeBuilder<UnkeyedListEntryNode, UnkeyedListNode> withoutChild(
- final InstanceIdentifier.PathArgument key) {
+ final YangInstanceIdentifier.PathArgument key) {
checkDirty();
throw new UnsupportedOperationException("Children does not have identifiers.");
}
@Override
public CollectionNodeBuilder<UnkeyedListEntryNode, UnkeyedListNode> withNodeIdentifier(
- final InstanceIdentifier.NodeIdentifier nodeIdentifier) {
+ final YangInstanceIdentifier.NodeIdentifier nodeIdentifier) {
this.nodeIdentifier = nodeIdentifier;
return this;
}
}
protected static final class ImmutableUnkeyedListNode extends
- AbstractImmutableNormalizedValueNode<InstanceIdentifier.NodeIdentifier, Iterable<UnkeyedListEntryNode>>
+ AbstractImmutableNormalizedValueNode<YangInstanceIdentifier.NodeIdentifier, Iterable<UnkeyedListEntryNode>>
implements Immutable, UnkeyedListNode {
private final ImmutableList<UnkeyedListEntryNode> children;
- ImmutableUnkeyedListNode(final InstanceIdentifier.NodeIdentifier nodeIdentifier,
+ ImmutableUnkeyedListNode(final YangInstanceIdentifier.NodeIdentifier nodeIdentifier,
final ImmutableList<UnkeyedListEntryNode> children) {
super(nodeIdentifier, children);
this.children = children;
import com.google.common.collect.Sets;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.impl.schema.SchemaUtils;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
private final DataNodeContainer schema;
private final Set<QName> childNodes;
- private final Set<InstanceIdentifier.AugmentationIdentifier> augments = Sets.newHashSet();
+ private final Set<YangInstanceIdentifier.AugmentationIdentifier> augments = Sets.newHashSet();
public DataNodeContainerValidator(DataNodeContainer schema) {
this.schema = Preconditions.checkNotNull(schema, "Schema was null");
}
}
- private boolean isKnownChild(InstanceIdentifier.PathArgument child) {
- if(child instanceof InstanceIdentifier.AugmentationIdentifier) {
+ private boolean isKnownChild(YangInstanceIdentifier.PathArgument child) {
+ if(child instanceof YangInstanceIdentifier.AugmentationIdentifier) {
return augments.contains(child);
}
return childNodes.contains(child.getNodeType());
}
- public void validateChild(InstanceIdentifier.PathArgument child) {
+ public void validateChild(YangInstanceIdentifier.PathArgument child) {
DataValidationException.checkLegalChild(isKnownChild(child), child, schema, childNodes, augments);
}
import java.util.Set;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
super(message);
}
- public static void checkLegalChild(final boolean isLegal, final InstanceIdentifier.PathArgument child, final DataNodeContainer schema,
- final Set<QName> childNodes, final Set<InstanceIdentifier.AugmentationIdentifier> augments) {
+ public static void checkLegalChild(final boolean isLegal, final YangInstanceIdentifier.PathArgument child, final DataNodeContainer schema,
+ final Set<QName> childNodes, final Set<YangInstanceIdentifier.AugmentationIdentifier> augments) {
if (isLegal == false) {
throw new IllegalChildException(child, schema, childNodes, augments);
}
}
- public static void checkLegalChild(final boolean isLegal, final InstanceIdentifier.PathArgument child, final DataSchemaNode schema,
+ public static void checkLegalChild(final boolean isLegal, final YangInstanceIdentifier.PathArgument child, final DataSchemaNode schema,
final Set<QName> childNodes) {
if (isLegal == false) {
throw new IllegalChildException(child, schema, childNodes);
}
}
- public static void checkLegalChild(final boolean isLegal, final InstanceIdentifier.PathArgument child, final ChoiceNode schema) {
+ public static void checkLegalChild(final boolean isLegal, final YangInstanceIdentifier.PathArgument child, final ChoiceNode schema) {
if (isLegal == false) {
throw new IllegalChildException(child, schema);
}
}
public static void checkListKey(final DataContainerChild<?, ?> childNode, final Map<QName, Object> keyValues, final QName keyQName,
- final InstanceIdentifier.NodeIdentifierWithPredicates nodeId) {
+ final YangInstanceIdentifier.NodeIdentifierWithPredicates nodeId) {
checkListKey(childNode, keyQName, nodeId);
Object expectedValue = nodeId.getKeyValues().get(keyQName);
}
}
- public static void checkListKey(final DataContainerChild<?, ?> childNode, final QName keyQName, final InstanceIdentifier.NodeIdentifierWithPredicates nodeId) {
+ public static void checkListKey(final DataContainerChild<?, ?> childNode, final QName keyQName, final YangInstanceIdentifier.NodeIdentifierWithPredicates nodeId) {
if (childNode == null) {
throw new IllegalListKeyException(keyQName, nodeId);
}
static final class IllegalChildException extends DataValidationException {
private static final long serialVersionUID = 1L;
- public IllegalChildException(final InstanceIdentifier.PathArgument child, final DataNodeContainer schema,
- final Set<QName> childNodes, final Set<InstanceIdentifier.AugmentationIdentifier> augments) {
+ public IllegalChildException(final YangInstanceIdentifier.PathArgument child, final DataNodeContainer schema,
+ final Set<QName> childNodes, final Set<YangInstanceIdentifier.AugmentationIdentifier> augments) {
super(String.format("Unknown child node: %s, does not belong to: %s as a direct child. "
+ "Direct child nodes: %s, augmented child nodes: %s", child, schema, childNodes, augments));
}
- public IllegalChildException(final InstanceIdentifier.PathArgument child, final ChoiceNode schema) {
+ public IllegalChildException(final YangInstanceIdentifier.PathArgument child, final ChoiceNode schema) {
super(String.format("Unknown child node: %s, not detected in choice: %s", child, schema));
}
- public IllegalChildException(final InstanceIdentifier.PathArgument child, final DataSchemaNode schema, final Set<QName> childNodes) {
+ public IllegalChildException(final YangInstanceIdentifier.PathArgument child, final DataSchemaNode schema, final Set<QName> childNodes) {
super(String.format("Unknown child node: %s, does not belong to: %s as a child. "
+ "Child nodes: %s", child, schema, childNodes));
}
static final class IllegalListKeyException extends DataValidationException {
private static final long serialVersionUID = 1L;
- public IllegalListKeyException(final QName keyQName, final InstanceIdentifier.NodeIdentifierWithPredicates id) {
+ public IllegalListKeyException(final QName keyQName, final YangInstanceIdentifier.NodeIdentifierWithPredicates id) {
super(String.format("Key value not present for key: %s, in: %s", keyQName, id));
}
- public IllegalListKeyException(final QName keyQName, final InstanceIdentifier.NodeIdentifierWithPredicates id, final Object actualValue, final Object expectedValue) {
+ public IllegalListKeyException(final QName keyQName, final YangInstanceIdentifier.NodeIdentifierWithPredicates id, final Object actualValue, final Object expectedValue) {
super(String.format("Illegal value for key: %s, in: %s, actual value: %s, expected value from key: %s", keyQName, id, actualValue, expectedValue));
}
}
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.AttributesContainer;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import com.google.common.base.Objects.ToStringHelper;
-public abstract class AbstractImmutableDataContainerAttrNode<K extends InstanceIdentifier.PathArgument>
+public abstract class AbstractImmutableDataContainerAttrNode<K extends YangInstanceIdentifier.PathArgument>
extends AbstractImmutableDataContainerNode<K>
implements AttributesContainer {
private final Map<QName, String> attributes;
public AbstractImmutableDataContainerAttrNode(
- final Map<InstanceIdentifier.PathArgument, DataContainerChild<? extends InstanceIdentifier.PathArgument, ?>> children,
+ final Map<YangInstanceIdentifier.PathArgument, DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?>> children,
final K nodeIdentifier, final Map<QName, String> attributes) {
super(children, nodeIdentifier);
this.attributes = attributes;
import java.util.Map;
import org.opendaylight.yangtools.concepts.Immutable;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-public abstract class AbstractImmutableNormalizedNode<K extends InstanceIdentifier.PathArgument,V> implements NormalizedNode<K, V>, Immutable {
+public abstract class AbstractImmutableNormalizedNode<K extends YangInstanceIdentifier.PathArgument,V> implements NormalizedNode<K, V>, Immutable {
private final K nodeIdentifier;
protected AbstractImmutableNormalizedNode(final K nodeIdentifier) {
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.AttributesContainer;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import com.google.common.base.Objects.ToStringHelper;
import com.google.common.collect.ImmutableMap;
-public abstract class AbstractImmutableNormalizedValueAttrNode<K extends InstanceIdentifier.PathArgument,V>
+public abstract class AbstractImmutableNormalizedValueAttrNode<K extends YangInstanceIdentifier.PathArgument,V>
extends AbstractImmutableNormalizedValueNode<K, V>
implements AttributesContainer {
*/
package org.opendaylight.yangtools.yang.data.impl.schema.nodes;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public abstract class AbstractImmutableNormalizedValueNode<K extends InstanceIdentifier.PathArgument, V> extends
+public abstract class AbstractImmutableNormalizedValueNode<K extends YangInstanceIdentifier.PathArgument, V> extends
AbstractImmutableNormalizedNode<K, V> {
private static final Logger LOGGER = LoggerFactory.getLogger(AbstractImmutableNormalizedValueNode.class);
import java.util.Set;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
BaseDispatcherParser<E,AugmentationNode, AugmentationSchema> {
@Override
- protected final DataContainerNodeBuilder<InstanceIdentifier.AugmentationIdentifier, AugmentationNode> getBuilder(AugmentationSchema schema) {
+ protected final DataContainerNodeBuilder<YangInstanceIdentifier.AugmentationIdentifier, AugmentationNode> getBuilder(AugmentationSchema schema) {
return Builders.augmentationBuilder(schema);
}
import java.util.Set;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.AttributesBuilder;
choicesToElements.putAll(choiceSchema, childrenForQName);
// Regular child nodes
} else {
- DataContainerChild<? extends InstanceIdentifier.PathArgument, ?> builtChildNode = getDispatcher()
+ DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> builtChildNode = getDispatcher()
.dispatchChildElement(childSchema, childrenForQName);
containerBuilder.withChild(builtChildNode);
}
import java.util.Set;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
BaseDispatcherParser<E, ChoiceNode, org.opendaylight.yangtools.yang.model.api.ChoiceNode> {
@Override
- protected final DataContainerNodeBuilder<InstanceIdentifier.NodeIdentifier, ChoiceNode> getBuilder(
+ protected final DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifier, ChoiceNode> getBuilder(
org.opendaylight.yangtools.yang.model.api.ChoiceNode schema) {
return Builders.choiceBuilder(schema);
}
import java.util.Set;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
BaseDispatcherParser<E, ContainerNode, ContainerSchemaNode> {
@Override
- protected final DataContainerNodeBuilder<InstanceIdentifier.NodeIdentifier, ContainerNode> getBuilder(
+ protected final DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode> getBuilder(
ContainerSchemaNode schema) {
return Builders.containerBuilder(schema);
}
import java.util.Map;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeAttrBuilder;
final E e = elements.iterator().next();
Object value = parseLeaf(e, schema);
- NormalizedNodeAttrBuilder<InstanceIdentifier.NodeIdentifier,Object,LeafNode<Object>> leafBuilder = Builders.leafBuilder(schema);
+ NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier,Object,LeafNode<Object>> leafBuilder = Builders.leafBuilder(schema);
leafBuilder.withAttributes(getAttributes(e));
import java.util.Map;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeAttrBuilder;
final E e = elements.iterator().next();
Object value = parseLeafListEntry(e,schema);
- NormalizedNodeAttrBuilder<InstanceIdentifier.NodeWithValue, Object, LeafSetEntryNode<Object>> leafEntryBuilder = Builders
+ NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeWithValue, Object, LeafSetEntryNode<Object>> leafEntryBuilder = Builders
.leafSetEntryBuilder(schema);
leafEntryBuilder.withAttributes(getAttributes(e));
import java.util.Set;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
public abstract class MapEntryNodeBaseParser<E> extends BaseDispatcherParser<E, MapEntryNode, ListSchemaNode> {
@Override
- protected final DataContainerNodeBuilder<InstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> getBuilder(
+ protected final DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> getBuilder(
ListSchemaNode schema) {
return Builders.mapEntryBuilder(schema);
}
import java.util.Set;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.impl.schema.SchemaUtils;
@Override
protected DataSchemaNode getSchemaForChild(AugmentationSchema schema,
- DataContainerChild<? extends InstanceIdentifier.PathArgument, ?> childNode) {
+ DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> childNode) {
return SchemaUtils.findSchemaForChild(schema, childNode.getNodeType());
}
import java.util.List;
import java.util.Set;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode;
* Schema should be retrieved from parent schema: schema.
*/
protected abstract DataSchemaNode getSchemaForChild(S schema,
- DataContainerChild<? extends InstanceIdentifier.PathArgument, ?> childNode);
+ DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> childNode);
/**
*
public Iterable<E> serialize(S schema, N node) {
List<Iterable<E>> choiceChildren = Lists.newArrayList();
- for (DataContainerChild<? extends InstanceIdentifier.PathArgument, ?> choiceChild : node.getValue()) {
+ for (DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> choiceChild : node.getValue()) {
Object childSchema;
import java.util.HashSet;
import java.util.Set;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
@Override
protected final DataSchemaNode getSchemaForChild(final org.opendaylight.yangtools.yang.model.api.ChoiceNode schema,
- final DataContainerChild<? extends InstanceIdentifier.PathArgument, ?> childNode) {
+ final DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> childNode) {
return SchemaUtils.findSchemaForChild(schema, childNode.getNodeType());
}
import java.util.Set;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
@Override
protected final DataSchemaNode getSchemaForChild(ContainerSchemaNode schema,
- DataContainerChild<? extends InstanceIdentifier.PathArgument, ?> childNode) {
+ DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> childNode) {
return SchemaUtils.findSchemaForChild(schema, childNode.getNodeType());
}
import java.util.Set;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
@Override
protected final DataSchemaNode getSchemaForChild(ListSchemaNode schema,
- DataContainerChild<? extends InstanceIdentifier.PathArgument, ?> childNode) {
+ DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> childNode) {
return SchemaUtils.findSchemaForChild(schema, childNode.getNodeType());
}
*/
package org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
public interface NodeSerializerDispatcher<E> {
Iterable<E> dispatchChildElement(Object childSchema,
- DataContainerChild<? extends InstanceIdentifier.PathArgument, ?> dataContainerChild);
+ DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataContainerChild);
/**
* Abstract implementation that implements the dispatch conditions. Only requires serializers to be provided.
@Override
public final Iterable<E> dispatchChildElement(Object childSchema,
- DataContainerChild<? extends InstanceIdentifier.PathArgument, ?> dataContainerChild) {
+ DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataContainerChild) {
if (dataContainerChild instanceof ContainerNode) {
return onContainerNode(childSchema, dataContainerChild);
} else if (dataContainerChild instanceof LeafNode<?>) {
}
private Iterable<E> onAugmentationSchema(Object childSchema,
- DataContainerChild<? extends InstanceIdentifier.PathArgument, ?> dataContainerChild) {
+ DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataContainerChild) {
checkSchemaCompatibility(childSchema, AugmentationSchema.class, dataContainerChild);
return factory.getAugmentationNodeSerializer().serialize((AugmentationSchema) childSchema,
(AugmentationNode) dataContainerChild);
}
private Iterable<E> onChoiceNode(Object childSchema,
- DataContainerChild<? extends InstanceIdentifier.PathArgument, ?> dataContainerChild) {
+ DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataContainerChild) {
checkSchemaCompatibility(childSchema, org.opendaylight.yangtools.yang.model.api.ChoiceNode.class,
dataContainerChild);
return factory.getChoiceNodeSerializer()
}
private Iterable<E> onListNode(Object childSchema,
- DataContainerChild<? extends InstanceIdentifier.PathArgument, ?> dataContainerChild) {
+ DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataContainerChild) {
checkSchemaCompatibility(childSchema, ListSchemaNode.class, dataContainerChild);
return factory.getMapNodeSerializer().serialize((ListSchemaNode) childSchema, (MapNode) dataContainerChild);
}
private Iterable<E> onLeafListNode(Object childSchema,
- DataContainerChild<? extends InstanceIdentifier.PathArgument, ?> dataContainerChild) {
+ DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataContainerChild) {
checkSchemaCompatibility(childSchema, LeafListSchemaNode.class, dataContainerChild);
return factory.getLeafSetNodeSerializer().serialize((LeafListSchemaNode) childSchema,
(LeafSetNode<?>) dataContainerChild);
}
private Iterable<E> onLeafNode(Object childSchema,
- DataContainerChild<? extends InstanceIdentifier.PathArgument, ?> dataContainerChild) {
+ DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataContainerChild) {
checkSchemaCompatibility(childSchema, LeafSchemaNode.class, dataContainerChild);
Iterable<E> elements = factory.getLeafNodeSerializer().serialize((LeafSchemaNode) childSchema,
(LeafNode<?>) dataContainerChild);
}
private static void checkOnlyOneSerializedElement(Iterable<?> elements,
- DataContainerChild<? extends InstanceIdentifier.PathArgument, ?> dataContainerChild) {
+ DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataContainerChild) {
final int size = Iterables.size(elements);
Preconditions.checkArgument(size == 1,
"Unexpected count of elements for entry serialized from: %s, should be 1, was: %s",
}
private Iterable<E> onContainerNode(Object childSchema,
- DataContainerChild<? extends InstanceIdentifier.PathArgument, ?> dataContainerChild) {
+ DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataContainerChild) {
checkSchemaCompatibility(childSchema, ContainerSchemaNode.class, dataContainerChild);
Iterable<E> elements = factory.getContainerNodeSerializer().serialize((ContainerSchemaNode) childSchema,
}
private static void checkSchemaCompatibility(Object childSchema, Class<?> containerSchemaNodeClass,
- DataContainerChild<? extends InstanceIdentifier.PathArgument, ?> dataContainerChild) {
+ DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataContainerChild) {
Preconditions.checkArgument(containerSchemaNodeClass.isAssignableFrom(childSchema.getClass()),
"Incompatible schema: %s with node: %s, expected: %s", childSchema, dataContainerChild,
containerSchemaNodeClass);
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
import com.google.common.base.Preconditions;
abstract class AbstractDataTreeCandidate implements DataTreeCandidate {
- private final InstanceIdentifier rootPath;
+ private final YangInstanceIdentifier rootPath;
- protected AbstractDataTreeCandidate(final InstanceIdentifier rootPath) {
+ protected AbstractDataTreeCandidate(final YangInstanceIdentifier rootPath) {
this.rootPath = Preconditions.checkNotNull(rootPath);
}
@Override
- public final InstanceIdentifier getRootPath() {
+ public final YangInstanceIdentifier getRootPath() {
return rootPath;
}
import com.google.common.base.Optional;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.TreeNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.Version;
}
@Override
- public void checkApplicable(final InstanceIdentifier path,final NodeModification modification, final Optional<TreeNode> storeMetadata) {
+ public void checkApplicable(final YangInstanceIdentifier path,final NodeModification modification, final Optional<TreeNode> storeMetadata) {
throw new IllegalStateException("Schema Context is not available.");
}
import java.util.Set;
import java.util.concurrent.ExecutionException;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.AugmentationIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification;
*/
final class InMemoryDataTree implements DataTree {
private static final Logger LOG = LoggerFactory.getLogger(InMemoryDataTree.class);
- private static final InstanceIdentifier PUBLIC_ROOT_PATH = InstanceIdentifier.builder().build();
+ private static final YangInstanceIdentifier PUBLIC_ROOT_PATH = YangInstanceIdentifier.builder().build();
private final ReadWriteLock rwLock = new ReentrantReadWriteLock(true);
private final LatestOperationHolder operationHolder = new LatestOperationHolder();
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.Iterables;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.ModificationType;
private final RootNode root;
- InMemoryDataTreeCandidate(final InstanceIdentifier rootPath, final ModifiedNode modificationRoot,
+ InMemoryDataTreeCandidate(final YangInstanceIdentifier rootPath, final ModifiedNode modificationRoot,
final TreeNode beforeRoot, final TreeNode afterRoot) {
super(rootPath);
this.root = new RootNode(modificationRoot, beforeRoot, afterRoot);
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeFactory;
import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.TreeNodeFactory;
import javax.annotation.concurrent.GuardedBy;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification;
}
@Override
- public synchronized void write(final InstanceIdentifier path, final NormalizedNode<?, ?> value) {
+ public synchronized void write(final YangInstanceIdentifier path, final NormalizedNode<?, ?> value) {
checkSealed();
resolveModificationFor(path).write(value);
}
@Override
- public synchronized void merge(final InstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ public synchronized void merge(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
checkSealed();
mergeImpl(resolveModificationFor(path),data);
}
}
@Override
- public synchronized void delete(final InstanceIdentifier path) {
+ public synchronized void delete(final YangInstanceIdentifier path) {
checkSealed();
resolveModificationFor(path).delete();
}
@Override
- public synchronized Optional<NormalizedNode<?, ?>> readNode(final InstanceIdentifier path) {
+ public synchronized Optional<NormalizedNode<?, ?>> readNode(final YangInstanceIdentifier path) {
/*
* Walk the tree from the top, looking for the first node between root and
* the requested path which has been modified. If no such node exists,
* we use the node itself.
*/
- final Entry<InstanceIdentifier, ModifiedNode> entry = TreeNodeUtils.findClosestsOrFirstMatch(rootNode, path, ModifiedNode.IS_TERMINAL_PREDICATE);
- final InstanceIdentifier key = entry.getKey();
+ final Entry<YangInstanceIdentifier, ModifiedNode> entry = TreeNodeUtils.findClosestsOrFirstMatch(rootNode, path, ModifiedNode.IS_TERMINAL_PREDICATE);
+ final YangInstanceIdentifier key = entry.getKey();
final ModifiedNode mod = entry.getValue();
final Optional<TreeNode> result = resolveSnapshot(key, mod);
}
}
- private Optional<TreeNode> resolveSnapshot(final InstanceIdentifier path,
+ private Optional<TreeNode> resolveSnapshot(final YangInstanceIdentifier path,
final ModifiedNode modification) {
final Optional<Optional<TreeNode>> potentialSnapshot = modification.getSnapshotCache();
if(potentialSnapshot.isPresent()) {
}
}
- private ModificationApplyOperation resolveModificationStrategy(final InstanceIdentifier path) {
+ private ModificationApplyOperation resolveModificationStrategy(final YangInstanceIdentifier path) {
LOG.trace("Resolving modification apply strategy for {}", path);
if(rootNode.getType() == ModificationType.UNMODIFIED) {
strategyTree.upgradeIfPossible();
return TreeNodeUtils.<ModificationApplyOperation>findNodeChecked(strategyTree, path);
}
- private OperationWithModification resolveModificationFor(final InstanceIdentifier path) {
+ private OperationWithModification resolveModificationFor(final YangInstanceIdentifier path) {
ModifiedNode modification = rootNode;
// We ensure strategy is present.
ModificationApplyOperation operation = resolveModificationStrategy(path);
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeSnapshot;
import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.TreeNode;
}
@Override
- public Optional<NormalizedNode<?, ?>> readNode(final InstanceIdentifier path) {
+ public Optional<NormalizedNode<?, ?>> readNode(final YangInstanceIdentifier path) {
return NormalizedNodeUtils.findNode(rootNode.getData(), path);
}
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
import com.google.common.base.Optional;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.tree.StoreTreeNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.TreeNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.Version;
* false if modification is no applicable
* @throws DataValidationFailedException
*/
- void checkApplicable(InstanceIdentifier path, NodeModification modification, Optional<TreeNode> current) throws DataValidationFailedException;
+ void checkApplicable(YangInstanceIdentifier path, NodeModification modification, Optional<TreeNode> current) throws DataValidationFailedException;
}
import com.google.common.base.Optional;
import com.google.common.base.Predicate;
import org.opendaylight.yangtools.concepts.Identifiable;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.ModificationType;
import org.opendaylight.yangtools.yang.data.api.schema.tree.StoreTreeNode;
import com.google.common.base.Optional;
import org.opendaylight.yangtools.concepts.Identifiable;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.tree.ModificationType;
import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.TreeNode;
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.ModificationType;
}
};
- protected NoopDataTreeCandidate(final InstanceIdentifier rootPath, final ModifiedNode modificationRoot) {
+ protected NoopDataTreeCandidate(final YangInstanceIdentifier rootPath, final ModifiedNode modificationRoot) {
super(rootPath);
Preconditions.checkArgument(modificationRoot.getType() == ModificationType.UNMODIFIED);
}
import java.util.Map;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifierWithPredicates;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeWithValue;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
}
@Override
- protected void checkWriteApplicable(final InstanceIdentifier path, final NodeModification modification,
+ protected void checkWriteApplicable(final YangInstanceIdentifier path, final NodeModification modification,
final Optional<TreeNode> current) throws DataValidationFailedException {
// FIXME: Implement proper write check for replacement of node container
// prerequisite is to have transaction chain available for clients
}
@Override
- protected void checkSubtreeModificationApplicable(final InstanceIdentifier path, final NodeModification modification,
+ protected void checkSubtreeModificationApplicable(final YangInstanceIdentifier path, final NodeModification modification,
final Optional<TreeNode> current) throws DataValidationFailedException {
checkDoesNotExists(path, modification.getOriginal().isPresent() || current.isPresent(), "Node does not exist. Could not modify its children.");
SchemaAwareApplyOperation.checkConflicting(path, current.isPresent(), "Node was deleted by other transaction.");
checkChildPreconditions(path, modification, current);
}
- private static void checkDoesNotExists(final InstanceIdentifier path, final boolean condition, final String message) throws DataValidationFailedException {
+ private static void checkDoesNotExists(final YangInstanceIdentifier path, final boolean condition, final String message) throws DataValidationFailedException {
if(!condition) {
throw new ModifiedNodeDoesNotExistException(path,message);
}
}
- private void checkChildPreconditions(final InstanceIdentifier path, final NodeModification modification, final Optional<TreeNode> current) throws DataValidationFailedException {
+ private void checkChildPreconditions(final YangInstanceIdentifier path, final NodeModification modification, final Optional<TreeNode> current) throws DataValidationFailedException {
final TreeNode currentMeta = current.get();
for (NodeModification childMod : modification.getChildren()) {
final PathArgument childId = childMod.getIdentifier();
final Optional<TreeNode> childMeta = currentMeta.getChild(childId);
- InstanceIdentifier childPath = path.node(childId);
+ YangInstanceIdentifier childPath = path.node(childId);
resolveChildOperation(childId).checkApplicable(childPath, childMod, childMeta);
}
}
@Override
- protected void checkMergeApplicable(final InstanceIdentifier path, final NodeModification modification,
+ protected void checkMergeApplicable(final YangInstanceIdentifier path, final NodeModification modification,
final Optional<TreeNode> current) throws DataValidationFailedException {
if(current.isPresent()) {
checkChildPreconditions(path, modification,current);
import com.google.common.base.Optional;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.TreeNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.Version;
*/
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataValidationFailedException;
import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.TreeNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.Version;
}
@Override
- public final void checkApplicable(final InstanceIdentifier path, final NodeModification modification, final Optional<TreeNode> current)
+ public final void checkApplicable(final YangInstanceIdentifier path, final NodeModification modification, final Optional<TreeNode> current)
throws DataValidationFailedException {
getDelegate().checkApplicable(path, modification, current);
}
import java.util.List;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.AugmentationIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.ConflictingModificationAppliedException;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataValidationFailedException;
return null;
}
- public static boolean checkConflicting(final InstanceIdentifier path, final boolean condition, final String message) throws ConflictingModificationAppliedException {
+ public static boolean checkConflicting(final YangInstanceIdentifier path, final boolean condition, final String message) throws ConflictingModificationAppliedException {
if(!condition) {
throw new ConflictingModificationAppliedException(path, message);
}
}
}
- private static final void checkNotConflicting(final InstanceIdentifier path, final TreeNode original, final TreeNode current) throws ConflictingModificationAppliedException {
+ private static final void checkNotConflicting(final YangInstanceIdentifier path, final TreeNode original, final TreeNode current) throws ConflictingModificationAppliedException {
checkConflicting(path, original.getVersion().equals(current.getVersion()),
"Node was replaced by other transaction.");
checkConflicting(path, original.getSubtreeVersion().equals(current.getSubtreeVersion()),
}
@Override
- public final void checkApplicable(final InstanceIdentifier path,final NodeModification modification, final Optional<TreeNode> current) throws DataValidationFailedException {
+ public final void checkApplicable(final YangInstanceIdentifier path,final NodeModification modification, final Optional<TreeNode> current) throws DataValidationFailedException {
switch (modification.getType()) {
case DELETE:
checkDeleteApplicable(modification, current);
}
- protected void checkMergeApplicable(final InstanceIdentifier path, final NodeModification modification, final Optional<TreeNode> current) throws DataValidationFailedException {
+ protected void checkMergeApplicable(final YangInstanceIdentifier path, final NodeModification modification, final Optional<TreeNode> current) throws DataValidationFailedException {
Optional<TreeNode> original = modification.getOriginal();
if (original.isPresent() && current.isPresent()) {
/*
}
}
- protected void checkWriteApplicable(final InstanceIdentifier path, final NodeModification modification, final Optional<TreeNode> current) throws DataValidationFailedException {
+ protected void checkWriteApplicable(final YangInstanceIdentifier path, final NodeModification modification, final Optional<TreeNode> current) throws DataValidationFailedException {
Optional<TreeNode> original = modification.getOriginal();
if (original.isPresent() && current.isPresent()) {
checkNotConflicting(path, original.get(), current.get());
* @throws ConflictingModificationAppliedException If subtree was changed in conflicting way
* @throws IncorrectDataStructureException If subtree modification is not applicable (e.g. leaf node).
*/
- protected abstract void checkSubtreeModificationApplicable(InstanceIdentifier path, final NodeModification modification,
+ protected abstract void checkSubtreeModificationApplicable(YangInstanceIdentifier path, final NodeModification modification,
final Optional<TreeNode> current) throws DataValidationFailedException;
protected abstract void verifyWrittenStructure(NormalizedNode<?, ?> writtenValue);
}
@Override
- protected void checkSubtreeModificationApplicable(final InstanceIdentifier path, final NodeModification modification,
+ protected void checkSubtreeModificationApplicable(final YangInstanceIdentifier path, final NodeModification modification,
final Optional<TreeNode> current) throws IncorrectDataStructureException {
throw new IncorrectDataStructureException(path, "Subtree modification is not allowed.");
}
*/
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.AugmentationIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifierWithPredicates;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer;
import java.util.Iterator;
import java.util.Map;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.tree.StoreTreeNode;
/**
* @param path Path to the node
* @return Optional with node if the node is present in tree, {@link Optional#absent()} otherwise.
*/
- public static <T extends StoreTreeNode<T>> Optional<T> findNode(final T tree, final InstanceIdentifier path) {
+ public static <T extends StoreTreeNode<T>> Optional<T> findNode(final T tree, final YangInstanceIdentifier path) {
Optional<T> current = Optional.<T> of(tree);
Iterator<PathArgument> pathIter = path.getPathArguments().iterator();
while (current.isPresent() && pathIter.hasNext()) {
return current;
}
- public static <T extends StoreTreeNode<T>> T findNodeChecked(final T tree, final InstanceIdentifier path) {
+ public static <T extends StoreTreeNode<T>> T findNodeChecked(final T tree, final YangInstanceIdentifier path) {
T current = tree;
int i = 1;
* @return Map.Entry Entry with key which is path to closest parent and value is parent node.
*
*/
- public static <T extends StoreTreeNode<T>> Map.Entry<InstanceIdentifier, T> findClosest(final T tree, final InstanceIdentifier path) {
+ public static <T extends StoreTreeNode<T>> Map.Entry<YangInstanceIdentifier, T> findClosest(final T tree, final YangInstanceIdentifier path) {
return findClosestsOrFirstMatch(tree, path, Predicates.<T>alwaysFalse());
}
- public static <T extends StoreTreeNode<T>> Map.Entry<InstanceIdentifier, T> findClosestsOrFirstMatch(final T tree, final InstanceIdentifier path, final Predicate<T> predicate) {
+ public static <T extends StoreTreeNode<T>> Map.Entry<YangInstanceIdentifier, T> findClosestsOrFirstMatch(final T tree, final YangInstanceIdentifier path, final Predicate<T> predicate) {
Optional<T> parent = Optional.<T>of(tree);
Optional<T> current = Optional.<T> of(tree);
nesting++;
}
if(current.isPresent()) {
- final InstanceIdentifier currentPath = InstanceIdentifier.create(path.getPath().subList(0, nesting));
- return new SimpleEntry<InstanceIdentifier,T>(currentPath,current.get());
+ final YangInstanceIdentifier currentPath = YangInstanceIdentifier.create(path.getPath().subList(0, nesting));
+ return new SimpleEntry<YangInstanceIdentifier,T>(currentPath,current.get());
}
/*
* present. At any rate we check state just to be on the safe side.
*/
Preconditions.checkState(nesting > 0);
- final InstanceIdentifier parentPath = InstanceIdentifier.create(path.getPath().subList(0, nesting - 1));
+ final YangInstanceIdentifier parentPath = YangInstanceIdentifier.create(path.getPath().subList(0, nesting - 1));
- return new SimpleEntry<InstanceIdentifier,T>(parentPath,parent.get());
+ return new SimpleEntry<YangInstanceIdentifier,T>(parentPath,parent.get());
}
public static <T extends StoreTreeNode<T>> Optional<T> getChild(final Optional<T> parent,final PathArgument child) {
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
import com.google.common.base.Optional;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
}
@Override
- protected void checkSubtreeModificationApplicable(final InstanceIdentifier path, final NodeModification modification,
+ protected void checkSubtreeModificationApplicable(final YangInstanceIdentifier path, final NodeModification modification,
final Optional<TreeNode> current) throws IncorrectDataStructureException {
throw new IncorrectDataStructureException(path, "Subtree modification is not allowed.");
}
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.SimpleNode;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
final CompositeNode node = inputXmlToCompositeNode(input);
final SimpleNode<?> refParsed = node.getSimpleNodesByName("ref").iterator().next();
- Assert.assertEquals(InstanceIdentifier.class, refParsed.getValue().getClass());
+ Assert.assertEquals(YangInstanceIdentifier.class, refParsed.getValue().getClass());
final Document serializedDocument = inputCompositeNodeToXml(node);
XMLUnit.compareXML(inputDocument, serializedDocument);
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
@Test
public void testSchemaUnaware() throws Exception {
// Container
- DataContainerNodeBuilder<InstanceIdentifier.NodeIdentifier, ContainerNode> builder = Builders
+ DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode> builder = Builders
.containerBuilder().withNodeIdentifier(getNodeIdentifier("container"));
// leaf
.withValue(1).build())
.withChild(Builders.containerBuilder().withNodeIdentifier(getNodeIdentifier("containerInList")).build())
.withNodeIdentifier(
- new InstanceIdentifier.NodeIdentifierWithPredicates(getNodeIdentifier("list").getNodeType(),
+ new YangInstanceIdentifier.NodeIdentifierWithPredicates(getNodeIdentifier("list").getNodeType(),
Collections.singletonMap(getNodeIdentifier("uint32InList").getNodeType(), (Object) 1)))
.build();
AugmentationNode augmentation = Builders
.augmentationBuilder()
.withNodeIdentifier(
- new InstanceIdentifier.AugmentationIdentifier(Sets.newHashSet(getQName("augmentUint32"))))
+ new YangInstanceIdentifier.AugmentationIdentifier(Sets.newHashSet(getQName("augmentUint32"))))
.withChild(
Builders.<Integer> leafBuilder().withNodeIdentifier(getNodeIdentifier("augmentUint32"))
.withValue(11).build()).build();
@Test
public void testSchemaAware() throws Exception {
- DataContainerNodeBuilder<InstanceIdentifier.NodeIdentifier, ContainerNode> builder = Builders
+ DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode> builder = Builders
.containerBuilder(containerNode);
LeafSchemaNode schemaNode = (LeafSchemaNode) getSchemaNode(schema, "test", "uint32");
throw new IllegalStateException("Unable to find child augmentation in " + containerNode);
}
- private InstanceIdentifier.NodeWithValue getNodeWithValueIdentifier(final String localName, final Object value) {
- return new InstanceIdentifier.NodeWithValue(getQName(localName), value);
+ private YangInstanceIdentifier.NodeWithValue getNodeWithValueIdentifier(final String localName, final Object value) {
+ return new YangInstanceIdentifier.NodeWithValue(getQName(localName), value);
}
private QName getQName(final String localName) {
return new QName(URI.create(namespace), localName);
}
- private InstanceIdentifier.NodeIdentifier getNodeIdentifier(final String localName) {
- return new InstanceIdentifier.NodeIdentifier(getQName(localName));
+ private YangInstanceIdentifier.NodeIdentifier getNodeIdentifier(final String localName) {
+ return new YangInstanceIdentifier.NodeIdentifier(getQName(localName));
}
public static DataSchemaNode getSchemaNode(final SchemaContext context, final String moduleName, final String childNodeName) {
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeUtils;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
private static final String ONE = "one";
private static final String TWO = "two";
- private static final InstanceIdentifier LIST_A_FOO_PATH = InstanceIdentifier.builder()
+ private static final YangInstanceIdentifier LIST_A_FOO_PATH = YangInstanceIdentifier.builder()
//.node(ROOT_QNAME)
.node(LIST_A_QNAME)
.nodeWithKey(LIST_A_QNAME, LEAF_A_QNAME, FOO)
.build();
- private static final InstanceIdentifier LIST_B_TWO_PATH = InstanceIdentifier.builder()
+ private static final YangInstanceIdentifier LIST_B_TWO_PATH = YangInstanceIdentifier.builder()
//.node(ROOT_QNAME)
.node(LIST_A_QNAME)
.nodeWithKey(LIST_A_QNAME, LEAF_A_QNAME, BAR)
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
}
private static ContainerNode withAttributes() {
- DataContainerNodeBuilder<InstanceIdentifier.NodeIdentifier, ContainerNode> b = Builders.containerBuilder();
+ DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode> b = Builders.containerBuilder();
b.withNodeIdentifier(getNodeIdentifier("container"));
CollectionNodeBuilder<MapEntryNode, MapNode> listBuilder = Builders.mapBuilder().withNodeIdentifier(
Map<QName, Object> predicates = Maps.newHashMap();
predicates.put(getNodeIdentifier("uint32InList").getNodeType(), 3L);
- DataContainerNodeBuilder<InstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> list1Builder = Builders
+ DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> list1Builder = Builders
.mapEntryBuilder().withNodeIdentifier(
- new InstanceIdentifier.NodeIdentifierWithPredicates(getNodeIdentifier("list").getNodeType(),
+ new YangInstanceIdentifier.NodeIdentifierWithPredicates(getNodeIdentifier("list").getNodeType(),
predicates));
- NormalizedNodeBuilder<InstanceIdentifier.NodeIdentifier,Object,LeafNode<Object>> uint32InListBuilder
+ NormalizedNodeBuilder<YangInstanceIdentifier.NodeIdentifier,Object,LeafNode<Object>> uint32InListBuilder
= Builders.leafBuilder().withNodeIdentifier(getNodeIdentifier("uint32InList"));
list1Builder.withChild(uint32InListBuilder.withValue(3L).build());
listBuilder.withChild(list1Builder.build());
b.withChild(listBuilder.build());
- NormalizedNodeBuilder<InstanceIdentifier.NodeIdentifier, Object, LeafNode<Object>> booleanBuilder
+ NormalizedNodeBuilder<YangInstanceIdentifier.NodeIdentifier, Object, LeafNode<Object>> booleanBuilder
= Builders.leafBuilder().withNodeIdentifier(getNodeIdentifier("boolean"));
booleanBuilder.withValue(false);
b.withChild(booleanBuilder.build());
ListNodeBuilder<Object, LeafSetEntryNode<Object>> leafListBuilder
= Builders.leafSetBuilder().withNodeIdentifier(getNodeIdentifier("leafList"));
- NormalizedNodeBuilder<InstanceIdentifier.NodeWithValue, Object, LeafSetEntryNode<Object>> leafList1Builder
- = Builders.leafSetEntryBuilder().withNodeIdentifier(new InstanceIdentifier.NodeWithValue(getNodeIdentifier("leafList").getNodeType(), "a"));
+ NormalizedNodeBuilder<YangInstanceIdentifier.NodeWithValue, Object, LeafSetEntryNode<Object>> leafList1Builder
+ = Builders.leafSetEntryBuilder().withNodeIdentifier(new YangInstanceIdentifier.NodeWithValue(getNodeIdentifier("leafList").getNodeType(), "a"));
leafList1Builder.withValue("a");
private static ContainerNode augmentChoiceHell() {
- DataContainerNodeBuilder<InstanceIdentifier.NodeIdentifier, ContainerNode> b = Builders.containerBuilder();
+ DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode> b = Builders.containerBuilder();
b.withNodeIdentifier(getNodeIdentifier("container"));
b.withChild(
return b.build();
}
- private static InstanceIdentifier.NodeIdentifier getNodeIdentifier(final String localName) {
- return new InstanceIdentifier.NodeIdentifier(QName.create(URI.create(NAMESPACE), revision, localName));
+ private static YangInstanceIdentifier.NodeIdentifier getNodeIdentifier(final String localName) {
+ return new YangInstanceIdentifier.NodeIdentifier(QName.create(URI.create(NAMESPACE), revision, localName));
}
- public static InstanceIdentifier.AugmentationIdentifier getAugmentIdentifier(final String... childNames) {
+ public static YangInstanceIdentifier.AugmentationIdentifier getAugmentIdentifier(final String... childNames) {
Set<QName> qn = Sets.newHashSet();
for (String childName : childNames) {
qn.add(getNodeIdentifier(childName).getNodeType());
}
- return new InstanceIdentifier.AugmentationIdentifier(qn);
+ return new YangInstanceIdentifier.AugmentationIdentifier(qn);
}
public NormalizedNodeXmlTranslationTest(final String yangPath, final String xmlPath, final ContainerNode expectedNode) {
import org.junit.Before;
import org.junit.Test;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
private static final String TWO_ONE_NAME = "one";
private static final String TWO_TWO_NAME = "two";
- private static final InstanceIdentifier OUTER_LIST_1_PATH = InstanceIdentifier.builder(TestModel.OUTER_LIST_PATH)
+ private static final YangInstanceIdentifier OUTER_LIST_1_PATH = YangInstanceIdentifier.builder(TestModel.OUTER_LIST_PATH)
.nodeWithKey(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, ONE_ID) //
.build();
- private static final InstanceIdentifier OUTER_LIST_2_PATH = InstanceIdentifier.builder(TestModel.OUTER_LIST_PATH)
+ private static final YangInstanceIdentifier OUTER_LIST_2_PATH = YangInstanceIdentifier.builder(TestModel.OUTER_LIST_PATH)
.nodeWithKey(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, TWO_ID) //
.build();
- private static final InstanceIdentifier TWO_TWO_PATH = InstanceIdentifier.builder(OUTER_LIST_2_PATH)
+ private static final YangInstanceIdentifier TWO_TWO_PATH = YangInstanceIdentifier.builder(OUTER_LIST_2_PATH)
.node(TestModel.INNER_LIST_QNAME) //
.nodeWithKey(TestModel.INNER_LIST_QNAME, TestModel.NAME_QNAME, TWO_TWO_NAME) //
.build();
- private static final InstanceIdentifier TWO_TWO_VALUE_PATH = InstanceIdentifier.builder(TWO_TWO_PATH)
+ private static final YangInstanceIdentifier TWO_TWO_VALUE_PATH = YangInstanceIdentifier.builder(TWO_TWO_PATH)
.node(TestModel.VALUE_QNAME) //
.build();
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.parser.impl.YangParserImpl;
public static final QName VALUE_QNAME = QName.create(TEST_QNAME, "value");
private static final String DATASTORE_TEST_YANG = "/odl-datastore-test.yang";
- public static final InstanceIdentifier TEST_PATH = InstanceIdentifier.of(TEST_QNAME);
- public static final InstanceIdentifier OUTER_LIST_PATH = InstanceIdentifier.builder(TEST_PATH).node(OUTER_LIST_QNAME).build();
+ public static final YangInstanceIdentifier TEST_PATH = YangInstanceIdentifier.of(TEST_QNAME);
+ public static final YangInstanceIdentifier OUTER_LIST_PATH = YangInstanceIdentifier.builder(TEST_PATH).node(OUTER_LIST_QNAME).build();
public static final QName TWO_QNAME = QName.create(TEST_QNAME, "two");
public static final QName THREE_QNAME = QName.create(TEST_QNAME, "three");
import junit.framework.Assert;
import org.junit.Before;
import org.junit.Test;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
private static final String TWO_ONE_NAME = "one";
private static final String TWO_TWO_NAME = "two";
- private static final InstanceIdentifier OUTER_LIST_1_PATH = InstanceIdentifier.builder(TestModel.OUTER_LIST_PATH)
+ private static final YangInstanceIdentifier OUTER_LIST_1_PATH = YangInstanceIdentifier.builder(TestModel.OUTER_LIST_PATH)
.nodeWithKey(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, ONE_ID) //
.build();
- private static final InstanceIdentifier OUTER_LIST_2_PATH = InstanceIdentifier.builder(TestModel.OUTER_LIST_PATH)
+ private static final YangInstanceIdentifier OUTER_LIST_2_PATH = YangInstanceIdentifier.builder(TestModel.OUTER_LIST_PATH)
.nodeWithKey(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, TWO_ID) //
.build();
- private static final InstanceIdentifier TWO_TWO_PATH = InstanceIdentifier.builder(OUTER_LIST_2_PATH)
+ private static final YangInstanceIdentifier TWO_TWO_PATH = YangInstanceIdentifier.builder(OUTER_LIST_2_PATH)
.node(TestModel.INNER_LIST_QNAME) //
.nodeWithKey(TestModel.INNER_LIST_QNAME, TestModel.NAME_QNAME, TWO_TWO_NAME) //
.build();
public NormalizedNode<?, ?> createDocumentOne() {
return ImmutableContainerNodeBuilder
.create()
- .withNodeIdentifier(new InstanceIdentifier.NodeIdentifier(schemaContext.getQName()))
+ .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(schemaContext.getQName()))
.withChild(createTestContainer()).build();
}
private ContainerNode createTestContainer() {
return ImmutableContainerNodeBuilder
.create()
- .withNodeIdentifier(new InstanceIdentifier.NodeIdentifier(TestModel.TEST_QNAME))
+ .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TestModel.TEST_QNAME))
.withChild(
mapNodeBuilder(TestModel.OUTER_LIST_QNAME)
.withChild(mapEntry(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, ONE_ID))
InMemoryDataTreeSnapshot inMemoryDataTreeSnapshot = new InMemoryDataTreeSnapshot(schemaContext,
TreeNodeFactory.createTreeNode(createDocumentOne(), Version.initial()), rootOper);
TreeNode rootNode = inMemoryDataTreeSnapshot.getRootNode();
- final InstanceIdentifier outerList1InvalidPath = InstanceIdentifier.builder(TestModel.OUTER_LIST_PATH)
+ final YangInstanceIdentifier outerList1InvalidPath = YangInstanceIdentifier.builder(TestModel.OUTER_LIST_PATH)
.nodeWithKey(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 3) //
.build();
Optional<TreeNode> node = TreeNodeUtils.findNode(rootNode, outerList1InvalidPath);
InMemoryDataTreeSnapshot inMemoryDataTreeSnapshot = new InMemoryDataTreeSnapshot(schemaContext,
TreeNodeFactory.createTreeNode(createDocumentOne(), Version.initial()), rootOper);
TreeNode rootNode = inMemoryDataTreeSnapshot.getRootNode();
- final InstanceIdentifier outerList1InvalidPath = InstanceIdentifier.builder(TestModel.OUTER_LIST_PATH)
+ final YangInstanceIdentifier outerList1InvalidPath = YangInstanceIdentifier.builder(TestModel.OUTER_LIST_PATH)
.nodeWithKey(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 3) //
.build();
try {
TreeNode rootNode = inMemoryDataTreeSnapshot.getRootNode();
Optional<TreeNode> expectedNode = TreeNodeUtils.findNode(rootNode, TWO_TWO_PATH);
assertPresentAndType(expectedNode, TreeNode.class);
- Map.Entry<InstanceIdentifier, TreeNode> actualNode = TreeNodeUtils.findClosest(rootNode, TWO_TWO_PATH);
+ Map.Entry<YangInstanceIdentifier, TreeNode> actualNode = TreeNodeUtils.findClosest(rootNode, TWO_TWO_PATH);
Assert.assertEquals("Expected node and actual node are not the same", expectedNode.get(), actualNode.getValue());
}
InMemoryDataTreeSnapshot inMemoryDataTreeSnapshot = new InMemoryDataTreeSnapshot(schemaContext,
TreeNodeFactory.createTreeNode(createDocumentOne(), Version.initial()), rootOper);
TreeNode rootNode = inMemoryDataTreeSnapshot.getRootNode();
- final InstanceIdentifier outerListInnerListPath = InstanceIdentifier.builder(OUTER_LIST_2_PATH)
+ final YangInstanceIdentifier outerListInnerListPath = YangInstanceIdentifier.builder(OUTER_LIST_2_PATH)
.node(TestModel.INNER_LIST_QNAME)
.build();
- final InstanceIdentifier twoTwoInvalidPath = InstanceIdentifier.builder(OUTER_LIST_2_PATH)
+ final YangInstanceIdentifier twoTwoInvalidPath = YangInstanceIdentifier.builder(OUTER_LIST_2_PATH)
.node(TestModel.INNER_LIST_QNAME) //
.nodeWithKey(TestModel.INNER_LIST_QNAME, TestModel.NAME_QNAME, "three") //
.build();
Optional<TreeNode> expectedNode = TreeNodeUtils.findNode(rootNode, outerListInnerListPath);
assertPresentAndType(expectedNode, TreeNode.class);
- Map.Entry<InstanceIdentifier, TreeNode> actualNode = TreeNodeUtils.findClosest(rootNode, twoTwoInvalidPath);
+ Map.Entry<YangInstanceIdentifier, TreeNode> actualNode = TreeNodeUtils.findClosest(rootNode, twoTwoInvalidPath);
Assert.assertEquals("Expected node and actual node are not the same", expectedNode.get(), actualNode.getValue());
}
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.MutableCompositeNode;
import org.opendaylight.yangtools.yang.data.api.Node;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
return build;
}
- private static InstanceIdentifier.NodeIdentifier getNodeIdentifier(final String localName) {
+ private static YangInstanceIdentifier.NodeIdentifier getNodeIdentifier(final String localName) {
return getNodeIdentifier(MODULE_BASE, localName);
}
- private static InstanceIdentifier.NodeIdentifier getNodeIdentifier(final QNameModule module, final String localName) {
- return new InstanceIdentifier.NodeIdentifier(QName.create(module, localName));
+ private static YangInstanceIdentifier.NodeIdentifier getNodeIdentifier(final QNameModule module, final String localName) {
+ return new YangInstanceIdentifier.NodeIdentifier(QName.create(module, localName));
}
- private static InstanceIdentifier.NodeWithValue getNodeIdentifier(final String localName, final Object value) {
- return new InstanceIdentifier.NodeWithValue(QName.create(MODULE_BASE, localName),
+ private static YangInstanceIdentifier.NodeWithValue getNodeIdentifier(final String localName, final Object value) {
+ return new YangInstanceIdentifier.NodeWithValue(QName.create(MODULE_BASE, localName),
value);
}
- private static InstanceIdentifier.NodeIdentifierWithPredicates getNodeIdentifierPredicate(final String localName,
+ private static YangInstanceIdentifier.NodeIdentifierWithPredicates getNodeIdentifierPredicate(final String localName,
final Map<String, Object> keys) {
Map<QName, Object> predicate = new HashMap<>();
for (String key : keys.keySet()) {
predicate.put(QName.create(MODULE_BASE, key), keys.get(key));
}
- return new InstanceIdentifier.NodeIdentifierWithPredicates(QName.create(MODULE_BASE, localName), predicate);
+ return new YangInstanceIdentifier.NodeIdentifierWithPredicates(QName.create(MODULE_BASE, localName), predicate);
}
- private static InstanceIdentifier.AugmentationIdentifier getAugmentationIdentifier(final String localName,
+ private static YangInstanceIdentifier.AugmentationIdentifier getAugmentationIdentifier(final String localName,
final String namespace, final Date revision, final Set<QName> children) {
- return new InstanceIdentifier.AugmentationIdentifier(children);
+ return new YangInstanceIdentifier.AugmentationIdentifier(children);
}
}
import java.util.Set;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
return actual;
}
- Set<InstanceIdentifier.PathArgument> toProcess = getChildrenToProcess(schema, actual, modification);
+ Set<YangInstanceIdentifier.PathArgument> toProcess = getChildrenToProcess(schema, actual, modification);
List<? extends DataContainerChild<?, ?>> merged = modifyContainerChildNodes(schema, operationStack,
actual.get(), modification.get(), toProcess);
}
private List<? extends DataContainerChild<?, ?>> modifyContainerChildNodes(S schema, OperationStack operationStack,
- N actual, N modification, Set<InstanceIdentifier.PathArgument> toProcess) throws DataModificationException {
+ N actual, N modification, Set<YangInstanceIdentifier.PathArgument> toProcess) throws DataModificationException {
List<DataContainerChild<?, ?>> result = Lists.newArrayList();
- for (InstanceIdentifier.PathArgument childToProcessId : toProcess) {
+ for (YangInstanceIdentifier.PathArgument childToProcessId : toProcess) {
Object schemaOfChildToProcess = findSchema(schema, childToProcessId);
Optional<? extends DataContainerChild<?, ?>> modifiedValues = modifyContainerNode(operationStack, actual,
}
private Optional<? extends DataContainerChild<?, ?>> modifyContainerNode(OperationStack operationStack, N actual,
- N modification, InstanceIdentifier.PathArgument childToProcess, Object schemaChild)
+ N modification, YangInstanceIdentifier.PathArgument childToProcess, Object schemaChild)
throws DataModificationException {
Optional<DataContainerChild<?, ?>> storedChildren = actual.getChild(childToProcess);
return NodeDispatcher.dispatchChildModification(schemaChild, storedChildren, modifiedChildren, operationStack);
}
- private Object findSchema(S schema, InstanceIdentifier.PathArgument childToProcessId) {
- if (childToProcessId instanceof InstanceIdentifier.AugmentationIdentifier) {
- return findSchemaForAugment(schema, (InstanceIdentifier.AugmentationIdentifier) childToProcessId);
+ private Object findSchema(S schema, YangInstanceIdentifier.PathArgument childToProcessId) {
+ if (childToProcessId instanceof YangInstanceIdentifier.AugmentationIdentifier) {
+ return findSchemaForAugment(schema, (YangInstanceIdentifier.AugmentationIdentifier) childToProcessId);
} else {
return findSchemaForChild(schema, childToProcessId.getNodeType());
}
protected abstract Object findSchemaForChild(S schema, QName nodeType);
- protected abstract Object findSchemaForAugment(S schema, InstanceIdentifier.AugmentationIdentifier childToProcessId);
+ protected abstract Object findSchemaForAugment(S schema, YangInstanceIdentifier.AugmentationIdentifier childToProcessId);
private Optional<N> build(S schema, List<? extends DataContainerChild<?, ?>> result) {
DataContainerNodeBuilder<?, N> b = getBuilder(schema);
protected abstract DataContainerNodeBuilder<?, N> getBuilder(S schema);
- protected Set<InstanceIdentifier.PathArgument> getChildrenToProcess(S schema, Optional<N> actual,
+ protected Set<YangInstanceIdentifier.PathArgument> getChildrenToProcess(S schema, Optional<N> actual,
Optional<N> modification) throws DataModificationException {
- Set<InstanceIdentifier.PathArgument> qNames = Sets.newLinkedHashSet();
+ Set<YangInstanceIdentifier.PathArgument> qNames = Sets.newLinkedHashSet();
qNames.addAll(getChildQNames(actual));
qNames.addAll(getChildQNames(modification));
return qNames;
}
- private Set<? extends InstanceIdentifier.PathArgument> getChildQNames(Optional<N> actual) {
- Set<InstanceIdentifier.PathArgument> qNames = Sets.newLinkedHashSet();
+ private Set<? extends YangInstanceIdentifier.PathArgument> getChildQNames(Optional<N> actual) {
+ Set<YangInstanceIdentifier.PathArgument> qNames = Sets.newLinkedHashSet();
- for (DataContainerChild<? extends InstanceIdentifier.PathArgument, ?> child : actual.get().getValue()) {
+ for (DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> child : actual.get().getValue()) {
qNames.add(child.getIdentifier());
}
package org.opendaylight.yangtools.yang.data.operations;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
}
@Override
- protected Object findSchemaForAugment(AugmentationSchema schema, InstanceIdentifier.AugmentationIdentifier childToProcessId) {
+ protected Object findSchemaForAugment(AugmentationSchema schema, YangInstanceIdentifier.AugmentationIdentifier childToProcessId) {
throw new UnsupportedOperationException("Augmentation cannot be augmented directly, " + schema);
}
import java.util.Set;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
}
@Override
- protected Set<InstanceIdentifier.PathArgument> getChildrenToProcess(ChoiceNode schema,
+ protected Set<YangInstanceIdentifier.PathArgument> getChildrenToProcess(ChoiceNode schema,
Optional<org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode> actual,
Optional<org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode> modification)
throws DataModificationException {
- Set<InstanceIdentifier.PathArgument> childrenToProcess = super.getChildrenToProcess(schema, actual,
+ Set<YangInstanceIdentifier.PathArgument> childrenToProcess = super.getChildrenToProcess(schema, actual,
modification);
if (modification.isPresent() == false) {
// Detect case node from modification
ChoiceCaseNode detectedCase = null;
- for (DataContainerChild<? extends InstanceIdentifier.PathArgument, ?> child : modification.get().getValue()) {
+ for (DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> child : modification.get().getValue()) {
Optional<ChoiceCaseNode> detectedCaseForChild = SchemaUtils.detectCase(schema, child);
if(detectedCaseForChild.isPresent() == false) {
// Filter out child nodes that do not belong to detected case =
// Nodes from other cases present in actual
- Set<InstanceIdentifier.PathArgument> childrenToProcessFiltered = Sets.newLinkedHashSet();
- for (InstanceIdentifier.PathArgument childToProcess : childrenToProcess) {
+ Set<YangInstanceIdentifier.PathArgument> childrenToProcessFiltered = Sets.newLinkedHashSet();
+ for (YangInstanceIdentifier.PathArgument childToProcess : childrenToProcess) {
// child from other cases, skip
if (childToProcess instanceof AugmentationNode
&& SchemaUtils.belongsToCaseAugment(detectedCase,
- (InstanceIdentifier.AugmentationIdentifier) childToProcess) == false) {
+ (YangInstanceIdentifier.AugmentationIdentifier) childToProcess) == false) {
continue;
} else if (belongsToCase(detectedCase, childToProcess) == false) {
continue;
return childrenToProcessFiltered;
}
- private boolean belongsToCase(ChoiceCaseNode detectedCase, InstanceIdentifier.PathArgument childToProcess) {
+ private boolean belongsToCase(ChoiceCaseNode detectedCase, YangInstanceIdentifier.PathArgument childToProcess) {
return detectedCase.getDataChildByName(childToProcess.getNodeType()) != null;
}
@Override
- protected Object findSchemaForAugment(ChoiceNode schema, InstanceIdentifier.AugmentationIdentifier childToProcessId) {
+ protected Object findSchemaForAugment(ChoiceNode schema, YangInstanceIdentifier.AugmentationIdentifier childToProcessId) {
return SchemaUtils.findSchemaForAugment(schema, childToProcessId.getPossibleChildNames());
}
package org.opendaylight.yangtools.yang.data.operations;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
@Override
protected Object findSchemaForAugment(ContainerSchemaNode schema,
- InstanceIdentifier.AugmentationIdentifier childToProcessId) {
+ YangInstanceIdentifier.AugmentationIdentifier childToProcessId) {
return SchemaUtils.findSchemaForAugment(schema, childToProcessId.getPossibleChildNames());
}
package org.opendaylight.yangtools.yang.data.operations;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
}
@Override
- protected Object findSchemaForAugment(ListSchemaNode schema, InstanceIdentifier.AugmentationIdentifier childToProcessId) {
+ protected Object findSchemaForAugment(ListSchemaNode schema, YangInstanceIdentifier.AugmentationIdentifier childToProcessId) {
return SchemaUtils.findSchemaForAugment(schema, childToProcessId.getPossibleChildNames());
}
import java.util.Map;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
if (modification.isPresent() == false)
return actual;
- Map<InstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> resultNodes = Maps.newLinkedHashMap();
+ Map<YangInstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> resultNodes = Maps.newLinkedHashMap();
if(actual.isPresent())
resultNodes.putAll(mapEntries(actual.get()));
operationStack.enteringNode(mapEntryModification);
- InstanceIdentifier.NodeIdentifierWithPredicates entryKey = mapEntryModification.getIdentifier();
+ YangInstanceIdentifier.NodeIdentifierWithPredicates entryKey = mapEntryModification.getIdentifier();
switch (operationStack.getCurrentOperation()) {
case NONE:
return build(schema, resultNodes);
}
- private Optional<MapNode> build(ListSchemaNode schema, Map<InstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> resultNodes) {
+ private Optional<MapNode> build(ListSchemaNode schema, Map<YangInstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> resultNodes) {
if(resultNodes.isEmpty())
return Optional.absent();
return Optional.of(b.build());
}
- private Map<InstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> mapEntries(MapNode mapNode) {
- Map<InstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> mapped = Maps.newLinkedHashMap();
+ private Map<YangInstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> mapEntries(MapNode mapNode) {
+ Map<YangInstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> mapped = Maps.newLinkedHashMap();
for (MapEntryNode mapEntryNode : mapNode.getValue()) {
mapped.put(mapEntryNode.getIdentifier(), mapEntryNode);
Code Review / yangtools.git / commitdiff