List<MapEntryNode> outerList = new ArrayList<>(outerElements);
for (int j = 0; j < outerElements; j++) {
outerList.add(ImmutableNodes.mapEntryBuilder()
- .withNodeIdentifier(new NodeIdentifierWithPredicates(OuterList.QNAME, OL_ID, j))
+ .withNodeIdentifier(NodeIdentifierWithPredicates.of(OuterList.QNAME, OL_ID, j))
.withChild(ImmutableNodes.leafNode(OL_ID, j))
.withChild(buildInnerList(j, innerElements))
.build());
final String itemStr = "Item-" + String.valueOf(index) + "-";
for (int i = 0; i < elements; i++) {
innerList.addChild(ImmutableNodes.mapEntryBuilder()
- .withNodeIdentifier(new NodeIdentifierWithPredicates(InnerList.QNAME, IL_NAME, i))
+ .withNodeIdentifier(NodeIdentifierWithPredicates.of(InnerList.QNAME, IL_NAME, i))
.withChild(ImmutableNodes.leafNode(IL_NAME, i))
.withChild(ImmutableNodes.leafNode(IL_VALUE, itemStr + String.valueOf(i)))
.build());
long writeCnt = 0;
for (int l = 0; l < outerListElem; l++) {
- YangInstanceIdentifier yid = pid.node(new NodeIdentifierWithPredicates(OuterList.QNAME, olId, l));
+ YangInstanceIdentifier yid = pid.node(NodeIdentifierWithPredicates.of(OuterList.QNAME, olId, l));
tx.delete(dsType, yid);
writeCnt++;
try (DOMDataTreeReadTransaction tx = domDataBroker.newReadOnlyTransaction()) {
for (int l = 0; l < outerListElem; l++) {
- YangInstanceIdentifier yid = pid.node(new NodeIdentifierWithPredicates(OuterList.QNAME, olId, l));
+ YangInstanceIdentifier yid = pid.node(NodeIdentifierWithPredicates.of(OuterList.QNAME, olId, l));
FluentFuture<Optional<NormalizedNode<?, ?>>> submitFuture = tx.read(dsType, yid);
try {
Optional<NormalizedNode<?,?>> optionalDataObject = submitFuture.get();
for (MapEntryNode element : this.list) {
YangInstanceIdentifier yid =
- pid.node(new NodeIdentifierWithPredicates(OuterList.QNAME, element.getIdentifier().getKeyValues()));
+ pid.node(NodeIdentifierWithPredicates.of(OuterList.QNAME, element.getIdentifier().getKeyValues()));
if (oper == StartTestInput.Operation.PUT) {
tx.put(dsType, yid, element);
int writeCnt = 0;
for (int l = 0; l < outerListElem; l++) {
- YangInstanceIdentifier yid = pid.node(new NodeIdentifierWithPredicates(OuterList.QNAME, olId, l));
+ YangInstanceIdentifier yid = pid.node(NodeIdentifierWithPredicates.of(OuterList.QNAME, olId, l));
tx.delete(dsType, yid);
writeCnt++;
try (DOMDataTreeReadTransaction tx = domDataBroker.newReadOnlyTransaction()) {
for (int l = 0; l < outerListElem; l++) {
- YangInstanceIdentifier yid = pid.node(new NodeIdentifierWithPredicates(OuterList.QNAME, olId, l));
+ YangInstanceIdentifier yid = pid.node(NodeIdentifierWithPredicates.of(OuterList.QNAME, olId, l));
Optional<NormalizedNode<?,?>> optionalDataObject;
FluentFuture<Optional<NormalizedNode<?, ?>>> submitFuture = tx.read(dsType, yid);
try {
for (MapEntryNode element : this.list) {
YangInstanceIdentifier yid =
- pid.node(new NodeIdentifierWithPredicates(OuterList.QNAME, element.getIdentifier().getKeyValues()));
+ pid.node(NodeIdentifierWithPredicates.of(OuterList.QNAME, element.getIdentifier().getKeyValues()));
if (oper == StartTestInput.Operation.PUT) {
tx.put(dsType, yid, element);
final int count = input.readInt();
switch (count) {
case 0:
- return new NodeIdentifierWithPredicates(qname);
+ return NodeIdentifierWithPredicates.of(qname);
case 1:
- return new NodeIdentifierWithPredicates(qname, readQName(), readObject());
+ return NodeIdentifierWithPredicates.of(qname, readQName(), readObject());
default:
// ImmutableList is used by ImmutableOffsetMapTemplate for lookups, hence we use that.
final Builder<QName> keys = ImmutableList.builderWithExpectedSize(count);
values[i] = readObject();
}
- return new NodeIdentifierWithPredicates(qname, ImmutableOffsetMapTemplate.ordered(keys.build())
+ return NodeIdentifierWithPredicates.of(qname, ImmutableOffsetMapTemplate.ordered(keys.build())
.instantiateWithValues(values));
}
}
private static YangInstanceIdentifier.NodeIdentifierWithPredicates listId(final String listName,
final String keyName,
final Object keyValue) {
- return new YangInstanceIdentifier.NodeIdentifierWithPredicates(QName.create(CONTAINER_Q_NAME, listName),
+ return YangInstanceIdentifier.NodeIdentifierWithPredicates.of(QName.create(CONTAINER_Q_NAME, listName),
QName.create(CONTAINER_Q_NAME, keyName), keyValue);
}
// Create YangInstanceIdentifier with all path arg types.
YangInstanceIdentifier instanceID = YangInstanceIdentifier.create(
new NodeIdentifier(QName.create(TEST_QNAME, "qname")),
- new NodeIdentifierWithPredicates(QName.create(TEST_QNAME, "list-entry"),
+ NodeIdentifierWithPredicates.of(QName.create(TEST_QNAME, "list-entry"),
QName.create(TEST_QNAME, "key"), 10),
new AugmentationIdentifier(ImmutableSet.of(
QName.create(TEST_QNAME, "aug1"), QName.create(TEST_QNAME, "aug2"))),
return ImmutableMapEntryNodeBuilder
.create()
.withNodeIdentifier(
- new YangInstanceIdentifier.NodeIdentifierWithPredicates(
+ YangInstanceIdentifier.NodeIdentifierWithPredicates.of(
AUGMENTED_LIST_QNAME, ID_QNAME, id))
.withChild(ImmutableNodes.leafNode(ID_QNAME, id))
.withChild(augmentationNode).build();
UnorderedMapMixinNormalization(final ListSchemaNode list) {
super(new NodeIdentifier(list.getQName()),list);
- this.innerNode = new ListItemNormalization(new NodeIdentifierWithPredicates(list.getQName(),
+ this.innerNode = new ListItemNormalization(NodeIdentifierWithPredicates.of(list.getQName(),
Collections.<QName, Object>emptyMap()), list);
}
}
static NodeIdentifierWithPredicates candidateNodeKey(final String candidateName) {
- return new NodeIdentifierWithPredicates(Candidate.QNAME, NODE_KEY_TEMPLATE.instantiateWithValue(candidateName));
+ return NodeIdentifierWithPredicates.of(Candidate.QNAME, NODE_KEY_TEMPLATE.instantiateWithValue(candidateName));
}
static NormalizedNode<?, ?> entityOwnersWithCandidate(final String entityType,
boolean checkDefaultIsPresent() {
final NodeIdentifierWithPredicates pag =
- new NodeIdentifierWithPredicates(ClusterUtils.SHARD_LIST_QNAME, ClusterUtils.SHARD_PREFIX_QNAME,
+ NodeIdentifierWithPredicates.of(ClusterUtils.SHARD_LIST_QNAME, ClusterUtils.SHARD_PREFIX_QNAME,
YangInstanceIdentifier.EMPTY);
final YangInstanceIdentifier defaultId = ClusterUtils.SHARD_LIST_PATH.node(pag);
final MapEntryNode newEntry = ImmutableMapEntryNodeBuilder.create()
.withNodeIdentifier(
- new NodeIdentifierWithPredicates(ClusterUtils.SHARD_LIST_QNAME, ClusterUtils.SHARD_PREFIX_QNAME,
+ NodeIdentifierWithPredicates.of(ClusterUtils.SHARD_LIST_QNAME, ClusterUtils.SHARD_PREFIX_QNAME,
path))
.withChild(ImmutableLeafNodeBuilder.create()
.withNodeIdentifier(new NodeIdentifier(ClusterUtils.SHARD_PREFIX_QNAME))
ClusterUtils.SHARD_LIST_PATH.getPathArguments().forEach(cursor::enter);
cursor.delete(
- new NodeIdentifierWithPredicates(ClusterUtils.SHARD_LIST_QNAME, ClusterUtils.SHARD_PREFIX_QNAME, path));
+ NodeIdentifierWithPredicates.of(ClusterUtils.SHARD_LIST_QNAME, ClusterUtils.SHARD_PREFIX_QNAME, path));
cursor.close();
return tx.ready();
assertTrue("Missing " + childMap.toString(), childNode.isPresent());
MapNode entityTypeMapNode = (MapNode) childNode.get();
- Optional<MapEntryNode> entityTypeEntry = entityTypeMapNode.getChild(new NodeIdentifierWithPredicates(
+ Optional<MapEntryNode> entityTypeEntry = entityTypeMapNode.getChild(NodeIdentifierWithPredicates.of(
childMap, child, key));
if (expectPresent && !entityTypeEntry.isPresent()) {
fail("Missing " + childMap.toString() + " entry for " + key + ". Actual: " + entityTypeMapNode.getValue());
private DOMDataTreeWriteCursor cursor;
private static final YangInstanceIdentifier OUTER_LIST_YID = TestModel.OUTER_LIST_PATH.node(
- new NodeIdentifierWithPredicates(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1));
+ NodeIdentifierWithPredicates.of(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1));
private static final DOMDataTreeIdentifier OUTER_LIST_ID =
new DOMDataTreeIdentifier(LogicalDatastoreType.CONFIGURATION, OUTER_LIST_YID);
final Collection<MapEntryNode> ret = new ArrayList<>();
for (int i = 0; i < amount; i++) {
ret.add(ImmutableNodes.mapEntryBuilder()
- .withNodeIdentifier(new NodeIdentifierWithPredicates(TestModel.OUTER_LIST_QNAME,
+ .withNodeIdentifier(NodeIdentifierWithPredicates.of(TestModel.OUTER_LIST_QNAME,
QName.create(TestModel.OUTER_LIST_QNAME, "id"), i))
.withChild(ImmutableNodes
.leafNode(QName.create(TestModel.OUTER_LIST_QNAME, "id"), i))
final Collection<MapEntryNode> ret = new ArrayList<>();
for (int i = 0; i < amount; i++) {
ret.add(ImmutableNodes.mapEntryBuilder()
- .withNodeIdentifier(new NodeIdentifierWithPredicates(TestModel.INNER_LIST_QNAME,
+ .withNodeIdentifier(NodeIdentifierWithPredicates.of(TestModel.INNER_LIST_QNAME,
QName.create(TestModel.INNER_LIST_QNAME, "name"), Integer.toString(i)))
.withChild(ImmutableNodes
.leafNode(QName.create(TestModel.INNER_LIST_QNAME, "value"), valuePrefix + "-" + i))
}
private static YangInstanceIdentifier getOuterListIdFor(final int id) {
- return TestModel.OUTER_LIST_PATH.node(new NodeIdentifierWithPredicates(
+ return TestModel.OUTER_LIST_PATH.node(NodeIdentifierWithPredicates.of(
TestModel.OUTER_LIST_QNAME, QName.create(TestModel.OUTER_LIST_QNAME, "id"), id));
}
}
}
public static NodeIdentifierWithPredicates outerEntryKey(final int id) {
- return new NodeIdentifierWithPredicates(OUTER_LIST_QNAME, ID_QNAME, id);
+ return NodeIdentifierWithPredicates.of(OUTER_LIST_QNAME, ID_QNAME, id);
}
public static YangInstanceIdentifier outerEntryPath(final int id) {
}
public static NodeIdentifierWithPredicates innerEntryKey(final String name) {
- return new NodeIdentifierWithPredicates(INNER_LIST_QNAME, NAME_QNAME, name);
+ return NodeIdentifierWithPredicates.of(INNER_LIST_QNAME, NAME_QNAME, name);
}
public static YangInstanceIdentifier innerEntryPath(final int id, final String name) {
.registerDataTreeChangeListener(OUTER_LIST_DATA_TREE_ID, listener);
final YangInstanceIdentifier.NodeIdentifierWithPredicates outerListEntryId1
- = new YangInstanceIdentifier.NodeIdentifierWithPredicates(TestModel.OUTER_LIST_QNAME,
+ = YangInstanceIdentifier.NodeIdentifierWithPredicates.of(TestModel.OUTER_LIST_QNAME,
TestModel.ID_QNAME, 1);
final YangInstanceIdentifier.NodeIdentifierWithPredicates outerListEntryId2
- = new YangInstanceIdentifier.NodeIdentifierWithPredicates(TestModel.OUTER_LIST_QNAME,
+ = YangInstanceIdentifier.NodeIdentifierWithPredicates.of(TestModel.OUTER_LIST_QNAME,
TestModel.ID_QNAME, 2);
final YangInstanceIdentifier.NodeIdentifierWithPredicates outerListEntryId3
- = new YangInstanceIdentifier.NodeIdentifierWithPredicates(TestModel.OUTER_LIST_QNAME,
+ = YangInstanceIdentifier.NodeIdentifierWithPredicates.of(TestModel.OUTER_LIST_QNAME,
TestModel.ID_QNAME, 3);
final MapEntryNode outerListEntry1 = ImmutableNodes.mapEntry(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1);
public static final YangInstanceIdentifier path(final String topName,
final String nestedName) {
return path(topName).node(NestedList.QNAME).node(
- new NodeIdentifierWithPredicates(NestedList.QNAME, NAME_QNAME,
+ NodeIdentifierWithPredicates.of(NestedList.QNAME, NAME_QNAME,
nestedName));
}
public static final YangInstanceIdentifier path(final String topName) {
return TOP_LEVEL.node(TopLevelList.QNAME).node(
- new NodeIdentifierWithPredicates(TopLevelList.QNAME,
+ NodeIdentifierWithPredicates.of(TopLevelList.QNAME,
NAME_QNAME, topName));
}
final String id = input.getId();
LOG.debug("Filling the item list {} with initial values.", id);
- final YangInstanceIdentifier idListWithKey = ID_INT_YID.node(new NodeIdentifierWithPredicates(ID_INT, ID, id));
+ final YangInstanceIdentifier idListWithKey = ID_INT_YID.node(NodeIdentifierWithPredicates.of(ID_INT, ID, id));
final DOMDataTreeProducer itemProducer = domDataTreeService.createProducer(
Collections.singleton(new DOMDataTreeIdentifier(LogicalDatastoreType.CONFIGURATION, idListWithKey)));
final DOMDataTreeCursorAwareTransaction tx = itemProducer.createTransaction(false);
final DOMDataTreeWriteCursor cursor = tx.createCursor(idListItem);
- final NodeIdentifierWithPredicates entryId = new NodeIdentifierWithPredicates(ITEM, NUMBER, i);
+ final NodeIdentifierWithPredicates entryId = NodeIdentifierWithPredicates.of(ITEM, NUMBER, i);
if (usedValues.contains(i)) {
LOG.debug("Deleting item: {}", i);
deleteTx++;
final int i = nextInt(MAX_ITEM + 1);
final YangInstanceIdentifier entryId =
- idListItem.node(ITEM).node(new YangInstanceIdentifier.NodeIdentifierWithPredicates(ITEM, NUMBER, i));
+ idListItem.node(ITEM).node(YangInstanceIdentifier.NodeIdentifierWithPredicates.of(ITEM, NUMBER, i));
final DOMDataWriteTransaction tx = createTransaction();