Direct constructors are going away, use factory methods instead.
Change-Id: I14092a254320f12269c72304e70dcf7ee5f86e97
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>
AbstractMapMixin(final ListSchemaNode list) {
super(NodeIdentifier.create(list.getQName()));
- this.innerNode = new ListEntry(new NodeIdentifierWithPredicates(list.getQName(), ImmutableMap.of()), list);
+ this.innerNode = new ListEntry(NodeIdentifierWithPredicates.of(list.getQName()), list);
}
@Override
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.Sessions;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.sessions.Session;
import org.opendaylight.yangtools.yang.common.QName;
-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.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
moduleInfoBackedContext.addModuleInfos(Collections.singletonList($YangModuleInfoImpl.getInstance()));
final SchemaContext context = moduleInfoBackedContext.getSchemaContext();
final LeafNode<?> username = Builders.leafBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(QName.create(Session.QNAME, "username")))
+ .withNodeIdentifier(new NodeIdentifier(QName.create(Session.QNAME, "username")))
.withValue("admin")
.build();
final MapEntryNode session1 = Builders.mapEntryBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier
- .NodeIdentifierWithPredicates(Session.QNAME, QName.create(Session.QNAME, "session-id"), 1L))
+ .withNodeIdentifier(
+ NodeIdentifierWithPredicates.of(Session.QNAME, QName.create(Session.QNAME, "session-id"), 1L))
.withChild(username)
.build();
final MapNode sessionList = Builders.mapBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(Session.QNAME))
+ .withNodeIdentifier(new NodeIdentifier(Session.QNAME))
.withChild(session1)
.build();
final ContainerNode sessions = Builders.containerBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(Sessions.QNAME))
+ .withNodeIdentifier(new NodeIdentifier(Sessions.QNAME))
.withChild(sessionList)
.build();
final DOMResult result = new DOMResult(XmlUtil.newDocument());
private RemoteDeviceId(final String name) {
this.name = Preconditions.checkNotNull(name);
this.topologyPath = DEFAULT_TOPOLOGY_NODE
- .node(new NodeIdentifierWithPredicates(Node.QNAME, NODE_ID_QNAME, name));
+ .node(NodeIdentifierWithPredicates.of(Node.QNAME, NODE_ID_QNAME, name));
this.key = new NodeKey(new NodeId(name));
this.topologyBindingPath = DEFAULT_TOPOLOGY_IID.child(Node.class, key);
}
- public RemoteDeviceId(final String name, InetSocketAddress address) {
+ public RemoteDeviceId(final String name, final InetSocketAddress address) {
this(name);
this.address = address;
this.host = buildHost();
import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.toPath;
import static org.opendaylight.netconf.util.NetconfUtil.NETCONF_DATA_QNAME;
-import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import java.io.IOException;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.schemas.Schema;
import org.opendaylight.yangtools.yang.common.QName;
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.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.AnyXmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
assertTrue(compositeNodeRpcResult.getErrors().isEmpty());
assertNotNull(compositeNodeRpcResult.getResult());
- final List<DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?>> values = Lists.newArrayList(
+ final List<DataContainerChild<?, ?>> values = Lists.newArrayList(
NetconfRemoteSchemaYangSourceProvider
.createGetSchemaRequest("module", Optional.of("2012-12-12")).getValue());
final Map<QName, Object> keys = new HashMap<>();
- for (final DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> value : values) {
+ for (final DataContainerChild<?, ?> value : values) {
keys.put(value.getNodeType(), value.getValue());
}
- final YangInstanceIdentifier.NodeIdentifierWithPredicates identifierWithPredicates =
- new YangInstanceIdentifier.NodeIdentifierWithPredicates(Schema.QNAME, keys);
+ final NodeIdentifierWithPredicates identifierWithPredicates =
+ NodeIdentifierWithPredicates.of(Schema.QNAME, keys);
final MapEntryNode schemaNode =
Builders.mapEntryBuilder().withNodeIdentifier(identifierWithPredicates).withValue(values).build();
public void testGetConfigLeafRequest() throws Exception {
final DataContainerChild<?, ?> filter = toFilterStructure(
YangInstanceIdentifier.create(toId(NetconfState.QNAME), toId(Schemas.QNAME), toId(Schema.QNAME),
- new NodeIdentifierWithPredicates(Schema.QNAME, ImmutableMap.of()),
+ NodeIdentifierWithPredicates.of(Schema.QNAME),
toId(QName.create(Schemas.QNAME, "version"))), SCHEMA);
final DataContainerChild<?, ?> source = NetconfBaseOps.getSourceNode(NETCONF_RUNNING_QNAME);
@Test
public void testEditConfigRequest() throws Exception {
- final List<DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?>> values = Lists.newArrayList(
+ final List<DataContainerChild<?, ?>> values = Lists.newArrayList(
NetconfRemoteSchemaYangSourceProvider
.createGetSchemaRequest("module", Optional.of("2012-12-12")).getValue());
final Map<QName, Object> keys = new HashMap<>();
- for (final DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> value : values) {
+ for (final DataContainerChild<?, ?> value : values) {
keys.put(value.getNodeType(), value.getValue());
}
- final YangInstanceIdentifier.NodeIdentifierWithPredicates identifierWithPredicates =
- new YangInstanceIdentifier.NodeIdentifierWithPredicates(Schema.QNAME, keys);
+ final NodeIdentifierWithPredicates identifierWithPredicates =
+ NodeIdentifierWithPredicates.of(Schema.QNAME, keys);
final MapEntryNode schemaNode =
Builders.mapEntryBuilder().withNodeIdentifier(identifierWithPredicates).withValue(values).build();
final QName capability = QName.create(Capabilities.QNAME, "capability");
final DataContainerChild<?, ?> filter = toFilterStructure(
YangInstanceIdentifier.create(toId(NetconfState.QNAME), toId(Capabilities.QNAME), toId(capability),
- new YangInstanceIdentifier.NodeWithValue<>(capability, "a:b:c")), SCHEMA);
+ new NodeWithValue<>(capability, "a:b:c")), SCHEMA);
final NetconfMessage netconfMessage = netconfMessageTransformer.toRpcRequest(toPath(NETCONF_GET_QNAME),
NetconfMessageTransformUtil.wrap(NETCONF_GET_QNAME, filter));
QName nameQname = QName.create(SERVER_QNAME, "name");
List<PathArgument> nodeIdentifiers = new ArrayList<>();
nodeIdentifiers.add(new NodeIdentifier(SERVER_QNAME));
- nodeIdentifiers.add(new NodeIdentifierWithPredicates(SERVER_QNAME, nameQname, "test"));
+ nodeIdentifiers.add(NodeIdentifierWithPredicates.of(SERVER_QNAME, nameQname, "test"));
DOMDataTreeIdentifier domDataTreeIdentifier = prepareDataTreeId(nodeIdentifiers);
ContainerNode data = initInputAction(QName.create(SERVER_QNAME, "reset-at"), "now");
List<PathArgument> nodeIdentifiers = new ArrayList<>();
nodeIdentifiers.add(NodeIdentifier.create(DEVICE_QNAME));
nodeIdentifiers.add(NodeIdentifier.create(INTERFACE_QNAME));
- nodeIdentifiers.add(new NodeIdentifierWithPredicates(INTERFACE_QNAME, nameQname, "test"));
+ nodeIdentifiers.add(NodeIdentifierWithPredicates.of(INTERFACE_QNAME, nameQname, "test"));
DOMDataTreeIdentifier domDataTreeIdentifier = prepareDataTreeId(nodeIdentifiers);
List<PathArgument> nodeIdentifiers = new ArrayList<>();
nodeIdentifiers.add(NodeIdentifier.create(SERVER_QNAME));
- nodeIdentifiers.add(new NodeIdentifierWithPredicates(SERVER_QNAME, serverNameQname, "testServer"));
- nodeIdentifiers.add(new YangInstanceIdentifier
- .AugmentationIdentifier(Collections.singleton(APPLICATIONS_QNAME)));
+ nodeIdentifiers.add(NodeIdentifierWithPredicates.of(SERVER_QNAME, serverNameQname, "testServer"));
+ nodeIdentifiers.add(new AugmentationIdentifier(Collections.singleton(APPLICATIONS_QNAME)));
nodeIdentifiers.add(NodeIdentifier.create(APPLICATIONS_QNAME));
nodeIdentifiers.add(NodeIdentifier.create(APPLICATION_QNAME));
- nodeIdentifiers.add(new NodeIdentifierWithPredicates(APPLICATION_QNAME,
+ nodeIdentifiers.add(NodeIdentifierWithPredicates.of(APPLICATION_QNAME,
applicationNameQname, "testApplication"));
DOMDataTreeIdentifier domDataTreeIdentifier = prepareDataTreeId(nodeIdentifiers);
List<PathArgument> nodeIdentifiers = new ArrayList<>();
nodeIdentifiers.add(NodeIdentifier.create(BAR_QNAME));
- nodeIdentifiers.add(new NodeIdentifierWithPredicates(BAR_QNAME, barIdQname, "test"));
+ nodeIdentifiers.add(NodeIdentifierWithPredicates.of(BAR_QNAME, barIdQname, "test"));
DOMDataTreeIdentifier domDataTreeIdentifier = prepareDataTreeId(nodeIdentifiers);
import org.opendaylight.netconf.api.xml.XmlUtil;
import org.opendaylight.yangtools.yang.common.QName;
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.schema.AnyXmlNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.w3c.dom.Document;
Assert.assertTrue(String.format("Input %s: %s", testDataset, diff.toString()), diff.similar());
}
- private static YangInstanceIdentifier.NodeIdentifier createNodeId(final String name) {
- return new YangInstanceIdentifier.NodeIdentifier(QName.create(NAMESPACE, name));
+ private static NodeIdentifier createNodeId(final String name) {
+ return new NodeIdentifier(QName.create(NAMESPACE, name));
}
- private static YangInstanceIdentifier.NodeIdentifierWithPredicates createListNodeId(
+ private static NodeIdentifierWithPredicates createListNodeId(
final String nodeName, final String keyName, final String id) {
- return new YangInstanceIdentifier
- .NodeIdentifierWithPredicates(QName.create(NAMESPACE, nodeName), QName.create(NAMESPACE, keyName), id);
+ return NodeIdentifierWithPredicates.of(QName.create(NAMESPACE, nodeName), QName.create(NAMESPACE, keyName), id);
}
- private static YangInstanceIdentifier.NodeIdentifierWithPredicates createListNodeId(
- final String nodeName, final Map<QName, Object> keys) {
- return new YangInstanceIdentifier.NodeIdentifierWithPredicates(QName.create(NAMESPACE, nodeName), keys);
+ private static NodeIdentifierWithPredicates createListNodeId(final String nodeName, final Map<QName, Object> keys) {
+ return NodeIdentifierWithPredicates.of(QName.create(NAMESPACE, nodeName), keys);
}
}
import org.opendaylight.yangtools.util.concurrent.SpecialExecutors;
import org.opendaylight.yangtools.yang.common.QName;
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.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
final QName namespace = QName.create(Schema.QNAME, "namespace");
CollectionNodeBuilder<MapEntryNode, MapNode> schemaMapEntryNodeMapNodeCollectionNodeBuilder = Builders
- .mapBuilder().withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(Schema.QNAME));
+ .mapBuilder().withNodeIdentifier(new NodeIdentifier(Schema.QNAME));
LeafSetEntryNode locationLeafSetEntryNode = Builders.leafSetEntryBuilder().withNodeIdentifier(
- new YangInstanceIdentifier.NodeWithValue(location, "NETCONF")).withValue("NETCONF").build();
+ new NodeWithValue<>(location, "NETCONF")).withValue("NETCONF").build();
Map<QName, Object> keyValues = Maps.newHashMap();
for (final Schema schema : monitor.getSchemas().getSchema()) {
keyValues.put(version, schema.getVersion());
keyValues.put(format, Yang.QNAME);
- MapEntryNode schemaMapEntryNode = Builders.mapEntryBuilder().withNodeIdentifier(
- new YangInstanceIdentifier.NodeIdentifierWithPredicates(Schema.QNAME, keyValues))
- .withChild(Builders.leafBuilder().withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(
- identifier)).withValue(schema.getIdentifier()).build())
- .withChild(Builders.leafBuilder().withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(
- version)).withValue(schema.getVersion()).build())
- .withChild(Builders.leafBuilder().withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(
- format)).withValue(Yang.QNAME).build())
- .withChild(Builders.leafBuilder().withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(
- namespace)).withValue(schema.getNamespace().getValue()).build())
+ MapEntryNode schemaMapEntryNode = Builders.mapEntryBuilder()
+ .withNodeIdentifier(NodeIdentifierWithPredicates.of(Schema.QNAME, keyValues))
+ .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(identifier))
+ .withValue(schema.getIdentifier()).build())
+ .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(version))
+ .withValue(schema.getVersion()).build())
+ .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(format))
+ .withValue(Yang.QNAME).build())
+ .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(namespace))
+ .withValue(schema.getNamespace().getValue()).build())
.withChild((DataContainerChild<?, ?>) Builders.leafSetBuilder().withNodeIdentifier(
- new YangInstanceIdentifier.NodeIdentifier(location))
+ new NodeIdentifier(location))
.withChild(locationLeafSetEntryNode).build())
.build();
DataContainerChild<?, ?> schemaList = schemaMapEntryNodeMapNodeCollectionNodeBuilder.build();
ContainerNode schemasContainer = Builders.containerBuilder().withNodeIdentifier(
- new YangInstanceIdentifier.NodeIdentifier(Schemas.QNAME)).withChild(schemaList).build();
+ new NodeIdentifier(Schemas.QNAME)).withChild(schemaList).build();
return Builders.containerBuilder().withNodeIdentifier(
- new YangInstanceIdentifier.NodeIdentifier(NetconfState.QNAME)).withChild(schemasContainer).build();
+ new NodeIdentifier(NetconfState.QNAME)).withChild(schemasContainer).build();
}
private static DOMDataBroker createDataStore(final DOMSchemaService schemaService, final long sessionId) {
validNamespace);
predicatesMap.put(listKey.getQName(), predicate.getValue());
}
- pathArgument = new NodeIdentifierWithPredicates(qName, predicatesMap);
+ pathArgument = NodeIdentifierWithPredicates.of(qName, predicatesMap);
} else {
LOG.info("Node {} is not List or Leaf-list.", node);
LOG.info("Instance-identifier will be translated as NULL for data - {}",
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.controller.sal.restconf.impl.test;
import static org.junit.Assert.assertEquals;
@Test
public void testLeafrefListKeyDeserializtion() {
final YangInstanceIdentifier node1IIexpected = YangInstanceIdentifier.of(CONT_QNAME)
- .node(LST_WITH_LFREF_KEY_QNAME).node(new NodeIdentifierWithPredicates(
+ .node(LST_WITH_LFREF_KEY_QNAME).node(NodeIdentifierWithPredicates.of(
LST_WITH_LFREF_KEY_QNAME, LFREF_KEY_QNAME, "node1"));
final InstanceIdentifierContext<?> iiContext =
controllerContext.toInstanceIdentifier("leafref-module:cont/lst-with-lfref-key/node1");
import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
keyValues.put(NAME_QNAME, "name");
keyValues.put(TYPE_QNAME, MODULE_TYPE_QNAME);
final YangInstanceIdentifier expectedYII = YangInstanceIdentifier.of(MODULES_QNAME).node(MODULE_QNAME)
- .node(new YangInstanceIdentifier.NodeIdentifierWithPredicates(MODULE_QNAME, keyValues));
+ .node(NodeIdentifierWithPredicates.of(MODULE_QNAME, keyValues));
assertEquals(expectedYII, ctx.getInstanceIdentifier());
}
keyValues.put(QName.create(new URI("augment:module"), "keyvalue111"), "value1");
keyValues.put(QName.create(new URI("augment:module"), "keyvalue112"), "value2");
final NodeIdentifierWithPredicates nodeIdentifierWithPredicates =
- new NodeIdentifierWithPredicates(qName, keyValues);
+ NodeIdentifierWithPredicates.of(qName, keyValues);
pathArguments.add(nodeIdentifierWithPredicates);
pathArguments.add(new NodeIdentifier(QName.create(new URI("augment:augment:module"), "lf112")));
}
private static NodeIdentifierWithPredicates toIdentifier(final String localName, final Map<QName, Object> keys) {
- return new NodeIdentifierWithPredicates(QName.create("urn:nested:module", "2014-06-03", localName),
- keys);
+ return NodeIdentifierWithPredicates.of(QName.create("urn:nested:module", "2014-06-03", localName), keys);
}
private static NodeWithValue<?> toIdentifier(final String localName, final Object value) {
assertTrue("Expected MapNode. Actual " + mapChild.get().getClass(), mapChild.get() instanceof MapNode);
final MapNode mapNode = (MapNode)mapChild.get();
- final NodeIdentifierWithPredicates entryNodeID = new NodeIdentifierWithPredicates(
+ final NodeIdentifierWithPredicates entryNodeID = NodeIdentifierWithPredicates.of(
INTERFACE_QNAME, NAME_QNAME, "eth0");
final java.util.Optional<MapEntryNode> entryChild = mapNode.getChild(entryNodeID);
assertEquals(entryNodeID.toString() + " present", true, entryChild.isPresent());
final QName qNameList = newTestModuleQName("lst1");
final QName qNameKeyList = newTestModuleQName("lf11");
- parameters.add(new YangInstanceIdentifier.NodeIdentifier(qNameCont));
- parameters.add(new YangInstanceIdentifier.NodeIdentifier(qNameList));
- parameters.add(new YangInstanceIdentifier.NodeIdentifierWithPredicates(qNameList, qNameKeyList,
- "GigabitEthernet0/0/0/0"));
+ parameters.add(new NodeIdentifier(qNameCont));
+ parameters.add(new NodeIdentifier(qNameList));
+ parameters.add(NodeIdentifierWithPredicates.of(qNameList, qNameKeyList, "GigabitEthernet0/0/0/0"));
return YangInstanceIdentifier.create(parameters);
}
setControllerContext(schemaContextTestModule);
final QName moduleQN = newTestModuleQName("module");
- final ImmutableMap<QName, Object> keyMap = ImmutableMap.<QName, Object>builder()
- .put(newTestModuleQName("type"), newTestModuleQName("test-identity"))
- .put(newTestModuleQName("name"), "foo").build();
+ final ImmutableMap<QName, Object> keyMap = ImmutableMap.of(
+ newTestModuleQName("type"), newTestModuleQName("test-identity"),
+ newTestModuleQName("name"), "foo");
final YangInstanceIdentifier iid = YangInstanceIdentifier.builder().node(newTestModuleQName("modules"))
.node(moduleQN).nodeWithKey(moduleQN, keyMap).build();
@SuppressWarnings("rawtypes")
final NormalizedNode data = ImmutableMapNodeBuilder.create().withNodeIdentifier(
new NodeIdentifier(moduleQN)).withChild(ImmutableNodes.mapEntryBuilder()
- .withNodeIdentifier(new NodeIdentifierWithPredicates(moduleQN, keyMap))
+ .withNodeIdentifier(NodeIdentifierWithPredicates.of(moduleQN, keyMap))
.withChild(ImmutableNodes.leafNode(newTestModuleQName("type"), newTestModuleQName("test-identity")))
.withChild(ImmutableNodes.leafNode(newTestModuleQName("name"), "foo"))
.withChild(ImmutableNodes.leafNode(newTestModuleQName("data"), "bar")).build()).build();
final QName qName = QName.create("urn:ietf:params:xml:ns:yang:test-interface", "2014-07-01", "interface");
final QName qNameKey = QName.create("urn:ietf:params:xml:ns:yang:test-interface", "2014-07-01", "name");
final NodeIdentifierWithPredicates identWithPredicates =
- new NodeIdentifierWithPredicates(qName, qNameKey, "key");
+ NodeIdentifierWithPredicates.of(qName, qNameKey, "key");
Mockito.when(data.getNodeType()).thenReturn(qName);
Mockito.when(data.getIdentifier()).thenReturn(identWithPredicates);
final NormalizedNodeContext payload = new NormalizedNodeContext(iiCx, data);
final QName qName = QName.create("urn:ietf:params:xml:ns:yang:test-interface", "2014-07-01", "sub-interface");
final QName qNameSubKey = QName.create("urn:ietf:params:xml:ns:yang:test-interface", "2014-07-01", "sub-name");
final NodeIdentifierWithPredicates identWithPredicates =
- new NodeIdentifierWithPredicates(qName, qNameSubKey, "subkey");
+ NodeIdentifierWithPredicates.of(qName, qNameSubKey, "subkey");
Mockito.when(data.getNodeType()).thenReturn(qName);
Mockito.when(data.getIdentifier()).thenReturn(identWithPredicates);
final NormalizedNodeContext payload = new NormalizedNodeContext(iiCx, data);
final QName qName = QName.create("urn:ietf:params:xml:ns:yang:test-interface", "2014-07-01", "interface");
final QName qNameKey = QName.create("urn:ietf:params:xml:ns:yang:test-interface", "2014-07-01", "name");
final NodeIdentifierWithPredicates identWithPredicates =
- new NodeIdentifierWithPredicates(qName, qNameKey, "notSameKey");
+ NodeIdentifierWithPredicates.of(qName, qNameKey, "notSameKey");
Mockito.when(data.getNodeType()).thenReturn(qName);
Mockito.when(data.getIdentifier()).thenReturn(identWithPredicates);
final NormalizedNodeContext payload = new NormalizedNodeContext(iiCx, data);
final MapEntryNode payload = mock(MapEntryNode.class);
final NodeIdentifierWithPredicates nodeIdWithPred =
- new NodeIdentifierWithPredicates(keyDef, keyDef, al2.toArray());
+ NodeIdentifierWithPredicates.of(keyDef, keyDef, al2.toArray());
when(payload.getIdentifier()).thenReturn(nodeIdWithPred);
final List<QName> keyDefinitions = new ArrayList<>();
predicate.put(QName.create(namespace, revision, key), keys.get(key));
}
- return new NodeIdentifierWithPredicates(QName.create(namespace, revision, localName), predicate);
+ return NodeIdentifierWithPredicates.of(QName.create(namespace, revision, localName), predicate);
}
public static NodeIdentifierWithPredicates getNodeIdentifierPredicate(final String localName,
predicate.put(QName.create(namespace, revision, keysAndValues[index++]), keysAndValues[index++]);
}
- return new NodeIdentifierWithPredicates(QName.create(namespace, revision, localName), predicate);
+ return NodeIdentifierWithPredicates.of(QName.create(namespace, revision, localName), predicate);
}
public static NormalizedNode<?, ?> prepareNormalizedNodeWithIetfInterfacesInterfacesData() throws ParseException {
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.yangtools.yang.common.QName;
-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;
keyLeafNodeIdentifier = NodeIdentifier.create(mapEntryNodeKey);
keyLeafNodeValue = "key-value";
- mapEntryNodeIdentifier = new YangInstanceIdentifier.NodeIdentifierWithPredicates(
- QName.create("namespace", "list-entry"), Collections.singletonMap(mapEntryNodeKey, keyLeafNodeValue));
+ mapEntryNodeIdentifier = NodeIdentifierWithPredicates.of(
+ QName.create("namespace", "list-entry"), mapEntryNodeKey, keyLeafNodeValue);
when(mapEntryNodeData.getIdentifier()).thenReturn(mapEntryNodeIdentifier);
when(mapEntryNodeData.getChild(keyLeafNodeIdentifier)).thenReturn(Optional.of(keyLeafNodeData));
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.netconf.sal.restconf.impl;
import static org.junit.Assert.assertEquals;
import org.opendaylight.yangtools.concepts.Codec;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
.build();
this.instanceIdentifierOKList = YangInstanceIdentifier.builder()
- .node(new YangInstanceIdentifier.NodeIdentifierWithPredicates(
+ .node(NodeIdentifierWithPredicates.of(
QName.create(baseQName, "list-one-key"),
QName.create(QName.create(baseQName, "list-one-key"), "name"), "value"))
.build();
final MapEntryNode entry = mock(MapEntryNode.class);
final Map<QName, Object> keyValues = new HashMap<>();
keyValues.put(leaf.getNodeType(), "value");
- final NodeIdentifierWithPredicates nodeId = new NodeIdentifierWithPredicates(leaf.getNodeType(), keyValues);
+ final NodeIdentifierWithPredicates nodeId = NodeIdentifierWithPredicates.of(leaf.getNodeType(), keyValues);
when(entry.getIdentifier()).thenReturn(nodeId);
when(entry.getChild(any())).thenReturn(Optional.of(leaf));
predicate.getName().getValue(), validNamespace);
predicatesMap.put(listKey.getQName(), predicate.getValue());
}
- pathArgument = new NodeIdentifierWithPredicates(qName, predicatesMap);
+ pathArgument = NodeIdentifierWithPredicates.of(qName, predicatesMap);
} else {
LOG.info("Node {} is not List or Leaf-list.", node);
LOG.info("Instance-identifier will be translated as NULL for data - {}",
predicate.put(QName.create(namespace, revision, key), keys.get(key));
}
- return new NodeIdentifierWithPredicates(QName.create(namespace, revision, localName), predicate);
+ return NodeIdentifierWithPredicates.of(QName.create(namespace, revision, localName), predicate);
}
public static NodeIdentifierWithPredicates getNodeIdentifierPredicate(final String localName,
predicate.put(QName.create(namespace, revision, keysAndValues[index++]), keysAndValues[index++]);
}
- return new NodeIdentifierWithPredicates(QName.create(namespace, revision, localName), predicate);
+ return NodeIdentifierWithPredicates.of(QName.create(namespace, revision, localName), predicate);
}
public static NormalizedNode<?, ?> prepareNormalizedNodeWithIetfInterfacesInterfacesData() throws ParseException {
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.yangtools.yang.common.QName;
-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;
keyLeafNodeIdentifier = NodeIdentifier.create(mapEntryNodeKey);
keyLeafNodeValue = "key-value";
- mapEntryNodeIdentifier = new YangInstanceIdentifier.NodeIdentifierWithPredicates(
- QName.create("namespace", "list-entry"), Collections.singletonMap(mapEntryNodeKey, keyLeafNodeValue));
+ mapEntryNodeIdentifier = NodeIdentifierWithPredicates.of(
+ QName.create("namespace", "list-entry"), mapEntryNodeKey, keyLeafNodeValue);
when(mapEntryNodeData.getIdentifier()).thenReturn(mapEntryNodeIdentifier);
when(mapEntryNodeData.getChild(keyLeafNodeIdentifier)).thenReturn(Optional.of(keyLeafNodeData));
keyLeafNodeIdentifier = NodeIdentifier.create(mapEntryNodeKey);
keyLeafNodeValue = "key-value";
- mapEntryNodeIdentifier = new NodeIdentifierWithPredicates(
- QName.create("namespace", "list-entry"), Collections.singletonMap(mapEntryNodeKey, keyLeafNodeValue));
+ mapEntryNodeIdentifier = NodeIdentifierWithPredicates.of(
+ QName.create("namespace", "list-entry"), mapEntryNodeKey, keyLeafNodeValue);
Mockito.when(mapEntryNodeData.getIdentifier()).thenReturn(mapEntryNodeIdentifier);
Mockito.when(mapEntryNodeData.getNodeType()).thenReturn(mapEntryNodeIdentifier.getNodeType());
Mockito.when(mapEntryNodeData.getChild(keyLeafNodeIdentifier)).thenReturn(Optional.of(keyLeafNodeData));
final ContainerNode actualNode = (ContainerNode) capturedNode.getValue();
assertEquals("ContainerNode node type", INTERFACES_QNAME, actualNode.getNodeType());
- final Optional<DataContainerChild<?, ?>> mapChild = actualNode.getChild(
- new NodeIdentifier(INTERFACE_QNAME));
+ final Optional<DataContainerChild<?, ?>> mapChild = actualNode.getChild(new NodeIdentifier(INTERFACE_QNAME));
assertEquals(INTERFACE_QNAME.toString() + " present", true, mapChild.isPresent());
assertTrue("Expected MapNode. Actual " + mapChild.get().getClass(), mapChild.get() instanceof MapNode);
final MapNode mapNode = (MapNode)mapChild.get();
- final NodeIdentifierWithPredicates entryNodeID = new NodeIdentifierWithPredicates(
+ final NodeIdentifierWithPredicates entryNodeID = NodeIdentifierWithPredicates.of(
INTERFACE_QNAME, NAME_QNAME, "eth0");
final Optional<MapEntryNode> entryChild = mapNode.getChild(entryNodeID);
assertEquals(entryNodeID.toString() + " present", true, entryChild.isPresent());
import org.opendaylight.yangtools.yang.common.QName;
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.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
final QName listPlaylistQName = QName.create(this.baseQName, "playlist");
final LeafNode buildLeaf = Builders.leafBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(this.leafQname))
+ .withNodeIdentifier(new NodeIdentifier(this.leafQname))
.withValue(0.2)
.build();
this.buildPlayerCont = Builders.containerBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(this.containerPlayerQname))
+ .withNodeIdentifier(new NodeIdentifier(this.containerPlayerQname))
.withChild(buildLeaf)
.build();
this.buildLibraryCont = Builders.containerBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(containerLibraryQName))
+ .withNodeIdentifier(new NodeIdentifier(containerLibraryQName))
.build();
this.buildPlaylistList = Builders.mapBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(listPlaylistQName))
+ .withNodeIdentifier(new NodeIdentifier(listPlaylistQName))
.build();
this.buildBaseCont = Builders.containerBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(this.baseQName))
+ .withNodeIdentifier(new NodeIdentifier(this.baseQName))
.withChild(this.buildPlayerCont)
.build();
// config contains one child the same as in operational and one additional
this.buildBaseContConfig = Builders.containerBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(this.baseQName))
+ .withNodeIdentifier(new NodeIdentifier(this.baseQName))
.withChild(this.buildPlayerCont)
.withChild(this.buildLibraryCont)
.build();
// operational contains one child the same as in config and one additional
this.buildBaseContOperational = Builders.containerBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(this.baseQName))
+ .withNodeIdentifier(new NodeIdentifier(this.baseQName))
.withChild(this.buildPlayerCont)
.withChild(this.buildPlaylistList)
.build();
public void testPostData() {
final QName listQname = QName.create(this.baseQName, "playlist");
final QName listKeyQname = QName.create(this.baseQName, "name");
- final YangInstanceIdentifier.NodeIdentifierWithPredicates nodeWithKey =
- new YangInstanceIdentifier.NodeIdentifierWithPredicates(listQname, listKeyQname, "name of band");
+ final NodeIdentifierWithPredicates nodeWithKey =
+ NodeIdentifierWithPredicates.of(listQname, listKeyQname, "name of band");
final LeafNode<Object> content = Builders.leafBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(QName.create(this.baseQName, "name")))
+ .withNodeIdentifier(new NodeIdentifier(QName.create(this.baseQName, "name")))
.withValue("name of band")
.build();
final LeafNode<Object> content2 = Builders.leafBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(QName.create(this.baseQName, "description")))
+ .withNodeIdentifier(new NodeIdentifier(QName.create(this.baseQName, "description")))
.withValue("band description")
.build();
final MapEntryNode mapEntryNode = Builders.mapEntryBuilder()
.withChild(content2)
.build();
final MapNode buildList = Builders.mapBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(listQname))
+ .withNodeIdentifier(new NodeIdentifier(listQname))
.withChild(mapEntryNode)
.build();
doReturn(immediateFluentFuture(Optional.empty()))
.when(this.read).read(LogicalDatastoreType.CONFIGURATION, this.iidBase);
final MapNode data = (MapNode) payload.getData();
- final YangInstanceIdentifier.NodeIdentifierWithPredicates identifier =
+ final NodeIdentifierWithPredicates identifier =
data.getValue().iterator().next().getIdentifier();
final YangInstanceIdentifier node =
payload.getInstanceIdentifierContext().getInstanceIdentifier().node(identifier);
import org.opendaylight.restconf.nb.rfc8040.rests.transactions.TransactionVarsWrapper;
import org.opendaylight.yangtools.yang.common.QName;
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.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
final QName containerLibraryQName = QName.create(baseQName, "library");
final QName listArtistQName = QName.create(baseQName, "artist");
final QName leafNameQName = QName.create(baseQName, "name");
- final YangInstanceIdentifier.NodeIdentifierWithPredicates nodeWithKey =
- new YangInstanceIdentifier.NodeIdentifierWithPredicates(listArtistQName, leafNameQName, "name of artist");
+ final NodeIdentifierWithPredicates nodeWithKey = NodeIdentifierWithPredicates.of(listArtistQName, leafNameQName,
+ "name of artist");
/* instance identifier for accessing container node "player" */
this.instanceIdContainer = YangInstanceIdentifier.builder()
/* values that are used for creating leaf for testPatchDataCreateAndDelete test */
final LeafNode<?> buildGapLeaf = Builders.leafBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(leafGapQName))
+ .withNodeIdentifier(new NodeIdentifier(leafGapQName))
.withValue(0.2)
.build();
final ContainerNode buildPlayerContainer = Builders.containerBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(containerPlayerQName))
+ .withNodeIdentifier(new NodeIdentifier(containerPlayerQName))
.withChild(buildGapLeaf)
.build();
this.buildBaseContainerForTests = Builders.containerBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(baseQName))
+ .withNodeIdentifier(new NodeIdentifier(baseQName))
.withChild(buildPlayerContainer)
.build();
/* values that are used for creating leaf for testPatchDataReplaceMergeAndRemove test */
final LeafNode<Object> contentName = Builders.leafBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(QName.create(baseQName, "name")))
+ .withNodeIdentifier(new NodeIdentifier(QName.create(baseQName, "name")))
.withValue("name of artist")
.build();
final LeafNode<Object> contentDescription = Builders.leafBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(QName.create(baseQName, "description")))
+ .withNodeIdentifier(new NodeIdentifier(QName.create(baseQName, "description")))
.withValue("description of artist")
.build();
import org.opendaylight.yangtools.util.SingletonSet;
import org.opendaylight.yangtools.yang.common.QName;
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.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
final QName leafQname = QName.create(baseQName, "gap");
final QName listQname = QName.create(baseQName, "playlist");
final QName listKeyQname = QName.create(baseQName, "name");
- final YangInstanceIdentifier.NodeIdentifierWithPredicates nodeWithKey =
- new YangInstanceIdentifier.NodeIdentifierWithPredicates(listQname, listKeyQname, "name of band");
+ final NodeIdentifierWithPredicates nodeWithKey = NodeIdentifierWithPredicates.of(listQname, listKeyQname,
+ "name of band");
this.iid2 = YangInstanceIdentifier.builder()
.node(baseQName)
.build();
final LeafNode<?> buildLeaf = Builders.leafBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(leafQname))
+ .withNodeIdentifier(new NodeIdentifier(leafQname))
.withValue(0.2)
.build();
final ContainerNode buildPlayerCont = Builders.containerBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(containerQname))
+ .withNodeIdentifier(new NodeIdentifier(containerQname))
.withChild(buildLeaf)
.build();
this.buildBaseCont = Builders.containerBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(baseQName))
+ .withNodeIdentifier(new NodeIdentifier(baseQName))
.withChild(buildPlayerCont)
.build();
final LeafNode<Object> content = Builders.leafBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(QName.create(baseQName, "name")))
+ .withNodeIdentifier(new NodeIdentifier(QName.create(baseQName, "name")))
.withValue("name of band")
.build();
final LeafNode<Object> content2 = Builders.leafBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(QName.create(baseQName, "description")))
+ .withNodeIdentifier(new NodeIdentifier(QName.create(baseQName, "description")))
.withValue("band description")
.build();
final MapEntryNode mapEntryNode = Builders.mapEntryBuilder()
.withChild(content2)
.build();
this.buildList = Builders.mapBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(listQname))
+ .withNodeIdentifier(new NodeIdentifier(listQname))
.withChild(mapEntryNode)
.build();
doReturn(immediateFalseFluentFuture()).when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION,
this.iid2);
- final YangInstanceIdentifier.NodeIdentifier identifier =
+ final NodeIdentifier identifier =
((ContainerNode) ((SingletonSet<?>) payload.getData().getValue()).iterator().next()).getIdentifier();
final YangInstanceIdentifier node =
payload.getInstanceIdentifierContext().getInstanceIdentifier().node(identifier);
final NormalizedNodeContext payload = new NormalizedNodeContext(iidContext, this.buildList);
final MapNode data = (MapNode) payload.getData();
- final YangInstanceIdentifier.NodeIdentifierWithPredicates identifier =
- data.getValue().iterator().next().getIdentifier();
+ final NodeIdentifierWithPredicates identifier = data.getValue().iterator().next().getIdentifier();
final YangInstanceIdentifier node =
payload.getInstanceIdentifierContext().getInstanceIdentifier().node(identifier);
doReturn(immediateFalseFluentFuture()).when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION, node);
doReturn(immediateFalseFluentFuture()).when(this.readWrite).exists(LogicalDatastoreType.CONFIGURATION,
this.iid2);
- final YangInstanceIdentifier.NodeIdentifier identifier =
+ final NodeIdentifier identifier =
((ContainerNode) ((SingletonSet<?>) payload.getData().getValue()).iterator().next()).getIdentifier();
final YangInstanceIdentifier node =
payload.getInstanceIdentifierContext().getInstanceIdentifier().node(identifier);
import org.opendaylight.restconf.nb.rfc8040.rests.transactions.TransactionVarsWrapper;
import org.opendaylight.yangtools.yang.common.QName;
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.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
final QName listQname = QName.create(baseQName, "playlist");
final QName listKeyQname = QName.create(baseQName, "name");
- final YangInstanceIdentifier.NodeIdentifierWithPredicates nodeWithKey =
- new YangInstanceIdentifier.NodeIdentifierWithPredicates(listQname, listKeyQname, "name of band");
- final YangInstanceIdentifier.NodeIdentifierWithPredicates nodeWithKey2 =
- new YangInstanceIdentifier.NodeIdentifierWithPredicates(listQname, listKeyQname, "name of band 2");
+ final NodeIdentifierWithPredicates nodeWithKey =
+ NodeIdentifierWithPredicates.of(listQname, listKeyQname, "name of band");
+ final NodeIdentifierWithPredicates nodeWithKey2 =
+ NodeIdentifierWithPredicates.of(listQname, listKeyQname, "name of band 2");
this.iid = YangInstanceIdentifier.builder()
.node(baseQName)
this.schemaNode3 = DataSchemaContextTree.from(this.schema).getChild(this.iid3).getDataSchemaNode();
this.buildLeaf = Builders.leafBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(leafQname))
+ .withNodeIdentifier(new NodeIdentifier(leafQname))
.withValue(0.2)
.build();
final ContainerNode buildPlayerCont = Builders.containerBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(containerQname))
+ .withNodeIdentifier(new NodeIdentifier(containerQname))
.withChild(this.buildLeaf)
.build();
this.buildBaseCont = Builders.containerBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(baseQName))
+ .withNodeIdentifier(new NodeIdentifier(baseQName))
.withChild(buildPlayerCont)
.build();
final LeafNode<Object> content = Builders.leafBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(QName.create(baseQName, "name")))
+ .withNodeIdentifier(new NodeIdentifier(QName.create(baseQName, "name")))
.withValue("name of band")
.build();
final LeafNode<Object> content2 = Builders.leafBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(QName.create(baseQName, "description")))
+ .withNodeIdentifier(new NodeIdentifier(QName.create(baseQName, "description")))
.withValue("band description")
.build();
this.buildListEntry = Builders.mapEntryBuilder()
.withChild(content2)
.build();
final LeafNode<Object> content3 = Builders.leafBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(QName.create(baseQName, "name")))
+ .withNodeIdentifier(new NodeIdentifier(QName.create(baseQName, "name")))
.withValue("name of band 2")
.build();
final LeafNode<Object> content4 = Builders.leafBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(QName.create(baseQName, "description")))
+ .withNodeIdentifier(new NodeIdentifier(QName.create(baseQName, "description")))
.withValue("band description 2")
.build();
final MapEntryNode buildListEntry2 = Builders.mapEntryBuilder()
.withChild(content4)
.build();
final MapNode buildList = Builders.mapBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(listQname))
+ .withNodeIdentifier(new NodeIdentifier(listQname))
.withChild(this.buildListEntry)
.withChild(buildListEntry2)
.build();
this.buildBaseContWithList = Builders.containerBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(baseQName))
+ .withNodeIdentifier(new NodeIdentifier(baseQName))
.withChild(buildList)
.build();
import org.opendaylight.yangtools.yang.common.QName;
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.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
final QName listQname = QName.create(base, "list");
TestData() {
- final YangInstanceIdentifier.NodeIdentifierWithPredicates nodeWithKey =
- new YangInstanceIdentifier.NodeIdentifierWithPredicates(listQname, listKeyQName, "keyValue");
- final YangInstanceIdentifier.NodeIdentifierWithPredicates nodeWithKey2 =
- new YangInstanceIdentifier.NodeIdentifierWithPredicates(listQname, listKeyQName, "keyValue2");
+ final NodeIdentifierWithPredicates nodeWithKey =
+ NodeIdentifierWithPredicates.of(listQname, listKeyQName, "keyValue");
+ final NodeIdentifierWithPredicates nodeWithKey2 =
+ NodeIdentifierWithPredicates.of(listQname, listKeyQName, "keyValue2");
final LeafNode<Object> content = Builders.leafBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(QName.create(base, "leaf-content")))
+ .withNodeIdentifier(new NodeIdentifier(QName.create(base, "leaf-content")))
.withValue("content")
.build();
final LeafNode<Object> content2 = Builders.leafBuilder()
- .withNodeIdentifier(
- new YangInstanceIdentifier.NodeIdentifier(QName.create(base, "leaf-content-different")))
+ .withNodeIdentifier(new NodeIdentifier(QName.create(base, "leaf-content-different")))
.withValue("content-different")
.build();
- final DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataContainer =
+ final DataContainerChild<?, ?> dataContainer =
Builders.leafBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(QName.create(listQname, "identifier")))
+ .withNodeIdentifier(new NodeIdentifier(QName.create(listQname, "identifier")))
.withValue("id")
.build();
data = Builders.mapEntryBuilder()
.withChild(content)
.build();
listData = Builders.mapBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(QName.create(listQname, "list")))
+ .withNodeIdentifier(new NodeIdentifier(QName.create(listQname, "list")))
.withChild(data)
.build();
listData2 = Builders.mapBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(QName.create(listQname, "list")))
+ .withNodeIdentifier(new NodeIdentifier(QName.create(listQname, "list")))
.withChild(data)
.withChild(data2)
.build();
.node(listQname)
.build();
contentLeaf = Builders.leafBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(QName.create(base, "content")))
+ .withNodeIdentifier(new NodeIdentifier(QName.create(base, "content")))
.withValue("test")
.build();
contentLeaf2 = Builders.leafBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(QName.create(base, "content2")))
+ .withNodeIdentifier(new NodeIdentifier(QName.create(base, "content2")))
.withValue("test2")
.build();
data3 = Builders.containerBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(QName.create(base, "container")))
+ .withNodeIdentifier(new NodeIdentifier(QName.create(base, "container")))
.withChild(contentLeaf)
.build();
data4 = Builders.containerBuilder()
leafSetNodePath = YangInstanceIdentifier.builder().node(QName.create(base, "cont"))
.node(leafListQname).build();
- leafSetNode1 = Builders.<String>leafSetBuilder().withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(
+ leafSetNode1 = Builders.<String>leafSetBuilder().withNodeIdentifier(new NodeIdentifier(
leafListQname)).withChildValue("one").withChildValue("two").build();
- leafSetNode2 = Builders.<String>leafSetBuilder().withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(
+ leafSetNode2 = Builders.<String>leafSetBuilder().withNodeIdentifier(new NodeIdentifier(
leafListQname)).withChildValue("three").build();
orderedLeafSetNode1 = Builders.<String>orderedLeafSetBuilder().withNodeIdentifier(
- new YangInstanceIdentifier.NodeIdentifier(leafListQname)).withChildValue("one")
+ new NodeIdentifier(leafListQname)).withChildValue("one")
.withChildValue("two").build();
orderedLeafSetNode2 = Builders.<String>orderedLeafSetBuilder().withNodeIdentifier(
- new YangInstanceIdentifier.NodeIdentifier(leafListQname)).withChildValue("three")
+ new NodeIdentifier(leafListQname)).withChildValue("three")
.withChildValue("four").build();
orderedMapNode1 = Builders.orderedMapBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(listQname)).withChild(data).build();
+ .withNodeIdentifier(new NodeIdentifier(listQname)).withChild(data).build();
orderedMapNode2 = Builders.orderedMapBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(listQname)).withChild(data)
+ .withNodeIdentifier(new NodeIdentifier(listQname)).withChild(data)
.withChild(data2).build();
unkeyedListEntryNode1 = Builders.unkeyedListEntryBuilder().withNodeIdentifier(
- new YangInstanceIdentifier.NodeIdentifier(listQname)).withChild(content).build();
+ new NodeIdentifier(listQname)).withChild(content).build();
unkeyedListNode1 = Builders.unkeyedListBuilder().withNodeIdentifier(
- new YangInstanceIdentifier.NodeIdentifier(listQname)).withChild(unkeyedListEntryNode1).build();
+ new NodeIdentifier(listQname)).withChild(unkeyedListEntryNode1).build();
unkeyedListEntryNode2 = Builders.unkeyedListEntryBuilder().withNodeIdentifier(
new YangInstanceIdentifier.NodeIdentifier(listQname)).withChild(content2).build();
rpc = SchemaPath.create(true, rpcQname);
errorRpc = SchemaPath.create(true, errorRpcQname);
final LeafNode contentLeafNode = Builders.leafBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(QName.create(rpcQname, "content")))
+ .withNodeIdentifier(new NodeIdentifier(QName.create(rpcQname, "content")))
.withValue("test")
.build();
input = Builders.containerBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(QName.create(rpcQname, "input")))
+ .withNodeIdentifier(new NodeIdentifier(QName.create(rpcQname, "input")))
.withChild(contentLeafNode)
.build();
final LeafNode resultLeafNode = Builders.leafBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(QName.create(rpcQname, "content")))
+ .withNodeIdentifier(new NodeIdentifier(QName.create(rpcQname, "content")))
.withValue("operation result")
.build();
output = Builders.containerBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(QName.create(rpcQname, "output")))
+ .withNodeIdentifier(new NodeIdentifier(QName.create(rpcQname, "output")))
.withChild(resultLeafNode)
.build();
}
import java.net.URI;
import java.util.ArrayList;
import java.util.Collection;
-import java.util.HashMap;
-import java.util.Map;
import java.util.Optional;
import org.junit.Before;
import org.junit.Test;
private static MapEntryNode mockMapEntry(final QName entryQName, final LeafNode<String> leaf) {
final MapEntryNode entry = mock(MapEntryNode.class);
- final Map<QName, Object> keyValues = new HashMap<>();
- keyValues.put(leaf.getNodeType(), "value");
- final NodeIdentifierWithPredicates nodeId = new NodeIdentifierWithPredicates(leaf.getNodeType(), keyValues);
+ final NodeIdentifierWithPredicates nodeId = NodeIdentifierWithPredicates.of(leaf.getNodeType(),
+ leaf.getNodeType(), "value");
when(entry.getIdentifier()).thenReturn(nodeId);
when(entry.getChild(any())).thenReturn(Optional.of(leaf));
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.restconf.nb.rfc8040.utils.parser;
import static org.junit.Assert.assertEquals;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
+import java.util.Map.Entry;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.opendaylight.restconf.nb.rfc8040.TestRestconfUtils;
import org.opendaylight.yangtools.yang.common.QName;
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.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
*/
@Test
public void deserializeContainerTest() {
- final Iterable<YangInstanceIdentifier.PathArgument> result = YangInstanceIdentifierDeserializer
+ final Iterable<PathArgument> result = YangInstanceIdentifierDeserializer
.create(this.schemaContext, "deserializer-test:contA");
assertEquals("Result does not contains expected number of path arguments", 1, Iterables.size(result));
assertEquals("Not expected path argument",
- YangInstanceIdentifier.NodeIdentifier.create(QName.create("deserializer:test", "2016-06-06", "contA")),
+ NodeIdentifier.create(QName.create("deserializer:test", "2016-06-06", "contA")),
result.iterator().next());
}
*/
@Test
public void deserializeContainerWithLeafTest() {
- final Iterable<YangInstanceIdentifier.PathArgument> result = YangInstanceIdentifierDeserializer
+ final Iterable<PathArgument> result = YangInstanceIdentifierDeserializer
.create(this.schemaContext, "deserializer-test:contA/leaf-A");
assertEquals("Result does not contains expected number of path arguments", 2, Iterables.size(result));
- final Iterator<YangInstanceIdentifier.PathArgument> iterator = result.iterator();
+ final Iterator<PathArgument> iterator = result.iterator();
assertEquals("Not expected path argument",
- YangInstanceIdentifier.NodeIdentifier.create(QName.create("deserializer:test", "2016-06-06", "contA")),
+ NodeIdentifier.create(QName.create("deserializer:test", "2016-06-06", "contA")),
iterator.next());
assertEquals("Not expected path argument",
- YangInstanceIdentifier.NodeIdentifier.create(QName.create("deserializer:test", "2016-06-06", "leaf-A")),
+ NodeIdentifier.create(QName.create("deserializer:test", "2016-06-06", "leaf-A")),
iterator.next());
}
*/
@Test
public void deserializeContainerWithListWithLeafListTest() {
- final Iterable<YangInstanceIdentifier.PathArgument> result = YangInstanceIdentifierDeserializer
+ final Iterable<PathArgument> result = YangInstanceIdentifierDeserializer
.create(this.schemaContext, "deserializer-test:contA/list-A=100/leaf-list-AA=instance");
assertEquals("Result does not contains expected number of path arguments", 5, Iterables.size(result));
- final Iterator<YangInstanceIdentifier.PathArgument> iterator = result.iterator();
+ final Iterator<PathArgument> iterator = result.iterator();
// container
assertEquals("Not expected path argument",
- YangInstanceIdentifier.NodeIdentifier.create(QName.create("deserializer:test", "2016-06-06", "contA")),
+ NodeIdentifier.create(QName.create("deserializer:test", "2016-06-06", "contA")),
iterator.next());
// list
final QName list = QName.create("deserializer:test", "2016-06-06", "list-A");
- assertEquals("Not expected path argument",
- YangInstanceIdentifier.NodeIdentifier.create(list),
- iterator.next());
- assertEquals("Not expected path argument",
- new YangInstanceIdentifier.NodeIdentifierWithPredicates(
- list, QName.create(list, "list-key"), 100).toString(),
- iterator.next().toString());
+ assertEquals("Not expected path argument", NodeIdentifier.create(list), iterator.next());
+ assertEquals("Not expected path argument", NodeIdentifierWithPredicates.of(
+ list, QName.create(list, "list-key"), 100).toString(), iterator.next().toString());
// leaf list
final QName leafList = QName.create("deserializer:test", "2016-06-06", "leaf-list-AA");
- assertEquals("Not expected path argument",
- YangInstanceIdentifier.NodeIdentifier.create(leafList),
- iterator.next());
- assertEquals("Not expected path argument",
- new YangInstanceIdentifier.NodeWithValue<>(leafList, "instance"),
- iterator.next());
+ assertEquals("Not expected path argument", NodeIdentifier.create(leafList), iterator.next());
+ assertEquals("Not expected path argument", new NodeWithValue<>(leafList, "instance"), iterator.next());
}
/**
*/
@Test
public void deserializeContainerWithListWithActionTest() {
- final Iterable<YangInstanceIdentifier.PathArgument> result = YangInstanceIdentifierDeserializer
- .create(this.schemaContext, "example-actions:interfaces/interface=eth0/reset");
+ final Iterable<PathArgument> result = YangInstanceIdentifierDeserializer.create(this.schemaContext,
+ "example-actions:interfaces/interface=eth0/reset");
assertEquals("Result does not contains expected number of path arguments", 4, Iterables.size(result));
- final Iterator<YangInstanceIdentifier.PathArgument> iterator = result.iterator();
+ final Iterator<PathArgument> iterator = result.iterator();
// container
- assertEquals("Not expected path argument", YangInstanceIdentifier.NodeIdentifier
- .create(QName.create("https://example.com/ns/example-actions", "2016-07-07", "interfaces")),
+ assertEquals("Not expected path argument",
+ NodeIdentifier.create(QName.create("https://example.com/ns/example-actions", "2016-07-07", "interfaces")),
iterator.next());
// list
final QName list = QName.create("https://example.com/ns/example-actions", "2016-07-07", "interface");
- assertEquals("Not expected path argument", YangInstanceIdentifier.NodeIdentifier.create(list), iterator.next());
+ assertEquals("Not expected path argument", NodeIdentifier.create(list), iterator.next());
assertEquals("Not expected path argument",
- new YangInstanceIdentifier.NodeIdentifierWithPredicates(list, QName.create(list, "name"), "eth0"),
- iterator.next());
+ NodeIdentifierWithPredicates.of(list, QName.create(list, "name"), "eth0"), iterator.next());
// action QName
final QName action = QName.create("https://example.com/ns/example-actions", "2016-07-07", "reset");
- assertEquals("Not expected path argument", YangInstanceIdentifier.NodeIdentifier.create(action),
+ assertEquals("Not expected path argument", NodeIdentifier.create(action),
iterator.next());
}
*/
@Test
public void deserializeListWithNoKeysTest() {
- final Iterable<YangInstanceIdentifier.PathArgument> result = YangInstanceIdentifierDeserializer
- .create(this.schemaContext, "deserializer-test:list-no-key");
+ final Iterable<PathArgument> result = YangInstanceIdentifierDeserializer.create(this.schemaContext,
+ "deserializer-test:list-no-key");
assertEquals("Result does not contains expected number of path arguments", 2, Iterables.size(result));
- final Iterator<YangInstanceIdentifier.PathArgument> iterator = result.iterator();
+ final Iterator<PathArgument> iterator = result.iterator();
final QName list = QName.create("deserializer:test", "2016-06-06", "list-no-key");
- assertEquals("Not expected path argument",
- YangInstanceIdentifier.NodeIdentifier.create(list),
- iterator.next());
- assertEquals("Not expected path argument",
- YangInstanceIdentifier.NodeIdentifier.create(list),
- iterator.next());
+ assertEquals("Not expected path argument", NodeIdentifier.create(list), iterator.next());
+ assertEquals("Not expected path argument", NodeIdentifier.create(list), iterator.next());
}
/**
*/
@Test
public void deserializeListWithOneKeyTest() {
- final Iterable<YangInstanceIdentifier.PathArgument> result = YangInstanceIdentifierDeserializer
- .create(this.schemaContext, "deserializer-test:list-one-key=value");
+ final Iterable<PathArgument> result = YangInstanceIdentifierDeserializer.create(this.schemaContext,
+ "deserializer-test:list-one-key=value");
assertEquals("Result does not contains expected number of path arguments", 2, Iterables.size(result));
- final Iterator<YangInstanceIdentifier.PathArgument> iterator = result.iterator();
+ final Iterator<PathArgument> iterator = result.iterator();
final QName list = QName.create("deserializer:test", "2016-06-06", "list-one-key");
+ assertEquals("Not expected path argument", NodeIdentifier.create(list), iterator.next());
assertEquals("Not expected path argument",
- YangInstanceIdentifier.NodeIdentifier.create(list),
- iterator.next());
- assertEquals("Not expected path argument",
- new YangInstanceIdentifier.NodeIdentifierWithPredicates(list, QName.create(list, "name"), "value"),
- iterator.next());
+ NodeIdentifierWithPredicates.of(list, QName.create(list, "name"), "value"), iterator.next());
}
/**
values.put(QName.create(list, "number"), 100);
values.put(QName.create(list, "enabled"), false);
- final Iterable<YangInstanceIdentifier.PathArgument> result = YangInstanceIdentifierDeserializer
- .create(this.schemaContext, "deserializer-test:list-multiple-keys=value,100,false");
+ final Iterable<PathArgument> result = YangInstanceIdentifierDeserializer.create(this.schemaContext,
+ "deserializer-test:list-multiple-keys=value,100,false");
assertEquals("Result does not contains expected number of path arguments", 2, Iterables.size(result));
- final Iterator<YangInstanceIdentifier.PathArgument> iterator = result.iterator();
+ final Iterator<PathArgument> iterator = result.iterator();
- assertEquals("Not expected path argument",
- YangInstanceIdentifier.NodeIdentifier.create(list),
- iterator.next());
- assertEquals("Not expected path argument",
- new YangInstanceIdentifier.NodeIdentifierWithPredicates(list, values).toString(),
+ assertEquals("Not expected path argument", NodeIdentifier.create(list), iterator.next());
+ assertEquals("Not expected path argument", NodeIdentifierWithPredicates.of(list, values).toString(),
iterator.next().toString());
}
*/
@Test
public void deserializeLeafListTest() {
- final Iterable<YangInstanceIdentifier.PathArgument> result = YangInstanceIdentifierDeserializer
- .create(this.schemaContext, "deserializer-test:leaf-list-0=true");
+ final Iterable<PathArgument> result = YangInstanceIdentifierDeserializer.create(this.schemaContext,
+ "deserializer-test:leaf-list-0=true");
assertEquals("Result does not contains expected number of path arguments", 2, Iterables.size(result));
- final Iterator<YangInstanceIdentifier.PathArgument> iterator = result.iterator();
+ final Iterator<PathArgument> iterator = result.iterator();
final QName leafList = QName.create("deserializer:test", "2016-06-06", "leaf-list-0");
+ assertEquals("Not expected path argument", new NodeIdentifier(leafList), iterator.next());
assertEquals("Not expected path argument",
- new YangInstanceIdentifier.NodeIdentifier(leafList),
- iterator.next());
- assertEquals("Not expected path argument",
- new YangInstanceIdentifier.NodeWithValue<>(leafList, true).toString(),
- iterator.next().toString());
+ new NodeWithValue<>(leafList, true).toString(), iterator.next().toString());
}
/**
assertEquals("Result does not contains expected number of path arguments", 4, Iterables.size(result));
- final Iterator<YangInstanceIdentifier.PathArgument> iterator = result.iterator();
+ final Iterator<PathArgument> iterator = result.iterator();
// container
assertEquals("Not expected path argument",
- YangInstanceIdentifier.NodeIdentifier.create(QName.create("deserializer:test", "2016-06-06", "contA")),
+ NodeIdentifier.create(QName.create("deserializer:test", "2016-06-06", "contA")),
iterator.next());
// list
final QName list = QName.create("deserializer:test", "2016-06-06", "list-A");
+ assertEquals("Not expected path argument", NodeIdentifier.create(list), iterator.next());
assertEquals("Not expected path argument",
- YangInstanceIdentifier.NodeIdentifier.create(list),
- iterator.next());
- assertEquals("Not expected path argument",
- new YangInstanceIdentifier.NodeIdentifierWithPredicates(
- list, QName.create(list, "list-key"), 40).toString(),
+ NodeIdentifierWithPredicates.of(list, QName.create(list, "list-key"), 40).toString(),
iterator.next().toString());
// leaf
assertEquals("Not expected path argument",
- new YangInstanceIdentifier.NodeIdentifier(
- QName.create("deserializer:test", "2016-06-06", "list-key")),
- iterator.next());
+ new NodeIdentifier(QName.create("deserializer:test", "2016-06-06", "list-key")), iterator.next());
}
/**
values.put(QName.create(list, "number"), "");
values.put(QName.create(list, "enabled"), "");
- final Iterable<YangInstanceIdentifier.PathArgument> result = YangInstanceIdentifierDeserializer.create(
+ final Iterable<PathArgument> result = YangInstanceIdentifierDeserializer.create(
this.schemaContext, "deserializer-test:list-multiple-keys=%3Afoo,,/string-value");
assertEquals("Result does not contains expected number of path arguments", 3, Iterables.size(result));
- final Iterator<YangInstanceIdentifier.PathArgument> iterator = result.iterator();
+ final Iterator<PathArgument> iterator = result.iterator();
// list
- assertEquals("Not expected path argument",
- YangInstanceIdentifier.NodeIdentifier.create(list),
- iterator.next());
- assertEquals("Not expected path argument",
- new YangInstanceIdentifier.NodeIdentifierWithPredicates(list, values).toString(),
+ assertEquals("Not expected path argument", NodeIdentifier.create(list), iterator.next());
+ assertEquals("Not expected path argument", NodeIdentifierWithPredicates.of(list, values).toString(),
iterator.next().toString());
// leaf
assertEquals("Not expected path argument",
- new YangInstanceIdentifier.NodeIdentifier(
- QName.create("deserializer:test", "2016-06-06", "string-value")),
- iterator.next());
+ new NodeIdentifier(QName.create("deserializer:test", "2016-06-06", "string-value")), iterator.next());
}
/**
final YangInstanceIdentifier result = YangInstanceIdentifier.create(
YangInstanceIdentifierDeserializer.create(this.schemaContext, URI));
- final Iterator<Map.Entry<QName, Object>> resultListKeys = ((YangInstanceIdentifier.NodeIdentifierWithPredicates)
- result.getLastPathArgument()).getKeyValues().entrySet().iterator();
+ final Iterator<Entry<QName, Object>> resultListKeys =
+ ((NodeIdentifierWithPredicates)result.getLastPathArgument()).entrySet().iterator();
assertEquals(":foo", resultListKeys.next().getValue());
assertEquals(new Short("1"), resultListKeys.next().getValue());
values.put(QName.create(list, "number"), "");
values.put(QName.create(list, "enabled"), "");
- final Iterable<YangInstanceIdentifier.PathArgument> result = YangInstanceIdentifierDeserializer
+ final Iterable<PathArgument> result = YangInstanceIdentifierDeserializer
.create(this.schemaContext, "deserializer-test:list-multiple-keys=,,");
assertEquals("Result does not contains expected number of path arguments", 2, Iterables.size(result));
- final Iterator<YangInstanceIdentifier.PathArgument> iterator = result.iterator();
+ final Iterator<PathArgument> iterator = result.iterator();
- assertEquals("Not expected path argument",
- YangInstanceIdentifier.NodeIdentifier.create(list),
- iterator.next());
- assertEquals("Not expected path argument",
- new YangInstanceIdentifier.NodeIdentifierWithPredicates(list, values).toString(),
+ assertEquals("Not expected path argument", NodeIdentifier.create(list), iterator.next());
+ assertEquals("Not expected path argument", NodeIdentifierWithPredicates.of(list, values).toString(),
iterator.next().toString());
}
*/
@Test
public void deserializePartInOtherModuleTest() {
- final Iterable<YangInstanceIdentifier.PathArgument> result = YangInstanceIdentifierDeserializer.create(
- this.schemaContext, "deserializer-test-included:augmented-list=100/augmented-leaf");
+ final Iterable<PathArgument> result = YangInstanceIdentifierDeserializer.create(this.schemaContext,
+ "deserializer-test-included:augmented-list=100/augmented-leaf");
assertEquals("Result does not contains expected number of path arguments", 4, Iterables.size(result));
- final Iterator<YangInstanceIdentifier.PathArgument> iterator = result.iterator();
+ final Iterator<PathArgument> iterator = result.iterator();
final QName list = QName.create("deserializer:test:included", "2016-06-06", "augmented-list");
final QName child = QName.create("deserializer:test", "2016-06-06", "augmented-leaf");
// list
assertEquals("Not expected path argument",
- YangInstanceIdentifier.NodeIdentifier.create(list),
+ NodeIdentifier.create(list),
iterator.next());
assertEquals("Not expected path argument",
- new YangInstanceIdentifier.NodeIdentifierWithPredicates(list, QName.create(list, "list-key"), 100)
- .toString(),
- iterator.next()
- .toString());
+ NodeIdentifierWithPredicates.of(list, QName.create(list, "list-key"), 100).toString(),
+ iterator.next().toString());
// augmented leaf
- assertEquals("Not expected path argument",
- new YangInstanceIdentifier.AugmentationIdentifier(Sets.newHashSet(child)),
- iterator.next());
-
- assertEquals("Not expected path argument",
- YangInstanceIdentifier.NodeIdentifier.create(child),
- iterator.next());
+ assertEquals("Not expected path argument", new AugmentationIdentifier(Sets.newHashSet(child)), iterator.next());
+ assertEquals("Not expected path argument", NodeIdentifier.create(child), iterator.next());
}
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.restconf.nb.rfc8040.utils.parser;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
-import com.google.common.collect.Sets;
+import com.google.common.collect.ImmutableSet;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import org.opendaylight.restconf.nb.rfc8040.utils.parser.builder.ParserBuilderConstants;
import org.opendaylight.yangtools.yang.common.QName;
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.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
final YangInstanceIdentifier data = YangInstanceIdentifier.builder()
.node(QName.create("serializer:test", "2016-06-06", "contA"))
.node(list)
- .node(new YangInstanceIdentifier.NodeIdentifierWithPredicates(
- list, QName.create(list, "list-key"), 100))
+ .node(NodeIdentifierWithPredicates.of(list, QName.create(list, "list-key"), 100))
.node(leafList)
.node(new NodeWithValue<>(leafList, "instance"))
.build();
final YangInstanceIdentifier data = YangInstanceIdentifier.builder()
.node(list)
- .node(new YangInstanceIdentifier.NodeIdentifierWithPredicates(
- list, QName.create(list, "list-key"), 100))
- .node(new YangInstanceIdentifier.AugmentationIdentifier(Sets.newHashSet(child)))
+ .node(NodeIdentifierWithPredicates.of(list, QName.create(list, "list-key"), 100))
+ .node(new AugmentationIdentifier(ImmutableSet.of(child)))
.node(child)
.build();
final YangInstanceIdentifier data = YangInstanceIdentifier.builder()
.node(list)
- .node(new YangInstanceIdentifier.NodeIdentifierWithPredicates(
- list, QName.create(list, "list-key"), 100))
- .node(new YangInstanceIdentifier.AugmentationIdentifier(Sets.newHashSet(child)))
+ .node(NodeIdentifierWithPredicates.of(list, QName.create(list, "list-key"), 100))
+ .node(new AugmentationIdentifier(ImmutableSet.of(child)))
.node(child)
.build();
final Map<QName, Object> keyValues = new HashMap<>();
keyValues.put(KEY_QNAME, "id-string");
final YangInstanceIdentifier expectedYII = YangInstanceIdentifier.of(CONT_QNAME).node(LIST_QNAME)
- .node(new YangInstanceIdentifier.NodeIdentifierWithPredicates(LIST_QNAME, keyValues));
+ .node(YangInstanceIdentifier.NodeIdentifierWithPredicates.of(LIST_QNAME, keyValues));
assertEquals(expectedYII, ctx.getInstanceIdentifier());
}
Code Review / netconf.git / commitdiff