* Common constants defined and relating to RFC8040.
*/
public final class Rfc8040 {
- private static final YangInstanceIdentifier RESTCONF_STATE_STREAMS = YangInstanceIdentifier.create(
+ private static final YangInstanceIdentifier RESTCONF_STATE_STREAMS = YangInstanceIdentifier.of(
NodeIdentifier.create(RestconfState.QNAME), NodeIdentifier.create(Streams.QNAME),
NodeIdentifier.create(Stream.QNAME));
private static final QName NAME_QNAME = QName.create(Stream.QNAME, "name").intern();
private void putData(final ContainerNode normNode) {
final DOMDataTreeWriteTransaction wTx = domDataBroker.newWriteOnlyTransaction();
wTx.put(LogicalDatastoreType.OPERATIONAL,
- YangInstanceIdentifier.create(NodeIdentifier.create(normNode.getIdentifier().getNodeType())), normNode);
+ YangInstanceIdentifier.of(NodeIdentifier.create(normNode.name().getNodeType())), normNode);
try {
wTx.commit().get();
} catch (InterruptedException e) {
while (result instanceof ChoiceNode choice) {
final var childNode = choice.body().iterator().next();
if (isPost) {
- iiToDataList.add(result.getIdentifier());
+ iiToDataList.add(result.name());
}
result = childNode;
}
if (isPost) {
if (result instanceof MapEntryNode) {
- iiToDataList.add(new NodeIdentifier(result.getIdentifier().getNodeType()));
- iiToDataList.add(result.getIdentifier());
+ iiToDataList.add(new NodeIdentifier(result.name().getNodeType()));
+ iiToDataList.add(result.name());
} else {
final var parentPath = parentSchema.statementPath();
if (parentPath.isEmpty() || !(parentPath.get(parentPath.size() - 1) instanceof OperationDefinition)) {
- iiToDataList.add(result.getIdentifier());
+ iiToDataList.add(result.name());
}
}
} else if (result instanceof MapNode map) {
jsonWriter,
depth,
fields);
- final Module module = context.getSchemaContext().findModule(data.getIdentifier().getNodeType().getModule())
+ final Module module = context.getSchemaContext().findModule(data.name().getNodeType().getModule())
.orElseThrow();
jsonWriter.name(module.getName() + ":output");
jsonWriter.beginObject();
stack.enterSchemaTree(action.getOutput().getQName());
nnWriter = createNormalizedNodeWriter(context, stack.toInference(), jsonWriter, depth, fields);
- final Module module = context.getSchemaContext().findModule(data.getIdentifier().getNodeType().getModule())
+ final Module module = context.getSchemaContext().findModule(data.name().getNodeType().getModule())
.orElseThrow();
jsonWriter.name(module.getName() + ":output");
jsonWriter.beginObject();
if (data instanceof MapEntryNode mapEntry) {
// Restconf allows returning one list item. We need to wrap it
// in map node in order to serialize it properly
- nnWriter.write(ImmutableNodes.mapNodeBuilder(data.getIdentifier().getNodeType())
- .withChild(mapEntry)
- .build());
+ nnWriter.write(ImmutableNodes.mapNodeBuilder(data.name().getNodeType()).withChild(mapEntry).build());
} else {
nnWriter.write(data);
}
private boolean wasProcessAsSimpleNode(final NormalizedNode node) throws IOException {
if (node instanceof LeafSetEntryNode<?> nodeAsLeafList) {
if (selectedByParameters(node, false)) {
- writer.startLeafSetEntryNode(nodeAsLeafList.getIdentifier());
+ writer.startLeafSetEntryNode(nodeAsLeafList.name());
writer.scalarValue(nodeAsLeafList.body());
writer.endNode();
}
return true;
} else if (node instanceof LeafNode<?> nodeAsLeaf) {
- writer.startLeafNode(nodeAsLeaf.getIdentifier());
+ writer.startLeafNode(nodeAsLeaf.name());
writer.scalarValue(nodeAsLeaf.body());
writer.endNode();
return true;
} else if (node instanceof AnyxmlNode<?> anyxmlNode) {
final Class<?> objectModel = anyxmlNode.bodyObjectModel();
- if (writer.startAnyxmlNode(anyxmlNode.getIdentifier(), objectModel)) {
+ if (writer.startAnyxmlNode(anyxmlNode.name(), objectModel)) {
if (DOMSource.class.isAssignableFrom(objectModel)) {
writer.domSourceValue((DOMSource) anyxmlNode.body());
} else {
return true;
} else if (node instanceof AnydataNode<?> anydataNode) {
final Class<?> objectModel = anydataNode.bodyObjectModel();
- if (writer.startAnydataNode(anydataNode.getIdentifier(), objectModel)) {
+ if (writer.startAnydataNode(anydataNode.name(), objectModel)) {
writer.scalarValue(anydataNode.body());
writer.endNode();
}
if (selectedByParameters(mapEntryNode, false)) {
writeChildren(mapEntryNode.body(), false);
} else if (fields == null && maxDepth != null && currentDepth == maxDepth) {
- writeOnlyKeys(mapEntryNode.getIdentifier().entrySet());
+ writeOnlyKeys(mapEntryNode.name().entrySet());
}
return true;
}
}
protected boolean writeMapEntryNode(final MapEntryNode node) throws IOException {
- writer.startMapEntryNode(node.getIdentifier(), node.size());
+ writer.startMapEntryNode(node.name(), node.size());
currentDepth++;
writeMapEntryChildren(node);
currentDepth--;
if (data instanceof MapEntryNode mapEntry) {
// Restconf allows returning one list item. We need to wrap it
// in map node in order to serialize it properly
- nnWriter.write(ImmutableNodes.mapNodeBuilder(data.getIdentifier().getNodeType())
- .addChild(mapEntry)
- .build());
+ nnWriter.write(ImmutableNodes.mapNodeBuilder(data.name().getNodeType()).addChild(mapEntry).build());
} else if (isRoot) {
if (data instanceof ContainerNode container && container.isEmpty()) {
writeEmptyDataNode(xmlWriter, container);
private static void writeAndWrapInDataNode(final XMLStreamWriter xmlWriter,
final RestconfNormalizedNodeWriter nnWriter, final NormalizedNode data) throws IOException {
- final QName nodeType = data.getIdentifier().getNodeType();
+ final QName nodeType = data.name().getNodeType();
final String namespace = nodeType.getNamespace().toString();
try {
xmlWriter.writeStartElement(XMLConstants.DEFAULT_NS_PREFIX, nodeType.getLocalName(), namespace);
private static void writeEmptyDataNode(final XMLStreamWriter xmlWriter, final ContainerNode data)
throws IOException {
- final QName nodeType = data.getIdentifier().getNodeType();
+ final QName nodeType = data.name().getNodeType();
final String namespace = nodeType.getNamespace().toString();
try {
xmlWriter.writeStartElement(XMLConstants.DEFAULT_NS_PREFIX, nodeType.getLocalName(), namespace);
private static void writeElements(final XMLStreamWriter xmlWriter, final RestconfNormalizedNodeWriter nnWriter,
final ContainerNode data) throws IOException {
- final QName nodeType = data.getIdentifier().getNodeType();
+ final QName nodeType = data.name().getNodeType();
final String namespace = nodeType.getNamespace().toString();
try {
xmlWriter.writeStartElement(XMLConstants.DEFAULT_NS_PREFIX, nodeType.getLocalName(), namespace);
return switch (readParams.content()) {
case ALL, CONFIG -> {
- final QName type = node.getIdentifier().getNodeType();
+ final QName type = node.name().getNodeType();
yield Response.status(Status.OK)
.entity(NormalizedNodePayload.ofReadData(instanceIdentifier, node, queryParams))
.header("ETag", '"' + type.getModule().getRevision().map(Revision::toString).orElse(null) + "-"
listener.getOutputType(), uri);
tx.merge(LogicalDatastoreType.OPERATIONAL,
- Rfc8040.restconfStateStreamPath(mapToStreams.getIdentifier()), mapToStreams);
+ Rfc8040.restconfStateStreamPath(mapToStreams.name()), mapToStreams);
}
@Override
final YangInstanceIdentifier yangIIdContext = context.getInstanceIdentifier();
final NormalizedNode data = payload.getData();
- if (yangIIdContext.isEmpty() && !NETCONF_BASE_QNAME.equals(data.getIdentifier().getNodeType())) {
+ if (yangIIdContext.isEmpty() && !NETCONF_BASE_QNAME.equals(data.name().getNodeType())) {
throw new RestconfDocumentedException("Instance identifier need to contain at least one path argument",
ErrorType.PROTOCOL, ErrorTag.MALFORMED_MESSAGE);
}
*/
@VisibleForTesting
public static void validTopLevelNodeName(final YangInstanceIdentifier path, final NormalizedNodePayload payload) {
- final QName dataNodeType = payload.getData().getIdentifier().getNodeType();
+ final QName dataNodeType = payload.getData().name().getNodeType();
if (path.isEmpty()) {
if (!NETCONF_BASE_QNAME.equals(dataNodeType)) {
throw new RestconfDocumentedException("Instance identifier has to contain at least one path argument",
final PathArgument lastPathArgument = iiWithData.getInstanceIdentifier().getLastPathArgument();
final SchemaNode schemaNode = iiWithData.getSchemaNode();
final NormalizedNode data = payload.getData();
- if (schemaNode instanceof ListSchemaNode) {
- final List<QName> keyDefinitions = ((ListSchemaNode) schemaNode).getKeyDefinition();
+ if (schemaNode instanceof ListSchemaNode listSchema) {
+ final var keyDefinitions = listSchema.getKeyDefinition();
if (lastPathArgument instanceof NodeIdentifierWithPredicates && data instanceof MapEntryNode) {
final Map<QName, Object> uriKeyValues = ((NodeIdentifierWithPredicates) lastPathArgument).asMap();
isEqualUriAndPayloadKeyValues(uriKeyValues, (MapEntryNode) data, keyDefinitions);
mutableCopyUriKeyValues.remove(keyDefinition), ErrorType.PROTOCOL, ErrorTag.DATA_MISSING,
"Missing key %s in URI.", keyDefinition);
- final Object dataKeyValue = payload.getIdentifier().getValue(keyDefinition);
+ final Object dataKeyValue = payload.name().getValue(keyDefinition);
if (!uriKeyValue.equals(dataKeyValue)) {
final String errMsg = "The value '" + uriKeyValue + "' for key '" + keyDefinition.getLocalName()
// FIXME: callers are utter duplicates, refactor them
private static void writeDataToDS(final DOMDataTreeWriteOperations tx, final MapEntryNode mapToStreams) {
// FIXME: use put() here
- tx.merge(LogicalDatastoreType.OPERATIONAL, Rfc8040.restconfStateStreamPath(mapToStreams.getIdentifier()),
- mapToStreams);
+ tx.merge(LogicalDatastoreType.OPERATIONAL, Rfc8040.restconfStateStreamPath(mapToStreams.name()), mapToStreams);
}
private static void submitData(final DOMDataTreeWriteTransaction readWriteTransaction) {
private volatile int outstanding;
private BatchedExistenceCheck(final int total) {
- this.outstanding = total;
+ outstanding = total;
}
static BatchedExistenceCheck start(final DOMDataTreeReadOperations tx,
final Collection<? extends NormalizedNode> children) {
final BatchedExistenceCheck ret = new BatchedExistenceCheck(children.size());
for (NormalizedNode child : children) {
- final YangInstanceIdentifier path = parentPath.node(child.getIdentifier());
+ final YangInstanceIdentifier path = parentPath.node(child.name());
tx.exists(datastore, path).addCallback(new FutureCallback<Boolean>() {
@Override
public void onSuccess(final Boolean result) {
import org.opendaylight.yangtools.yang.common.ErrorTag;
import org.opendaylight.yangtools.yang.common.ErrorType;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.schema.DistinctNodeContainer;
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;
final EffectiveModelContext schemaContext) {
if (data instanceof MapNode || data instanceof LeafSetNode) {
final NormalizedNode emptySubTree = ImmutableNodes.fromInstanceId(schemaContext, path);
- merge(YangInstanceIdentifier.create(emptySubTree.getIdentifier()), emptySubTree);
+ merge(YangInstanceIdentifier.of(emptySubTree.name()), emptySubTree);
TransactionUtil.ensureParentsByMerge(path, schemaContext, this);
- final Collection<? extends NormalizedNode> children = ((NormalizedNodeContainer<?>) data).body();
+ final Collection<? extends NormalizedNode> children = ((DistinctNodeContainer<?, ?>) data).body();
final BatchedExistenceCheck check =
BatchedExistenceCheck.start(verifyNotNull(rwTx), CONFIGURATION, path, children);
for (final NormalizedNode child : children) {
- final YangInstanceIdentifier childPath = path.node(child.getIdentifier());
+ final YangInstanceIdentifier childPath = path.node(child.name());
verifyNotNull(rwTx).put(CONFIGURATION, childPath, child);
}
// ... finally collect existence checks and abort the transaction if any of them failed.
final EffectiveModelContext schemaContext) {
if (data instanceof MapNode || data instanceof LeafSetNode) {
final NormalizedNode emptySubtree = ImmutableNodes.fromInstanceId(schemaContext, path);
- merge(YangInstanceIdentifier.create(emptySubtree.getIdentifier()), emptySubtree);
+ merge(YangInstanceIdentifier.of(emptySubtree.name()), emptySubtree);
TransactionUtil.ensureParentsByMerge(path, schemaContext, this);
for (final NormalizedNode child : ((NormalizedNodeContainer<?>) data).body()) {
- final YangInstanceIdentifier childPath = path.node(child.getIdentifier());
+ final YangInstanceIdentifier childPath = path.node(child.name());
verifyNotNull(rwTx).put(CONFIGURATION, childPath, child);
}
} else {
final EffectiveModelContext schemaContext) {
if (data instanceof MapNode || data instanceof LeafSetNode) {
final NormalizedNode emptySubTree = ImmutableNodes.fromInstanceId(schemaContext, path);
- merge(YangInstanceIdentifier.create(emptySubTree.getIdentifier()), emptySubTree);
+ merge(YangInstanceIdentifier.of(emptySubTree.name()), emptySubTree);
for (final NormalizedNode child : ((NormalizedNodeContainer<?>) data).body()) {
- final YangInstanceIdentifier childPath = path.node(child.getIdentifier());
+ final YangInstanceIdentifier childPath = path.node(child.name());
enqueueOperation(() -> netconfService.create(CONFIGURATION, childPath, child, Optional.empty()));
}
} else {
final EffectiveModelContext schemaContext) {
if (data instanceof MapNode || data instanceof LeafSetNode) {
final NormalizedNode emptySubTree = ImmutableNodes.fromInstanceId(schemaContext, path);
- merge(YangInstanceIdentifier.create(emptySubTree.getIdentifier()), emptySubTree);
+ merge(YangInstanceIdentifier.of(emptySubTree.name()), emptySubTree);
for (final NormalizedNode child : ((NormalizedNodeContainer<?>) data).body()) {
- final YangInstanceIdentifier childPath = path.node(child.getIdentifier());
+ final YangInstanceIdentifier childPath = path.node(child.name());
enqueueOperation(() -> netconfService.replace(CONFIGURATION, childPath, child, Optional.empty()));
}
} else {
import com.google.common.util.concurrent.FluentFuture;
import java.net.URI;
-import java.util.Collection;
import java.util.Optional;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.Response.Status;
import org.opendaylight.yangtools.yang.common.ErrorTag;
import org.opendaylight.yangtools.yang.common.ErrorType;
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.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer;
ParserIdentifier.toInstanceIdentifier(point.value(), schemaContext, Optional.empty());
int lastItemPosition = 0;
for (final NormalizedNode nodeChild : readList.body()) {
- if (nodeChild.getIdentifier().equals(instanceIdentifier.getInstanceIdentifier().getLastPathArgument())) {
+ if (nodeChild.name().equals(instanceIdentifier.getInstanceIdentifier().getLastPathArgument())) {
break;
}
lastItemPosition++;
}
int lastInsertedPosition = 0;
final NormalizedNode emptySubtree = ImmutableNodes.fromInstanceId(schemaContext, parent);
- transaction.merge(YangInstanceIdentifier.create(emptySubtree.getIdentifier()), emptySubtree);
+ transaction.merge(YangInstanceIdentifier.of(emptySubtree.name()), emptySubtree);
for (final NormalizedNode nodeChild : readList.body()) {
if (lastInsertedPosition == lastItemPosition) {
transaction.replace(path, data, schemaContext);
}
- final YangInstanceIdentifier childPath = parent.node(nodeChild.getIdentifier());
+ final YangInstanceIdentifier childPath = parent.node(nodeChild.name());
transaction.replace(childPath, nodeChild, schemaContext);
lastInsertedPosition++;
}
}
YangInstanceIdentifier path = initialPath;
- if (data instanceof MapNode) {
- final Collection<MapEntryNode> children = ((MapNode) data).body();
+ if (data instanceof MapNode mapData) {
+ final var children = mapData.body();
if (!children.isEmpty()) {
- path = path.node(children.iterator().next().getIdentifier());
+ path = path.node(children.iterator().next().name());
}
}
ParserIdentifier.toInstanceIdentifier(point.value(), schemaContext, Optional.empty());
int lastItemPosition = 0;
for (final NormalizedNode nodeChild : readList.body()) {
- if (nodeChild.getIdentifier().equals(instanceIdentifier.getInstanceIdentifier().getLastPathArgument())) {
+ if (nodeChild.name().equals(instanceIdentifier.getInstanceIdentifier().getLastPathArgument())) {
break;
}
lastItemPosition++;
}
int lastInsertedPosition = 0;
final NormalizedNode emptySubtree = ImmutableNodes.fromInstanceId(schemaContext, path.getParent());
- transaction.merge(YangInstanceIdentifier.create(emptySubtree.getIdentifier()), emptySubtree);
+ transaction.merge(YangInstanceIdentifier.of(emptySubtree.name()), emptySubtree);
for (final NormalizedNode nodeChild : readList.body()) {
if (lastInsertedPosition == lastItemPosition) {
transaction.replace(path, data, schemaContext);
}
- final YangInstanceIdentifier childPath = path.getParent().node(nodeChild.getIdentifier());
+ final YangInstanceIdentifier childPath = path.coerceParent().node(nodeChild.name());
transaction.replace(childPath, nodeChild, schemaContext);
lastInsertedPosition++;
}
final var ctxNode = DataSchemaContextTree.from(ctx).findChild(path).orElseThrow();
if (readData instanceof ContainerNode container) {
- final var builder = Builders.containerBuilder().withNodeIdentifier(container.getIdentifier());
+ final var builder = Builders.containerBuilder().withNodeIdentifier(container.name());
buildCont(builder, container.body(), ctxNode, trim);
return builder.build();
} else if (readData instanceof MapEntryNode mapEntry) {
throw new IllegalStateException("Input " + mapEntry + " does not match " + ctxNode);
}
- final var builder = Builders.mapEntryBuilder().withNodeIdentifier(mapEntry.getIdentifier());
+ final var builder = Builders.mapEntryBuilder().withNodeIdentifier(mapEntry.name());
buildMapEntryBuilder(builder, mapEntry.body(), ctxNode, trim, listSchema.getKeyDefinition());
return builder.build();
} else {
private static void appendContainer(final DataContainerNodeBuilder<?, ?> builder, final ContainerNode container,
final DataSchemaContext ctxNode, final boolean trim) {
- final var childBuilder = Builders.containerBuilder().withNodeIdentifier(container.getIdentifier());
+ final var childBuilder = Builders.containerBuilder().withNodeIdentifier(container.name());
buildCont(childBuilder, container.body(), ctxNode, trim);
builder.withChild(childBuilder.build());
}
case SYSTEM -> Builders.mapBuilder();
case USER -> Builders.orderedMapBuilder();
};
- buildList(childBuilder.withNodeIdentifier(map.getIdentifier()), map.body(), childCtx, trim,
+ buildList(childBuilder.withNodeIdentifier(map.name()), map.body(), childCtx, trim,
listSchema.getKeyDefinition());
builder.withChild(childBuilder.build());
}
final List<@NonNull QName> keys) {
for (var entry : entries) {
final var childCtx = getChildContext(ctxNode, entry);
- final var mapEntryBuilder = Builders.mapEntryBuilder().withNodeIdentifier(entry.getIdentifier());
+ final var mapEntryBuilder = Builders.mapEntryBuilder().withNodeIdentifier(entry.name());
buildMapEntryBuilder(mapEntryBuilder, entry.body(), childCtx, trim, keys);
builder.withChild(mapEntryBuilder.build());
}
*/
private static void validateNodeMerge(final @NonNull NormalizedNode stateDataNode,
final @NonNull NormalizedNode configDataNode) {
- final QNameModule moduleOfStateData = stateDataNode.getIdentifier().getNodeType().getModule();
- final QNameModule moduleOfConfigData = configDataNode.getIdentifier().getNodeType().getModule();
+ final QNameModule moduleOfStateData = stateDataNode.name().getNodeType().getModule();
+ final QNameModule moduleOfConfigData = configDataNode.name().getNodeType().getModule();
if (!moduleOfStateData.equals(moduleOfConfigData)) {
throw new RestconfDocumentedException("Unable to merge data from different modules.");
}
final @NonNull NormalizedNode stateDataNode) {
final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder = ImmutableNodes
.mapEntryBuilder();
- mapEntryBuilder.withNodeIdentifier((NodeIdentifierWithPredicates) configDataNode.getIdentifier());
+ mapEntryBuilder.withNodeIdentifier((NodeIdentifierWithPredicates) configDataNode.name());
// MAP CONFIG DATA
mapRpcDataNode(configDataNode, mapEntryBuilder);
// MAP STATE DATA
mapRpcDataNode(stateDataNode, mapEntryBuilder);
- return ImmutableNodes.mapNodeBuilder(configDataNode.getIdentifier().getNodeType())
+ return ImmutableNodes.mapNodeBuilder(configDataNode.name().getNodeType())
.addChild(mapEntryBuilder.build())
.build();
}
final @NonNull NormalizedNode stateDataNode) {
if (configDataNode instanceof UserMapNode) {
final CollectionNodeBuilder<MapEntryNode, UserMapNode> builder = Builders
- .orderedMapBuilder().withNodeIdentifier(((MapNode) configDataNode).getIdentifier());
+ .orderedMapBuilder().withNodeIdentifier(((MapNode) configDataNode).name());
mapValueToBuilder(
((UserMapNode) configDataNode).body(), ((UserMapNode) stateDataNode).body(), builder);
return builder.build();
} else if (configDataNode instanceof MapNode) {
final CollectionNodeBuilder<MapEntryNode, SystemMapNode> builder = ImmutableNodes
- .mapNodeBuilder().withNodeIdentifier(((MapNode) configDataNode).getIdentifier());
+ .mapNodeBuilder().withNodeIdentifier(((MapNode) configDataNode).name());
mapValueToBuilder(
((MapNode) configDataNode).body(), ((MapNode) stateDataNode).body(), builder);
return builder.build();
} else if (configDataNode instanceof MapEntryNode) {
final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> builder = ImmutableNodes
- .mapEntryBuilder().withNodeIdentifier(((MapEntryNode) configDataNode).getIdentifier());
+ .mapEntryBuilder().withNodeIdentifier(((MapEntryNode) configDataNode).name());
mapValueToBuilder(
((MapEntryNode) configDataNode).body(), ((MapEntryNode) stateDataNode).body(), builder);
return builder.build();
} else if (configDataNode instanceof ContainerNode) {
final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> builder = Builders
- .containerBuilder().withNodeIdentifier(((ContainerNode) configDataNode).getIdentifier());
+ .containerBuilder().withNodeIdentifier(((ContainerNode) configDataNode).name());
mapValueToBuilder(
((ContainerNode) configDataNode).body(), ((ContainerNode) stateDataNode).body(), builder);
return builder.build();
} else if (configDataNode instanceof ChoiceNode) {
final DataContainerNodeBuilder<NodeIdentifier, ChoiceNode> builder = Builders
- .choiceBuilder().withNodeIdentifier(((ChoiceNode) configDataNode).getIdentifier());
+ .choiceBuilder().withNodeIdentifier(((ChoiceNode) configDataNode).name());
mapValueToBuilder(
((ChoiceNode) configDataNode).body(), ((ChoiceNode) stateDataNode).body(), builder);
return builder.build();
} else if (configDataNode instanceof LeafNode) {
- return ImmutableNodes.leafNode(configDataNode.getIdentifier().getNodeType(), configDataNode.body());
+ return ImmutableNodes.leafNode(configDataNode.name().getNodeType(), configDataNode.body());
} else if (configDataNode instanceof UserLeafSetNode) {
final ListNodeBuilder<Object, UserLeafSetNode<Object>> builder = Builders
- .orderedLeafSetBuilder().withNodeIdentifier(((UserLeafSetNode<?>) configDataNode).getIdentifier());
+ .orderedLeafSetBuilder().withNodeIdentifier(((UserLeafSetNode<?>) configDataNode).name());
mapValueToBuilder(((UserLeafSetNode<Object>) configDataNode).body(),
((UserLeafSetNode<Object>) stateDataNode).body(), builder);
return builder.build();
} else if (configDataNode instanceof LeafSetNode) {
final ListNodeBuilder<Object, SystemLeafSetNode<Object>> builder = Builders
- .leafSetBuilder().withNodeIdentifier(((LeafSetNode<?>) configDataNode).getIdentifier());
+ .leafSetBuilder().withNodeIdentifier(((LeafSetNode<?>) configDataNode).name());
mapValueToBuilder(((LeafSetNode<Object>) configDataNode).body(),
((LeafSetNode<Object>) stateDataNode).body(), builder);
return builder.build();
} else if (configDataNode instanceof LeafSetEntryNode) {
return Builders.leafSetEntryBuilder()
- .withNodeIdentifier(((LeafSetEntryNode<?>) configDataNode).getIdentifier())
+ .withNodeIdentifier(((LeafSetEntryNode<?>) configDataNode).name())
.withValue(configDataNode.body())
.build();
} else if (configDataNode instanceof UnkeyedListNode) {
final CollectionNodeBuilder<UnkeyedListEntryNode, UnkeyedListNode> builder = Builders
- .unkeyedListBuilder().withNodeIdentifier(((UnkeyedListNode) configDataNode).getIdentifier());
+ .unkeyedListBuilder().withNodeIdentifier(((UnkeyedListNode) configDataNode).name());
mapValueToBuilder(((UnkeyedListNode) configDataNode).body(),
((UnkeyedListNode) stateDataNode).body(), builder);
return builder.build();
} else if (configDataNode instanceof UnkeyedListEntryNode) {
final DataContainerNodeBuilder<NodeIdentifier, UnkeyedListEntryNode> builder = Builders
- .unkeyedListEntryBuilder().withNodeIdentifier(((UnkeyedListEntryNode) configDataNode).getIdentifier());
+ .unkeyedListEntryBuilder().withNodeIdentifier(((UnkeyedListEntryNode) configDataNode).name());
mapValueToBuilder(((UnkeyedListEntryNode) configDataNode).body(),
((UnkeyedListEntryNode) stateDataNode).body(), builder);
final @NonNull Collection<T> configData, final @NonNull Collection<T> stateData,
final @NonNull NormalizedNodeContainerBuilder<?, PathArgument, T, ?> builder) {
final Map<PathArgument, T> configMap = configData.stream().collect(
- Collectors.toMap(NormalizedNode::getIdentifier, Function.identity()));
+ Collectors.toMap(NormalizedNode::name, Function.identity()));
final Map<PathArgument, T> stateMap = stateData.stream().collect(
- Collectors.toMap(NormalizedNode::getIdentifier, Function.identity()));
+ Collectors.toMap(NormalizedNode::name, Function.identity()));
// merge config and state data of children with different identifiers
mapDataToBuilder(configMap, stateMap, builder);
package org.opendaylight.restconf.nb.rfc8040.rests.utils;
import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.List;
import org.opendaylight.restconf.nb.rfc8040.rests.transactions.RestconfTransaction;
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.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
public static void ensureParentsByMerge(final YangInstanceIdentifier path,
final EffectiveModelContext schemaContext,
final RestconfTransaction transaction) {
- final List<PathArgument> normalizedPathWithoutChildArgs = new ArrayList<>();
+ final var normalizedPathWithoutChildArgs = new ArrayList<PathArgument>();
YangInstanceIdentifier rootNormalizedPath = null;
- final Iterator<PathArgument> it = path.getPathArguments().iterator();
+ final var it = path.getPathArguments().iterator();
while (it.hasNext()) {
- final PathArgument pathArgument = it.next();
+ final var pathArgument = it.next();
if (rootNormalizedPath == null) {
- rootNormalizedPath = YangInstanceIdentifier.create(pathArgument);
+ rootNormalizedPath = YangInstanceIdentifier.of(pathArgument);
}
if (it.hasNext()) {
return;
}
- final NormalizedNode parentStructure = ImmutableNodes.fromInstanceId(schemaContext,
- YangInstanceIdentifier.create(normalizedPathWithoutChildArgs));
- transaction.merge(rootNormalizedPath, parentStructure);
+ transaction.merge(rootNormalizedPath,
+ ImmutableNodes.fromInstanceId(schemaContext, YangInstanceIdentifier.of(normalizedPathWithoutChildArgs)));
}
}
}
Result(final List<PathArgument> steps, final SchemaInferenceStack stack, final SchemaNode node) {
- path = YangInstanceIdentifier.create(steps);
+ path = YangInstanceIdentifier.of(steps);
this.stack = requireNonNull(stack);
this.node = requireNonNull(node);
}
@Test
public void writeMapNodeAllFieldsTest() throws Exception {
final var parameterWriter = ParameterAwareNormalizedNodeWriter.forStreamWriter(writer, null,
- List.of(Set.of(keyLeafNodeData.getIdentifier().getNodeType())));
+ List.of(Set.of(keyLeafNodeData.name().getNodeType())));
parameterWriter.write(mapNodeData);
// check return value
checkMountPointNormalizedNodePayload(payload);
// check if container was found both according to its name and namespace
- final var dataNodeType = payload.getData().getIdentifier().getNodeType();
+ final var dataNodeType = payload.getData().name().getNodeType();
assertEquals("foo-bar-container", dataNodeType.getLocalName());
assertEquals("foo:module", dataNodeType.getNamespace().toString());
}
// check return value
checkMountPointNormalizedNodePayload(payload);
// check if container was found both according to its name and namespace
- final var dataNodeType = payload.getData().getIdentifier().getNodeType();
+ final var dataNodeType = payload.getData().name().getNodeType();
assertEquals("foo-bar-container", dataNodeType.getLocalName());
assertEquals("bar:module", dataNodeType.getNamespace().toString());
}
final PatchContext returnValue = jsonToPatchBodyReader.readFrom(null, null, null, mediaType, null, inputStream);
checkPatchContext(returnValue);
final var data = returnValue.getData().get(0).getNode();
- assertEquals(LEAF_NAME_QNAME, data.getIdentifier().getNodeType());
+ assertEquals(LEAF_NAME_QNAME, data.name().getNodeType());
assertEquals(ImmutableNodes.leafNode(LEAF_NAME_QNAME, "my-leaf20"), data);
}
final var returnValue = jsonToPatchBodyReader.readFrom(null, null, null, mediaType, null, inputStream);
checkPatchContext(returnValue);
final var data = returnValue.getData().get(0).getNode();
- assertEquals(CONT_AUG_QNAME, data.getIdentifier().getNodeType());
+ assertEquals(CONT_AUG_QNAME, data.name().getNodeType());
assertEquals(expectedData, data);
}
final var returnValue = jsonToPatchBodyReader.readFrom(null, null, null, mediaType, null, inputStream);
checkPatchContext(returnValue);
final var data = returnValue.getData().get(0).getNode();
- assertEquals(MAP_CONT_QNAME, data.getIdentifier().getNodeType());
+ assertEquals(MAP_CONT_QNAME, data.name().getNodeType());
assertEquals(expectedData, data);
}
final var returnValue = jsonToPatchBodyReader.readFrom(null, null, null, mediaType, null, inputStream);
checkPatchContext(returnValue);
final var data = returnValue.getData().get(0).getNode();
- assertEquals(LEAF_SET_QNAME, data.getIdentifier().getNodeType());
+ assertEquals(LEAF_SET_QNAME, data.name().getNodeType());
assertEquals(expectedData, data);
}
final var returnValue = jsonToPatchBodyReader.readFrom(null, null, null, mediaType, null, inputStream);
checkPatchContext(returnValue);
final var data = returnValue.getData().get(0).getNode();
- assertEquals(LIST_QNAME, data.getIdentifier().getNodeType());
+ assertEquals(LIST_QNAME, data.name().getNodeType());
assertEquals(expectedData, data);
}
final var returnValue = jsonToPatchBodyReader.readFrom(null, null, null, mediaType, null, inputStream);
checkPatchContext(returnValue);
final var data = returnValue.getData().get(0).getNode();
- assertEquals(CHOICE_CONT_QNAME, data.getIdentifier().getNodeType());
+ assertEquals(CHOICE_CONT_QNAME, data.name().getNodeType());
assertEquals(expectedData, data);
}
}
final var returnValue = xmlToPatchBodyReader.readFrom(null, null, null, mediaType, null, inputStream);
checkPatchContext(returnValue);
final var data = returnValue.getData().get(0).getNode();
- assertEquals(CONT_AUG_QNAME, data.getIdentifier().getNodeType());
+ assertEquals(CONT_AUG_QNAME, data.name().getNodeType());
assertEquals(expectedData, data);
}
final var returnValue = xmlToPatchBodyReader.readFrom(null, null, null, mediaType, null, inputStream);
checkPatchContext(returnValue);
final var data = returnValue.getData().get(0).getNode();
- assertEquals(MAP_CONT_QNAME, data.getIdentifier().getNodeType());
+ assertEquals(MAP_CONT_QNAME, data.name().getNodeType());
assertEquals(expectedData, data);
}
final var returnValue = xmlToPatchBodyReader.readFrom(null, null, null, mediaType, null, inputStream);
checkPatchContext(returnValue);
final var data = returnValue.getData().get(0).getNode();
- assertEquals(LEAF_SET_QNAME, data.getIdentifier().getNodeType());
+ assertEquals(LEAF_SET_QNAME, data.name().getNodeType());
assertEquals(expectedData, data);
}
final var returnValue = xmlToPatchBodyReader.readFrom(null, null, null, mediaType, null, inputStream);
checkPatchContext(returnValue);
final var data = returnValue.getData().get(0).getNode();
- assertEquals(LIST_QNAME, data.getIdentifier().getNodeType());
+ assertEquals(LIST_QNAME, data.name().getNodeType());
assertEquals(expectedData, data);
}
final var returnValue = xmlToPatchBodyReader.readFrom(null, null, null, mediaType, null, inputStream);
checkPatchContext(returnValue);
final var data = returnValue.getData().get(0).getNode();
- assertEquals(CHOICE_CONT_QNAME, data.getIdentifier().getNodeType());
+ assertEquals(CHOICE_CONT_QNAME, data.name().getNodeType());
assertEquals(expectedData, data);
}
final var returnValue = xmlToPatchBodyReader.readFrom(null, null, null, mediaType, null, inputStream);
checkPatchContext(returnValue);
final var data = returnValue.getData().get(0).getNode();
- assertEquals(LEAF_NAME_QNAME, data.getIdentifier().getNodeType());
+ assertEquals(LEAF_NAME_QNAME, data.name().getNodeType());
assertEquals(ImmutableNodes.leafNode(LEAF_NAME_QNAME, "my-leaf20"), data);
}
}
assertNotNull(payload);
final InstanceIdentifierContext iid = payload.getInstanceIdentifierContext();
- assertEquals(YangInstanceIdentifier.create(
+ assertEquals(YangInstanceIdentifier.of(
new NodeIdentifier(TOP_LEVEL_LIST),
NodeIdentifierWithPredicates.of(TOP_LEVEL_LIST, QName.create(TOP_LEVEL_LIST, "key-leaf"), "key-value")),
iid.getInstanceIdentifier());
final MapEntryNode data = (MapEntryNode) payload.getData();
assertEquals(2, data.size());
for (final DataContainerChild child : data.body()) {
- switch (child.getIdentifier().getNodeType().getLocalName()) {
+ switch (child.name().getNodeType().getLocalName()) {
case "key-leaf":
assertEquals("key-value", child.body());
break;
// check return value
checkNormalizedNodePayload(payload);
// check if container was found both according to its name and namespace
- final var payloadNodeType = payload.getData().getIdentifier().getNodeType();
+ final var payloadNodeType = payload.getData().name().getNodeType();
assertEquals("foo-bar-container", payloadNodeType.getLocalName());
assertEquals("foo:module", payloadNodeType.getNamespace().toString());
}
// check return value
checkNormalizedNodePayload(payload);
// check if container was found both according to its name and namespace
- final var payloadNodeType = payload.getData().getIdentifier().getNodeType();
+ final var payloadNodeType = payload.getData().name().getNodeType();
assertEquals("foo-bar-container", payloadNodeType.getLocalName());
assertEquals("bar:module", payloadNodeType.getNamespace().toString());
}
@Test
public void testReadData() {
- doReturn(new MultivaluedHashMap<String, String>()).when(uriInfo).getQueryParameters();
+ doReturn(new MultivaluedHashMap<>()).when(uriInfo).getQueryParameters();
doReturn(immediateFluentFuture(Optional.of(buildBaseCont))).when(read)
.read(LogicalDatastoreType.CONFIGURATION, iidBase);
doReturn(immediateFluentFuture(Optional.empty()))
@Test
public void testReadRootData() {
- doReturn(new MultivaluedHashMap<String, String>()).when(uriInfo).getQueryParameters();
+ doReturn(new MultivaluedHashMap<>()).when(uriInfo).getQueryParameters();
doReturn(immediateFluentFuture(Optional.of(wrapNodeByDataRootContainer(buildBaseContConfig))))
.when(read)
.read(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.of());
*/
@Test
public void testReadDataMountPoint() {
- doReturn(new MultivaluedHashMap<String, String>()).when(uriInfo).getQueryParameters();
+ doReturn(new MultivaluedHashMap<>()).when(uriInfo).getQueryParameters();
doReturn(immediateFluentFuture(Optional.of(buildBaseContConfig))).when(read)
.read(LogicalDatastoreType.CONFIGURATION, iidBase);
doReturn(immediateFluentFuture(Optional.of(buildBaseContOperational))).when(read)
final NormalizedNode data = ((NormalizedNodePayload) response.getEntity()).getData();
assertTrue(data instanceof ContainerNode);
assertEquals(3, ((ContainerNode) data).size());
- assertTrue(((ContainerNode) data).findChildByArg(buildPlayerCont.getIdentifier()).isPresent());
- assertTrue(((ContainerNode) data).findChildByArg(buildLibraryCont.getIdentifier()).isPresent());
- assertTrue(((ContainerNode) data).findChildByArg(buildPlaylistList.getIdentifier()).isPresent());
+ assertNotNull(((ContainerNode) data).childByArg(buildPlayerCont.name()));
+ assertNotNull(((ContainerNode) data).childByArg(buildLibraryCont.name()));
+ assertNotNull(((ContainerNode) data).childByArg(buildPlaylistList.name()));
}
@Test
public void testReadDataNoData() {
- doReturn(new MultivaluedHashMap<String, String>()).when(uriInfo).getQueryParameters();
+ doReturn(new MultivaluedHashMap<>()).when(uriInfo).getQueryParameters();
doReturn(immediateFluentFuture(Optional.empty()))
.when(read).read(LogicalDatastoreType.CONFIGURATION, iidBase);
doReturn(immediateFluentFuture(Optional.empty()))
final NormalizedNode data = ((NormalizedNodePayload) response.getEntity()).getData();
// config data present
- assertTrue(((ContainerNode) data).findChildByArg(buildPlayerCont.getIdentifier()).isPresent());
- assertTrue(((ContainerNode) data).findChildByArg(buildLibraryCont.getIdentifier()).isPresent());
+ assertNotNull(((ContainerNode) data).childByArg(buildPlayerCont.name()));
+ assertNotNull(((ContainerNode) data).childByArg(buildLibraryCont.name()));
// state data absent
- assertFalse(((ContainerNode) data).findChildByArg(buildPlaylistList.getIdentifier()).isPresent());
+ assertNull(((ContainerNode) data).childByArg(buildPlaylistList.name()));
}
/**
final NormalizedNode data = ((NormalizedNodePayload) response.getEntity()).getData();
// state data present
- assertTrue(((ContainerNode) data).findChildByArg(buildPlayerCont.getIdentifier()).isPresent());
- assertTrue(((ContainerNode) data).findChildByArg(buildPlaylistList.getIdentifier()).isPresent());
+ assertNotNull(((ContainerNode) data).childByArg(buildPlayerCont.name()));
+ assertNotNull(((ContainerNode) data).childByArg(buildPlaylistList.name()));
// config data absent
- assertFalse(((ContainerNode) data).findChildByArg(buildLibraryCont.getIdentifier()).isPresent());
+ assertNull(((ContainerNode) data).childByArg(buildLibraryCont.name()));
}
@Test
final NodeIdentifierWithPredicates nodeWithKey =
NodeIdentifierWithPredicates.of(listQname, listKeyQname, "name of band");
- doReturn(new MultivaluedHashMap<String, String>()).when(uriInfo).getQueryParameters();
+ doReturn(new MultivaluedHashMap<>()).when(uriInfo).getQueryParameters();
final InstanceIdentifierContext iidContext = InstanceIdentifierContext.ofLocalPath(contextRef, iidBase);
final NormalizedNodePayload payload = NormalizedNodePayload.of(iidContext, Builders.mapBuilder()
.withNodeIdentifier(new NodeIdentifier(listQname))
.build());
final MapNode data = (MapNode) payload.getData();
final MapEntryNode entryNode = data.body().iterator().next();
- final NodeIdentifierWithPredicates identifier = entryNode.getIdentifier();
+ final NodeIdentifierWithPredicates identifier = entryNode.name();
final YangInstanceIdentifier node =
payload.getInstanceIdentifierContext().getInstanceIdentifier().node(identifier);
doReturn(immediateFalseFluentFuture())
import org.opendaylight.yangtools.yang.common.ErrorType;
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.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public static void setUpBeforeTest() {
final String name =
"data-change-event-subscription/toaster:toaster/toasterStatus/datastore=OPERATIONAL/scope=ONE";
- final ListenerAdapter adapter = new ListenerAdapter(YangInstanceIdentifier.create(new NodeIdentifier(
- QName.create("http://netconfcentral.org/ns/toaster", "2009-11-20", "toaster"))),
+ final ListenerAdapter adapter = new ListenerAdapter(YangInstanceIdentifier.of(
+ QName.create("http://netconfcentral.org/ns/toaster", "2009-11-20", "toaster")),
name, NotificationOutputType.JSON);
ListenersBroker.getInstance().setDataChangeListeners(Map.of(name, adapter));
}
doReturn(immediateFalseFluentFuture()).when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, iid2);
final NodeIdentifier identifier =
- ((ContainerNode) ((Collection<?>) payload.getData().body()).iterator().next()).getIdentifier();
+ ((ContainerNode) ((Collection<?>) payload.getData().body()).iterator().next()).name();
final YangInstanceIdentifier node = iid2.node(identifier);
doNothing().when(readWrite).put(LogicalDatastoreType.CONFIGURATION, node.getParent(), payload.getData());
doReturn(CommitInfo.emptyFluentFuture()).when(readWrite).commit();
final MapNode data = (MapNode) payload.getData();
final MapEntryNode entryNode = data.body().iterator().next();
- final NodeIdentifierWithPredicates identifier = entryNode.getIdentifier();
+ final NodeIdentifierWithPredicates identifier = entryNode.name();
final YangInstanceIdentifier node = iidList.node(identifier);
doReturn(immediateFalseFluentFuture()).when(readWrite).exists(LogicalDatastoreType.CONFIGURATION, node);
doNothing().when(readWrite).put(LogicalDatastoreType.CONFIGURATION, node, entryNode);
doReturn(immediateFalseFluentFuture()).when(readWrite).exists(LogicalDatastoreType.CONFIGURATION,
iid2);
final NodeIdentifier identifier =
- ((ContainerNode) ((Collection<?>) payload.getData().body()).iterator().next()).getIdentifier();
+ ((ContainerNode) ((Collection<?>) payload.getData().body()).iterator().next()).name();
final YangInstanceIdentifier node = iid2.node(identifier);
doNothing().when(readWrite).put(LogicalDatastoreType.CONFIGURATION, node.getParent(), payload.getData());
final DOMException domException = new DOMException((short) 414, "Post request failed");
.withChild(ImmutableNodes.leafNode(QName.create(DATA.base, "exampleLeaf"), "i am leaf"))
.build();
- final YangInstanceIdentifier path = YangInstanceIdentifier.builder().node(content.getIdentifier()).build();
+ final YangInstanceIdentifier path = YangInstanceIdentifier.builder().node(content.name()).build();
doReturn(immediateFluentFuture(Optional.of(content))).when(read)
.read(LogicalDatastoreType.CONFIGURATION, path);
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.util.BindingMap;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
import org.skyscreamer.jsonassert.JSONAssert;
private static final String XML_NOTIF_WITHOUT_DATA_DELETE =
"/listener-adapter-test/notif-without-data-delete.xml";
- private static final YangInstanceIdentifier PATCH_CONT_YIID =
- YangInstanceIdentifier.create(new NodeIdentifier(PatchCont.QNAME));
+ private static final YangInstanceIdentifier PATCH_CONT_YIID = YangInstanceIdentifier.of(PatchCont.QNAME);
private static EffectiveModelContext SCHEMA_CONTEXT;
* @author Michael Vorburger.ch
*/
public class InMemoryMdsalModule extends AbstractModule {
-
private static final int NOTIFICATION_SERVICE_QUEUE_DEPTH = 128;
private final AbstractBaseDataBrokerTest dataBrokerTest;
private final DOMNotificationRouter domNotificationRouter;
public InMemoryMdsalModule() throws Exception {
- dataBrokerTest = new AbstractConcurrentDataBrokerTest(true) { // NOT AbstractDataBrokerTest
+ dataBrokerTest = new AbstractConcurrentDataBrokerTest(true) {
+ // NOT AbstractDataBrokerTest
};
dataBrokerTest.setup();
import org.opendaylight.yangtools.yang.common.Revision;
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.api.schema.LeafNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
private static void assertMappedData(final Map<QName, Object> map, final MapEntryNode mappedData) {
assertNotNull(mappedData);
- for (final DataContainerChild child : mappedData.body()) {
- if (child instanceof LeafNode) {
- final LeafNode<?> leaf = (LeafNode<?>) child;
- assertTrue(map.containsKey(leaf.getIdentifier().getNodeType()));
- assertEquals(map.get(leaf.getIdentifier().getNodeType()), leaf.body());
+ for (var child : mappedData.body()) {
+ if (child instanceof LeafNode<?> leaf) {
+ assertTrue(map.containsKey(leaf.name().getNodeType()));
+ assertEquals(map.get(leaf.name().getNodeType()), leaf.body());
}
}
}
*/
private static void verifyDeviations(final ContainerNode containerNode) {
int deviationsFound = 0;
- for (final DataContainerChild child : containerNode.body()) {
- if (child instanceof MapNode) {
- for (final MapEntryNode mapEntryNode : ((MapNode) child).body()) {
- for (final DataContainerChild dataContainerChild : mapEntryNode.body()) {
- if (dataContainerChild.getIdentifier().getNodeType().equals(Deviation.QNAME)) {
+ for (var child : containerNode.body()) {
+ if (child instanceof MapNode mapChild) {
+ for (var mapEntryNode : mapChild.body()) {
+ for (var dataContainerChild : mapEntryNode.body()) {
+ if (dataContainerChild.name().getNodeType().equals(Deviation.QNAME)) {
deviationsFound++;
}
}
private static void verifyLoadedModules(final ContainerNode containerNode) {
final Map<String, String> loadedModules = new HashMap<>();
- for (final DataContainerChild child : containerNode.body()) {
+ for (var child : containerNode.body()) {
if (child instanceof LeafNode) {
- assertEquals(IetfYangLibrary.MODULE_SET_ID_LEAF_QNAME, child.getIdentifier().getNodeType());
+ assertEquals(IetfYangLibrary.MODULE_SET_ID_LEAF_QNAME, child.name().getNodeType());
}
- if (child instanceof MapNode) {
- assertEquals(IetfYangLibrary.MODULE_QNAME_LIST, child.getIdentifier().getNodeType());
- for (final MapEntryNode mapEntryNode : ((MapNode) child).body()) {
+ if (child instanceof MapNode mapChild) {
+ assertEquals(IetfYangLibrary.MODULE_QNAME_LIST, child.name().getNodeType());
+ for (var mapEntryNode : mapChild.body()) {
String name = "";
String revision = "";
- for (final DataContainerChild dataContainerChild : mapEntryNode.body()) {
- switch (dataContainerChild.getIdentifier().getNodeType().getLocalName()) {
+ for (var dataContainerChild : mapEntryNode.body()) {
+ switch (dataContainerChild.name().getNodeType().getLocalName()) {
case "name":
name = String.valueOf(dataContainerChild.body());
break;
break;
default :
LOG.info("Unknown local name '{}' of node.",
- dataContainerChild.getIdentifier().getNodeType().getLocalName());
+ dataContainerChild.name().getNodeType().getLocalName());
break;
}
}
Code Review / netconf.git / commitdiff