}
private static NodeIdentifier getNodeId(final NormalizedNode parsed, final String localName) {
- return new NodeIdentifier(QName.create(parsed.getIdentifier().getNodeType(), localName));
+ return new NodeIdentifier(QName.create(parsed.name().getNodeType(), localName));
}
private static String toStringDom(final DOMSource source) {
NodeIdentifierWithPredicates.of(OUTGOING_LABELS_QNAME, INDEX_QNAME, 0);
NodeIdentifierWithPredicates secondNodeId =
NodeIdentifierWithPredicates.of(OUTGOING_LABELS_QNAME, INDEX_QNAME, 1);
- assertTrue(labels.stream().anyMatch(mapEntryNode -> mapEntryNode.getIdentifier().compareTo(firstNodeId) == 0));
- assertTrue(labels.stream().anyMatch(mapEntryNode -> mapEntryNode.getIdentifier().compareTo(secondNodeId) == 0));
+ assertTrue(labels.stream().anyMatch(mapEntryNode -> mapEntryNode.name().compareTo(firstNodeId) == 0));
+ assertTrue(labels.stream().anyMatch(mapEntryNode -> mapEntryNode.name().compareTo(secondNodeId) == 0));
}
}
public sealed interface DataContainerChild extends NormalizedNode
permits ChoiceNode, ContainerNode, ForeignDataNode, LeafNode, LeafSetNode, MapNode, UnkeyedListNode {
@Override
- NodeIdentifier getIdentifier();
+ NodeIdentifier name();
+
+ @Override
+ @Deprecated(since = "11.0.0", forRemoval = true)
+ default NodeIdentifier getIdentifier() {
+ return name();
+ }
}
d.addDuplicate(path);
}
- if (node instanceof NormalizedNodeContainer<?>) {
- for (NormalizedNode c : ((NormalizedNodeContainer<?>) node).body()) {
- findDuplicates(path.node(c.getIdentifier()), c);
+ if (node instanceof NormalizedNodeContainer<?> container) {
+ for (NormalizedNode child : container.body()) {
+ findDuplicates(path.node(child.name()), child);
}
}
} else {
* {@code true == this.getIdentifier().getValue().equals(this.body())}.
*/
@Override
- NodeWithValue<T> getIdentifier();
+ NodeWithValue<T> name();
+
+ /**
+ * {@inheritDoc}
+ *
+ * <p>
+ * <b>Implementation note</b>
+ * Invocation of {@link NodeWithValue#getValue()} on returned instance of {@link NodeWithValue} must return the
+ * same value as invocation of {@code #body()}, such as following condition is always met:
+ * {@code true == this.getIdentifier().getValue().equals(this.body())}.
+ */
+ @Override
+ @Deprecated(since = "11.0.0", forRemoval = true)
+ default NodeWithValue<T> getIdentifier() {
+ return name();
+ }
}
* @return identifier of this node in the context of parent node
*/
@Override
- NodeIdentifierWithPredicates getIdentifier();
+ NodeIdentifierWithPredicates name();
+
+ /**
+ * Returns identifier of this node in parent map node
+ *
+ * <p>
+ * Contents of identifier is defined by <code>key</code> (
+ * {@link org.opendaylight.yangtools.yang.model.api.ListSchemaNode#getKeyDefinition()}
+ * ) statement in YANG schema for associated list item and child {@link LeafNode}s
+ * values with {@link NodeIdentifier} as defined in the schema.
+ *
+ * @return identifier of this node in the context of parent node
+ */
+ @Override
+ @Deprecated(since = "11.0.0", forRemoval = true)
+ default NodeIdentifierWithPredicates getIdentifier() {
+ return name();
+ }
}
package org.opendaylight.yangtools.yang.data.api.schema;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.concepts.Identifiable;
import org.opendaylight.yangtools.concepts.PrettyTreeAware;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
* boundary -- like RFC8528. Hence we cannot really have a reasonably-structured concept of unverified
* data. Nevertheless, this interface should be named 'NormalizedData'.
*/
-public interface NormalizedNode extends Identifiable<PathArgument>, PrettyTreeAware {
- @Override
- // We override here, so that NormalizedNode.getIdentifier() has fewer implementations
- PathArgument getIdentifier();
-
+public interface NormalizedNode extends PrettyTreeAware {
/**
* Return the contract governing this {@link NormalizedNode} instance.
*
*/
@NonNull Class<? extends NormalizedNode> contract();
+ /**
+ * Return the name of this node.
+ *
+ * @return Name of this node.
+ */
+ @NonNull PathArgument name();
+
/**
* Returns the body of this node. While the return value specifies {@link Object}, this method's return value has
* further semantics. The returned object must be a well-published contract, such as {@code String},
* @return Returned value of this node.
*/
@NonNull Object body();
+
+ /**
+ * Return the name of this node.
+ *
+ * @return Name of this node.
+ * @deprecated Use {@link #name()} instead.
+ */
+ @Deprecated(since = "11.0.0", forRemoval = true)
+ default @NonNull PathArgument getIdentifier() {
+ return name();
+ }
}
private static void toStringTree(final StringBuilder sb, final NormalizedNode node, final int offset) {
final String prefix = " ".repeat(offset);
- appendPathArgument(sb.append(prefix), node.getIdentifier());
+ appendPathArgument(sb.append(prefix), node.name());
if (node instanceof NormalizedNodeContainer<?> container) {
sb.append(" {\n");
for (var child : container.body()) {
package org.opendaylight.yangtools.yang.data.api.schema;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
/**
* A {@link NormalizedNodeContainer} which preserves user supplied ordering and allows addressing of child elements by
public sealed interface OrderedNodeContainer<V extends NormalizedNode>
extends NormalizedNodeContainer<V>, OrderingAware.User
permits UnkeyedListNode, UserLeafSetNode, UserMapNode {
- @Override
- NodeIdentifier getIdentifier();
-
/**
* Returns child node by position.
*
}
@Override
- NodeIdentifier getIdentifier();
+ NodeIdentifier name();
+
+ @Override
+ @Deprecated(since = "11.0.0", forRemoval = true)
+ default NodeIdentifier getIdentifier() {
+ return name();
+ }
}
*
* <p>
* <b>Implementation note</b>
- * Invocation of {@code body()} must provide the same value as value in {@link #getIdentifier()}.
- * {@code true == this.getIdentifier().getValue().equals(this.body())}.
+ * Invocation of {@code body()} must provide the same value as value in {@link #name()}.
+ * {@code true == this.name().getValue().equals(this.body())}.
*/
@Override
V body();
protected boolean wasProcessAsSimpleNode(final NormalizedNode node) throws IOException {
if (node instanceof LeafSetEntryNode<?> nodeAsLeafList) {
- 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<?> model = anyxmlNode.bodyObjectModel();
- if (writer.startAnyxmlNode(anyxmlNode.getIdentifier(), model)) {
+ if (writer.startAnyxmlNode(anyxmlNode.name(), model)) {
final Object value = node.body();
if (DOMSource.class.isAssignableFrom(model)) {
verify(value instanceof DOMSource, "Inconsistent anyxml node %s", anyxmlNode);
LOG.debug("Ignoring unhandled anyxml node {}", anyxmlNode);
} else if (node instanceof AnydataNode<?> anydata) {
final Class<?> model = anydata.bodyObjectModel();
- if (writer.startAnydataNode(anydata.getIdentifier(), model)) {
+ if (writer.startAnydataNode(anydata.name(), model)) {
writer.scalarValue(anydata.body());
writer.endNode();
return true;
}
protected boolean writeMapEntryNode(final MapEntryNode node) throws IOException {
- writer.startMapEntryNode(node.getIdentifier(), childSizeHint(node.body()));
+ writer.startMapEntryNode(node.name(), childSizeHint(node.body()));
return writeChildren(node.body());
}
protected boolean wasProcessedAsCompositeNode(final NormalizedNode node) throws IOException {
if (node instanceof ContainerNode n) {
- writer.startContainerNode(n.getIdentifier(), childSizeHint(n.body()));
+ writer.startContainerNode(n.name(), childSizeHint(n.body()));
return writeChildren(n.body());
} else if (node instanceof MapEntryNode n) {
return writeMapEntryNode(n);
} else if (node instanceof UnkeyedListEntryNode n) {
- writer.startUnkeyedListItem(n.getIdentifier(), childSizeHint(n.body()));
+ writer.startUnkeyedListItem(n.name(), childSizeHint(n.body()));
return writeChildren(n.body());
} else if (node instanceof ChoiceNode n) {
- writer.startChoiceNode(n.getIdentifier(), childSizeHint(n.body()));
+ writer.startChoiceNode(n.name(), childSizeHint(n.body()));
return writeChildren(n.body());
} else if (node instanceof UnkeyedListNode n) {
- writer.startUnkeyedList(n.getIdentifier(), childSizeHint(n.body()));
+ writer.startUnkeyedList(n.name(), childSizeHint(n.body()));
return writeChildren(n.body());
} else if (node instanceof UserMapNode n) {
- writer.startOrderedMapNode(n.getIdentifier(), childSizeHint(n.body()));
+ writer.startOrderedMapNode(n.name(), childSizeHint(n.body()));
return writeChildren(n.body());
} else if (node instanceof SystemMapNode n) {
- writer.startMapNode(n.getIdentifier(), childSizeHint(n.body()));
+ writer.startMapNode(n.name(), childSizeHint(n.body()));
return writeChildren(n.body());
} else if (node instanceof UserLeafSetNode<?> n) {
- writer.startOrderedLeafSet(n.getIdentifier(), childSizeHint(n.body()));
+ writer.startOrderedLeafSet(n.name(), childSizeHint(n.body()));
return writeChildren(n.body());
} else if (node instanceof SystemLeafSetNode<?> n) {
- writer.startLeafSet(n.getIdentifier(), childSizeHint(n.body()));
+ writer.startLeafSet(n.name(), childSizeHint(n.body()));
return writeChildren(n.body());
}
return false;
@Override
protected boolean writeMapEntryNode(final MapEntryNode node) throws IOException {
final NormalizedNodeStreamWriter nnWriter = getWriter();
- nnWriter.startMapEntryNode(node.getIdentifier(), childSizeHint(node.body()));
+ nnWriter.startMapEntryNode(node.name(), childSizeHint(node.body()));
- final Set<QName> qnames = node.getIdentifier().keySet();
+ final Set<QName> qnames = node.name().keySet();
// Write out all the key children
for (final QName qname : qnames) {
final DataContainerChild child = node.childByArg(new NodeIdentifier(qname));
// Write all the rest
return writeChildren(Iterables.filter(node.body(), input -> {
- if (qnames.contains(input.getIdentifier().getNodeType())) {
+ if (qnames.contains(input.name().getNodeType())) {
LOG.debug("Skipping key child {}", input);
return false;
}
final LeafNode<?> mockedLeafNode = mock(LeafNode.class);
final QName leafNodeQName = QName.create("test-ns", "2016-09-16", "leaf-node");
final NodeIdentifier leafNodeId = new NodeIdentifier(leafNodeQName);
- doReturn(leafNodeId).when(mockedLeafNode).getIdentifier();
+ doReturn(leafNodeId).when(mockedLeafNode).name();
doReturn("str-value-1").when(mockedLeafNode).body();
String stringTree = NormalizedNodes.toStringTree(mockedLeafNode);
final SystemMapNode mockedMapNode = mock(SystemMapNode.class);
final NodeIdentifier listNodeId = new NodeIdentifier(listQName);
- doReturn(listNodeId).when(mockedMapNode).getIdentifier();
+ doReturn(listNodeId).when(mockedMapNode).name();
final MapEntryNode mockedMapEntryNode = mock(MapEntryNode.class);
final NodeIdentifierWithPredicates listEntryNodeId = NodeIdentifierWithPredicates.of(listQName,
leafNodeQName, "key-leaf-value");
- doReturn(listEntryNodeId).when(mockedMapEntryNode).getIdentifier();
+ doReturn(listEntryNodeId).when(mockedMapEntryNode).name();
doReturn(List.of(mockedMapEntryNode)).when(mockedMapNode).body();
doReturn(List.of(mockedLeafNode)).when(mockedMapEntryNode).body();
assertTrue(ex.getMessage().startsWith("It wasn't possible to serialize node"));
final LeafSetEntryNode<?> mockedLeafSetEntryNode = mock(LeafSetEntryNode.class);
- doReturn(new NodeWithValue<>(myLeafList, "leaflist-value-1")).when(mockedLeafSetEntryNode).getIdentifier();
+ doReturn(new NodeWithValue<>(myLeafList, "leaflist-value-1")).when(mockedLeafSetEntryNode).name();
doReturn("leaflist-value-1").when(mockedLeafSetEntryNode).body();
assertNotNull(orderedNormalizedNodeWriter.write(mockedLeafSetEntryNode));
final MapEntryNode mockedMapEntryNode = mock(MapEntryNode.class);
doReturn(NodeIdentifierWithPredicates.of(myKeyedList, myKeyLeaf, "list-key-value-1"))
- .when(mockedMapEntryNode).getIdentifier();
+ .when(mockedMapEntryNode).name();
doReturn(null).when(mockedMapEntryNode).childByArg(any(NodeIdentifier.class));
assertNotNull(orderedNormalizedNodeWriter.write(mockedMapEntryNode));
final QName leafQname = QName.create("test", "leaf");
final LeafSetEntryNode<?> leafNode = mock(LeafSetEntryNode.class);
- doReturn(new NodeWithValue<>(leafQname, "test-value")).when(leafNode).getIdentifier();
+ doReturn(new NodeWithValue<>(leafQname, "test-value")).when(leafNode).name();
doReturn("test-value").when(leafNode).body();
nnWriter.write(leafNode);
final LeafSetEntryNode<?> leafNode2 = mock(LeafSetEntryNode.class);
- doReturn(new NodeWithValue<>(leafQname, "test-value-2")).when(leafNode2).getIdentifier();
+ doReturn(new NodeWithValue<>(leafQname, "test-value-2")).when(leafNode2).name();
doReturn("test-value-2").when(leafNode2).body();
nnWriter.write(leafNode2);
}
final ContainerNode containerNode = mock(ContainerNode.class);
final LeafNode<?> leafNode = mock(LeafNode.class);
- doReturn(new NodeIdentifier(QName.create("test", "payload-container"))).when(containerNode).getIdentifier();
+ doReturn(new NodeIdentifier(QName.create("test", "payload-container"))).when(containerNode).name();
doReturn(Set.of(leafNode)).when(containerNode).body();
- doReturn(new NodeIdentifier(QName.create("test", "payload-leaf"))).when(leafNode).getIdentifier();
+ doReturn(new NodeIdentifier(QName.create("test", "payload-leaf"))).when(leafNode).name();
doReturn("leaf-value").when(leafNode).body();
return containerNode;
@Override
public SchemaOrderedNormalizedNodeWriter write(final NormalizedNode node) throws IOException {
if (schemaContext.equals(root)) {
- currentSchemaNode = schemaContext.dataChildByName(node.getIdentifier().getNodeType());
+ currentSchemaNode = schemaContext.dataChildByName(node.name().getNodeType());
} else {
currentSchemaNode = root;
}
}
private static void putChild(final Multimap<QName, NormalizedNode> qnameToNodes, final NormalizedNode child) {
- qnameToNodes.put(child.getIdentifier().getNodeType(), child);
+ qnameToNodes.put(child.name().getNodeType(), child);
}
private final class SchemaNodeSetter implements AutoCloseable {
}
AbstractImmutableDataContainerNodeBuilder(final AbstractImmutableDataContainerNode<I, R> node) {
- nodeIdentifier = node.getIdentifier();
+ nodeIdentifier = node.name();
/*
* This quite awkward. What we actually want to be saying here is: give me a copy-on-write view of your
}
protected ImmutableLeafSetNodeBuilder(final ImmutableLeafSetNode<T> node) {
- nodeIdentifier = node.getIdentifier();
+ nodeIdentifier = node.name();
value = MapAdaptor.getDefaultInstance().takeSnapshot(node.children);
}
@Override
public ImmutableLeafSetNodeBuilder<T> withChild(final LeafSetEntryNode<T> child) {
- this.value.put(child.getIdentifier(), child);
+ value.put(child.name(), child);
return this;
}
@Override
public ImmutableLeafSetNodeBuilder<T> withoutChild(final PathArgument key) {
- this.value.remove(key);
+ value.remove(key);
return this;
}
@Override
public ImmutableLeafSetNodeBuilder<T> withNodeIdentifier(final NodeIdentifier withNodeIdentifier) {
- this.nodeIdentifier = withNodeIdentifier;
+ nodeIdentifier = withNodeIdentifier;
return this;
}
return false;
}
for (var child : children.values()) {
- if (!child.equals(other.childByArg(child.getIdentifier()))) {
+ if (!child.equals(other.childByArg(child.name()))) {
return false;
}
}
public class ImmutableMapEntryNodeBuilder
extends AbstractImmutableDataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> {
private static final Logger LOG = LoggerFactory.getLogger(ImmutableMapEntryNodeBuilder.class);
+ // FIXME: NodeIdentifier instead
protected final Map<QName, PathArgument> childrenQNamesToPaths;
protected ImmutableMapEntryNodeBuilder() {
private static void putQName(final Map<QName, PathArgument> map, final DataContainerChild child) {
// Augmentation nodes cannot be keys, and do not have to be present in childrenQNamesToPaths map
- final PathArgument identifier = child.getIdentifier();
+ final var identifier = child.name();
map.put(identifier.getNodeType(), identifier);
}
}
protected ImmutableMapNodeBuilder(final SystemMapNode node) {
- nodeIdentifier = node.getIdentifier();
+ nodeIdentifier = node.name();
value = MapAdaptor.getDefaultInstance().takeSnapshot(accessChildren(node));
}
@Override
public ImmutableMapNodeBuilder withChild(final MapEntryNode child) {
- value.put(child.getIdentifier(), child);
+ value.put(child.name(), child);
return this;
}
@Override
public ImmutableMapNodeBuilder withValue(final Collection<MapEntryNode> withValue) {
// TODO replace or putAll ?
- for (final MapEntryNode mapEntryNode : withValue) {
+ for (var mapEntryNode : withValue) {
withChild(mapEntryNode);
}
}
protected ImmutableUnkeyedListNodeBuilder(final ImmutableUnkeyedListNode node) {
- nodeIdentifier = node.getIdentifier();
+ nodeIdentifier = node.name();
// FIXME: clean this up, notably reuse unmodified lists
value = new LinkedList<>();
Iterables.addAll(value, node.body());
}
ImmutableUserLeafSetNodeBuilder(final ImmutableUserLeafSetNode<T> node) {
- nodeIdentifier = node.getIdentifier();
+ nodeIdentifier = node.name();
value = node.getChildren();
dirty = true;
}
@Override
public ImmutableUserLeafSetNodeBuilder<T> withChild(final LeafSetEntryNode<T> child) {
checkDirty();
- this.value.put(child.getIdentifier(), child);
+ value.put(child.name(), child);
return this;
}
@Override
public ImmutableUserLeafSetNodeBuilder<T> withoutChild(final PathArgument key) {
checkDirty();
- this.value.remove(key);
+ value.remove(key);
return this;
}
@Override
public ImmutableUserLeafSetNodeBuilder<T> withNodeIdentifier(final NodeIdentifier withNodeIdentifier) {
- this.nodeIdentifier = withNodeIdentifier;
+ nodeIdentifier = withNodeIdentifier;
return this;
}
}
private ImmutableUserMapNodeBuilder(final ImmutableUserMapNode node) {
- nodeIdentifier = node.getIdentifier();
+ nodeIdentifier = node.name();
value = node.children;
dirty = true;
}
@Override
public CollectionNodeBuilder<MapEntryNode, UserMapNode> withChild(final MapEntryNode child) {
checkDirty();
- value.put(child.getIdentifier(), child);
+ value.put(child.name(), child);
return this;
}
}
public DataContainerChild validateChild(final DataContainerChild child) {
- validateChild(child.getIdentifier());
+ validateChild(child.name());
return child;
}
* NormalizedNode API.
*/
private static Set<QName> getChildNodes(final DataNodeContainer nodeContainer) {
- Set<QName> allChildNodes = new HashSet<>();
+ final var allChildNodes = new HashSet<QName>();
for (var childSchema : nodeContainer.getChildNodes()) {
if (childSchema instanceof CaseSchemaNode caseChildSchema) {
return false;
}
for (var child : body()) {
- if (!child.equals(other.childByArg(child.getIdentifier()))) {
+ if (!child.equals(other.childByArg(child.name()))) {
return false;
}
}
}
public static void putChild(final Map<PathArgument, Object> map, final DataContainerChild child) {
- final DataContainerChild node = requireNonNull(child);
- map.put(node.getIdentifier(), encodeExpendableChild(node));
+ final var node = requireNonNull(child);
+ map.put(node.name(), encodeExpendableChild(node));
}
static @NonNull LeafNode<?> coerceLeaf(final PathArgument key, final Object value) {
import java.net.URISyntaxException;
import java.util.HashMap;
import java.util.LinkedList;
-import java.util.Map;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.util.UnmodifiableCollection;
@Test
public void immutableOrderedMapBuilderTest() {
- final LinkedList<MapEntryNode> mapEntryNodeColl = new LinkedList<>();
+ final var mapEntryNodeColl = new LinkedList<MapEntryNode>();
mapEntryNodeColl.add(LIST_MAIN_CHILD_3);
- final Map<QName, Object> keys = new HashMap<>();
+ final var keys = new HashMap<QName, Object>();
keys.put(LIST_MAIN_CHILD_QNAME_1, 1);
final NodeIdentifierWithPredicates mapEntryPath = NodeIdentifierWithPredicates.of(LIST_MAIN, keys);
final UserMapNode orderedMapNodeCreateNull = ImmutableUserMapNodeBuilder.create()
assertEquals(SIZE, orderedMapNodeCreateNull.size());
assertEquals(orderedMapNodeCreateNode.size(), orderedMapNodeCreateNull.size() - 1);
- assertEquals(NODE_IDENTIFIER_LIST, orderedMapNodeCreateSize.getIdentifier());
+ assertEquals(NODE_IDENTIFIER_LIST, orderedMapNodeCreateSize.name());
assertEquals(LIST_MAIN_CHILD_1, orderedMapNodeCreateNull.childAt(0));
assertEquals(SIZE, orderedMapNodeCreateNull.size());
assertEquals(orderedMapNodeSchemaAware.childAt(0), orderedMapNodeSchemaAwareMapNodeConst.childAt(0));
.build();
final UnkeyedListEntryNode unkeyedListEntryNodeNode = ImmutableUnkeyedListEntryNodeBuilder
.create(unkeyedListEntryNode).build();
- assertEquals(unkeyedListEntryNode.getIdentifier(), unkeyedListEntryNodeSize.getIdentifier());
- assertEquals(unkeyedListEntryNodeSize.getIdentifier(), unkeyedListEntryNodeNode.getIdentifier());
+ assertEquals(unkeyedListEntryNode.name(), unkeyedListEntryNodeSize.name());
+ assertEquals(unkeyedListEntryNodeSize.name(), unkeyedListEntryNodeNode.name());
}
@Test
assertNotNull(unkeyedListNodeSize.body());
assertEquals(unkeyedListEntryNode, unkeyedListNodeCreated.childAt(0));
- assertEquals(unkeyedListNode.getIdentifier(), unkeyedListNodeSize.getIdentifier());
+ assertEquals(unkeyedListNode.name(), unkeyedListNodeSize.name());
assertNotNull(unkeyedListNodeCreated);
}
final ChoiceNode choiceNode = ImmutableChoiceNodeBuilder.create(1).withNodeIdentifier(NODE_IDENTIFIER_LIST)
.build();
final ChoiceNode choiceNodeCreated = ImmutableChoiceNodeBuilder.create(choiceNode).build();
- assertEquals(choiceNodeCreated.getIdentifier(), choiceNode.getIdentifier());
+ assertEquals(choiceNodeCreated.name(), choiceNode.name());
}
@Test
final MapEntryNode entry = value.iterator().next();
// The entry must have a the proper order
- assertArrayEquals(new Object[] { FOO, BAR }, entry.getIdentifier().keySet().toArray());
+ assertArrayEquals(new Object[] { FOO, BAR }, entry.name().keySet().toArray());
}
}
@Test
public void testContainerNodeEquality() {
final var mock = mock(ContainerNode.class);
- doReturn(new NodeIdentifier(FOO)).when(mock).getIdentifier();
+ doReturn(new NodeIdentifier(FOO)).when(mock).name();
doReturn(1).when(mock).size();
doReturn(ImmutableNodes.leafNode(BAR, "abc")).when(mock).childByArg(new NodeIdentifier(BAR));
@Test
public void testSystemLeafSetNodeEquality() {
final var mock = mock(SystemLeafSetNode.class);
- doReturn(new NodeIdentifier(FOO)).when(mock).getIdentifier();
+ doReturn(new NodeIdentifier(FOO)).when(mock).name();
doReturn(1).when(mock).size();
doReturn(Builders.leafSetEntryBuilder()
.withNodeIdentifier(new NodeWithValue<>(FOO, "abc"))
@Test
public void testUserLeafSetNodeEquality() {
final var mock = mock(UserLeafSetNode.class);
- doReturn(new NodeIdentifier(FOO)).when(mock).getIdentifier();
+ doReturn(new NodeIdentifier(FOO)).when(mock).name();
doReturn(List.of(
Builders.leafSetEntryBuilder()
.withNodeIdentifier(new NodeWithValue<>(FOO, "abc"))
*/
package org.opendaylight.yangtools.yang.data.spi.node;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
+import com.google.common.base.MoreObjects;
import com.google.common.base.MoreObjects.ToStringHelper;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.concepts.AbstractIdentifiable;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.concepts.PrettyTree;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
*/
@Beta
public abstract class AbstractNormalizedNode<I extends PathArgument, T extends NormalizedNode>
- extends AbstractIdentifiable<PathArgument, I> implements NormalizedNode, Immutable {
- protected AbstractNormalizedNode(final I identifier) {
- super(identifier);
+ implements NormalizedNode, Immutable {
+ private final @NonNull I name;
+
+ protected AbstractNormalizedNode(final I name) {
+ this.name = requireNonNull(name);
+ }
+
+ @Override
+ public final I name() {
+ return name;
}
@Override
if (this == obj) {
return true;
}
- final Class<T> clazz = implementedType();
+ final var clazz = implementedType();
if (!clazz.isInstance(obj)) {
return false;
}
- final T other = clazz.cast(obj);
- return getIdentifier().equals(other.getIdentifier()) && valueEquals(other);
+ final var other = clazz.cast(obj);
+ return name().equals(other.name()) && valueEquals(other);
}
@Override
public final int hashCode() {
- return 31 * getIdentifier().hashCode() + valueHashCode();
+ return 31 * name().hashCode() + valueHashCode();
}
@Override
+ public final String toString() {
+ return addToStringAttributes(MoreObjects.toStringHelper(this)).toString();
+ }
+
protected ToStringHelper addToStringAttributes(final ToStringHelper toStringHelper) {
- return super.addToStringAttributes(toStringHelper).add("body", body());
+ return toStringHelper.add("name", name).add("body", body());
}
protected abstract @NonNull Class<T> implementedType();
appendIndent(sb, depth);
sb.append(simpleName.toLowerCase(Locale.ROOT).charAt(0)).append(simpleName, 1, simpleName.length()).append(' ');
- final QName qname = node.getIdentifier().getNodeType();
+ final QName qname = node.name().getNodeType();
final QNameModule currentNamespace = qname.getModule();
appendNamespace(sb, parentNamespace, currentNamespace);
sb.append(qname.getLocalName()).append(' ');
@Override
final void verifyValueChildren(final NormalizedNode writtenValue) {
if (verifyChildrenStructure) {
- final DistinctNodeContainer<?, ?> container = (DistinctNodeContainer<?, ?>) writtenValue;
- for (final NormalizedNode child : container.body()) {
- final ModificationApplyOperation childOp = childByArg(child.getIdentifier());
+ final var container = (DistinctNodeContainer<?, ?>) writtenValue;
+ for (var child : container.body()) {
+ final ModificationApplyOperation childOp = childByArg(child.name());
if (childOp == null) {
throw new SchemaValidationFailedException(String.format(
"Node %s is not a valid child of %s according to the schema.",
- child.getIdentifier(), container.getIdentifier()));
+ child.name(), container.name()));
}
childOp.fullVerifyStructure(child);
}
@Override
protected final void recursivelyVerifyStructure(final NormalizedNode value) {
- final NormalizedNodeContainer<?> container = (NormalizedNodeContainer<?>) value;
- for (final NormalizedNode child : container.body()) {
- final ModificationApplyOperation childOp = childByArg(child.getIdentifier());
+ final var container = (NormalizedNodeContainer<?>) value;
+ for (var child : container.body()) {
+ final var childOp = childByArg(child.name());
if (childOp == null) {
throw new SchemaValidationFailedException(
String.format("Node %s is not a valid child of %s according to the schema.",
- child.getIdentifier(), container.getIdentifier()));
+ child.name(), container.name()));
}
childOp.recursivelyVerifyStructure(child);
final NormalizedNode value = modification.getWrittenValue();
Verify.verify(value instanceof DistinctNodeContainer, "Attempted to merge non-container %s", value);
- for (final NormalizedNode c : ((DistinctNodeContainer<?, ?>) value).body()) {
- final PathArgument id = c.getIdentifier();
+ for (var c : ((DistinctNodeContainer<?, ?>) value).body()) {
+ final var id = c.name();
modification.modifyChild(id, resolveChildOperation(id), version);
}
return applyTouch(modification, currentMeta, version);
private void mergeChildrenIntoModification(final ModifiedNode modification,
final Collection<? extends NormalizedNode> children, final Version version) {
for (final NormalizedNode c : children) {
- final ModificationApplyOperation childOp = resolveChildOperation(c.getIdentifier());
- final ModifiedNode childNode = modification.modifyChild(c.getIdentifier(), childOp, version);
+ final ModificationApplyOperation childOp = resolveChildOperation(c.name());
+ final ModifiedNode childNode = modification.modifyChild(c.name(), childOp, version);
childOp.mergeIntoModifiedNode(childNode, c, version);
}
}
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
-import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodes;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableChoiceNodeBuilder;
import org.opendaylight.yangtools.yang.data.tree.api.DataTreeConfiguration;
private void enforceCases(final NormalizedNode normalizedNode) {
verify(normalizedNode instanceof ChoiceNode);
- final var children = ((ChoiceNode) normalizedNode).body();
- if (!children.isEmpty()) {
- final DataContainerChild firstChild = children.iterator().next();
- final CaseEnforcer enforcer = verifyNotNull(caseEnforcers.get(firstChild.getIdentifier()),
+ final var choice = (ChoiceNode) normalizedNode;
+ if (!choice.isEmpty()) {
+ final var firstChild = choice.body().iterator().next();
+ final var enforcer = verifyNotNull(caseEnforcers.get(firstChild.name()),
"Case enforcer cannot be null. Most probably, child node %s of choice node %s does not belong "
- + "in current tree type.", firstChild.getIdentifier(), normalizedNode.getIdentifier());
+ + "in current tree type.", firstChild.name(), normalizedNode.name());
// Make sure no leaves from other cases are present
- for (final CaseEnforcer other : verifyNotNull(exclusions.get(enforcer))) {
- for (final PathArgument id : other.getChildIdentifiers()) {
- final Optional<NormalizedNode> maybeChild = NormalizedNodes.getDirectChild(normalizedNode, id);
- checkArgument(!maybeChild.isPresent(),
+ for (var other : verifyNotNull(exclusions.get(enforcer))) {
+ for (var id : other.getChildIdentifiers()) {
+ final var child = choice.childByArg(id);
+ checkArgument(child == null,
"Child %s (from case %s) implies non-presence of child %s (from case %s), which is %s",
- firstChild.getIdentifier(), enforcer, id, other, maybeChild.orElse(null));
+ firstChild.name(), enforcer, id, other, child);
}
}
}
static void checkIdentifierReferencesData(final PathArgument arg, final NormalizedNode data) {
- checkArgument(arg.equals(data.getIdentifier()),
- "Instance identifier references %s but data identifier is %s", arg, data.getIdentifier());
+ final var dataName = data.name();
+ checkArgument(arg.equals(dataName),
+ "Instance identifier references %s but data identifier is %s", arg, dataName);
}
private void checkIdentifierReferencesData(final YangInstanceIdentifier path,
// ... not found, report the error
throw new IllegalArgumentException(String.format("Node %s is missing mandatory descendant %s",
- data.getIdentifier(), path));
+ data.name(), path));
}
static AugmentationSchemaNode getAugIdentifierOfChild(final DataNodeContainer parent, final DataSchemaNode child) {
checkArgument(value instanceof NormalizedNodeContainer, "Value %s is not a NormalizedNodeContainer", value);
final int children = ((NormalizedNodeContainer<?>) value).size();
if (minElements > children) {
- throw exceptionSupplier.get(children, value.getIdentifier()
+ throw exceptionSupplier.get(children, value.name()
+ " does not have enough elements (" + children + "), needs at least " + minElements);
}
if (maxElements < children) {
- throw exceptionSupplier.get(children, value.getIdentifier()
+ throw exceptionSupplier.get(children, value.name()
+ " has too many elements (" + children + "), can have at most " + maxElements);
}
}
}
NormalizedNode createEmptyValue(final NormalizedNode original) {
- return emptyBuilder.get().withNodeIdentifier((K) cast(original).getIdentifier()).build();
+ return emptyBuilder.get().withNodeIdentifier((K) cast(original).name()).build();
}
private T cast(final NormalizedNode original) {
final Object masked = BinaryValue.wrap(values);
if (!collected.put(validator, masked)) {
final Map<Descendant, @Nullable Object> index = validator.indexValues(values);
- throw exceptionSupplier.get(cont.getIdentifier()
+ throw exceptionSupplier.get(cont.name()
+ " violates unique constraint on " + masked + " of " + index.keySet(), index);
}
}
ToStringHelper addToStringAttributes(final ToStringHelper helper) {
// Modified children add added by superclass. Here we filter the other children.
return super.addToStringAttributes(helper).add("untouched", Collections2.filter(castData().body(),
- input -> getModifiedChild(input.getIdentifier()) == null));
+ input -> getModifiedChild(input.name()) == null));
}
}
@Override
public final PathArgument getIdentifier() {
- return data.getIdentifier();
+ return data.name();
}
/**
final LeafRefContext referencingCtx, final ModificationType modificationType,
final YangInstanceIdentifier current) {
for (final DataContainerChild child : node.body()) {
- final QName qname = child.getIdentifier().getNodeType();
+ final QName qname = child.name().getNodeType();
final LeafRefContext childReferencedByCtx = referencedByCtx == null ? null
: findReferencedByCtxUnderChoice(referencedByCtx, qname);
final LeafRefContext childReferencingCtx = referencingCtx == null ? null
: findReferencingCtxUnderChoice(referencingCtx, qname);
if (childReferencedByCtx != null || childReferencingCtx != null) {
validateNodeData(child, childReferencedByCtx, childReferencingCtx, modificationType,
- current.node(child.getIdentifier()));
+ current.node(child.name()));
}
}
}
private void validateDataContainerNodeData(final DataContainerNode node, final LeafRefContext referencedByCtx,
final LeafRefContext referencingCtx, final ModificationType modificationType,
final YangInstanceIdentifier current) {
- for (final DataContainerChild child : node.body()) {
+ for (var child : node.body()) {
validateChildNodeData(child, referencedByCtx, referencingCtx, modificationType, current);
}
}
private void validateMapNodeData(final MapNode node, final LeafRefContext referencedByCtx,
final LeafRefContext referencingCtx, final ModificationType modificationType,
final YangInstanceIdentifier current) {
- for (final MapEntryNode mapEntry : node.asMap().values()) {
- final YangInstanceIdentifier mapEntryIdentifier = current.node(mapEntry.getIdentifier());
- for (final DataContainerChild child : mapEntry.body()) {
+ for (var mapEntry : node.asMap().values()) {
+ final var mapEntryIdentifier = current.node(mapEntry.name());
+ for (var child : mapEntry.body()) {
validateChildNodeData(child, referencedByCtx, referencingCtx, modificationType, mapEntryIdentifier);
}
}
private void validateChildNodeData(final DataContainerChild child, final LeafRefContext referencedByCtx,
final LeafRefContext referencingCtx, final ModificationType modificationType,
final YangInstanceIdentifier current) {
- final QName qname = child.getIdentifier().getNodeType();
+ final QName qname = child.name().getNodeType();
final LeafRefContext childReferencedByCtx = referencedByCtx == null ? null
: referencedByCtx.getReferencedChildByName(qname);
final LeafRefContext childReferencingCtx = referencingCtx == null ? null
: referencingCtx.getReferencingChildByName(qname);
if (childReferencedByCtx != null || childReferencingCtx != null) {
validateNodeData(child, childReferencedByCtx, childReferencingCtx, modificationType, current.node(
- child.getIdentifier()));
+ child.name()));
}
}
LOG.debug("Invalid leafref value [{}] allowed values {} by validation of leafref TARGET node: {} path "
+ "of invalid LEAFREF node: {} leafRef target path: {} {}", leafRefsValue,
- leafRefTargetNodeValues, leaf.getIdentifier(), leafRefContext.getCurrentNodePath(),
+ leafRefTargetNodeValues, leaf.name(), leafRefContext.getCurrentNodePath(),
leafRefContext.getAbsoluteLeafRefTargetPath(), FAILED);
errorsMessages.add(String.format("Invalid leafref value [%s] allowed values %s by validation of leafref"
+ " TARGET node: %s path of invalid LEAFREF node: %s leafRef target path: %s %s", leafRefsValue,
- leafRefTargetNodeValues, leaf.getIdentifier(), leafRefContext.getCurrentNodePath(),
+ leafRefTargetNodeValues, leaf.name(), leafRefContext.getCurrentNodePath(),
leafRefContext.getAbsoluteLeafRefTargetPath(),
FAILED));
});
LOG.debug("Operation [{}] validate data of LEAFREF node: name[{}] = value[{}] {}", modificationType,
referencingCtx.getNodeName(), leaf.body(), FAILED);
LOG.debug("Invalid leafref value [{}] allowed values {} of LEAFREF node: {} leafRef target path: {}",
- leaf.body(), values, leaf.getIdentifier(), referencingCtx.getAbsoluteLeafRefTargetPath());
+ leaf.body(), values, leaf.name(), referencingCtx.getAbsoluteLeafRefTargetPath());
errorsMessages.add(String.format("Invalid leafref value [%s] allowed values %s of LEAFREF node: %s leafRef "
- + "target path: %s", leaf.body(), values, leaf.getIdentifier(),
+ + "target path: %s", leaf.body(), values, leaf.name(),
referencingCtx.getAbsoluteLeafRefTargetPath()));
}
}
return mapEntry -> {
- for (var entryKeyValue : mapEntry.getIdentifier().entrySet()) {
+ for (var entryKeyValue : mapEntry.name().entrySet()) {
final var allowedValues = keyValues.get(entryKeyValue.getKey());
if (allowedValues != null && !allowedValues.contains(entryKeyValue.getValue())) {
return false;
DataTreeConfiguration.DEFAULT_CONFIGURATION, SCHEMA_CONTEXT);
final DataTreeModification modificationTree = inMemoryDataTree.takeSnapshot().newModification();
final YangInstanceIdentifier ii = OUTER_LIST_1_PATH.node(new NodeIdentifier(TestModel.INNER_LIST_QNAME))
- .node(INNER_FOO_ENTRY_NODE.getIdentifier());
+ .node(INNER_FOO_ENTRY_NODE.name());
modificationTree.write(ii, INNER_FOO_ENTRY_NODE);
inMemoryDataTree.validate(modificationTree);
.withNodeIdentifier(new NodeIdentifier(MIN_MAX_LIST_QNAME))
.withChild(fooEntryNode).build();
- final YangInstanceIdentifier fooPath = MIN_MAX_LIST_PATH.node(fooEntryNode.getIdentifier());
- final YangInstanceIdentifier barPath = MIN_MAX_LIST_PATH.node(barEntryNode.getIdentifier());
- final YangInstanceIdentifier gooPath = MIN_MAX_LIST_PATH.node(gooEntryNode.getIdentifier());
+ final YangInstanceIdentifier fooPath = MIN_MAX_LIST_PATH.node(fooEntryNode.name());
+ final YangInstanceIdentifier barPath = MIN_MAX_LIST_PATH.node(barEntryNode.name());
+ final YangInstanceIdentifier gooPath = MIN_MAX_LIST_PATH.node(gooEntryNode.name());
modificationTree.write(MIN_MAX_LIST_PATH, mapNode);
modificationTree.merge(barPath, barEntryNode);
@Override
public final PathArgument getIdentifier() {
- return data.getIdentifier();
+ return data.name();
}
final @NonNull Optional<NormalizedNode> dataOptional() {
@Override
public String toString() {
- return this.getClass().getSimpleName() + "{data = " + this.data + "}";
+ return this.getClass().getSimpleName() + "{data = " + data + "}";
}
}
@Override
public final PathArgument getIdentifier() {
- return data.getIdentifier();
+ return data.name();
}
@Override
final Collection<DataTreeCandidateNode> result = new ArrayList<>();
for (NormalizedNode child : newData.body()) {
final DataTreeCandidateNode node;
- final NormalizedNode oldChild = oldData.childByArg(child.getIdentifier());
+ final NormalizedNode oldChild = oldData.childByArg(child.name());
if (oldChild != null) {
// This does not find children which have not in fact been modified, as doing that
// reliably would require us running a full equals() on the two nodes.
// Process removals next, looking into new data to see if we processed it
for (NormalizedNode child : oldData.body()) {
- if (newData.childByArg(child.getIdentifier()) == null) {
+ if (newData.childByArg(child.name()) == null) {
result.add(deleteNode(child));
}
}
@Override
public PathArgument getIdentifier() {
- return data.getIdentifier();
+ return data.name();
}
@Override
final NormalizedNodeDataTreeCandidateNode normalizedNodeDataTreeCandidateNode = new
NormalizedNodeDataTreeCandidateNode(mockedNormalizedNode);
- final PathArgument mockedPathArgument = new NodeIdentifier(QName.create("test", "test"));
- doReturn(mockedPathArgument).when(mockedNormalizedNode).getIdentifier();
+ final var mockedPathArgument = new NodeIdentifier(QName.create("test", "test"));
+ doReturn(mockedPathArgument).when(mockedNormalizedNode).name();
assertSame(mockedPathArgument, normalizedNodeDataTreeCandidateNode.getIdentifier());
final Collection<DataTreeCandidateNode> childNodes = normalizedNodeDataTreeCandidateNode.getChildNodes();
@Test
public void testDeleteUnkeyedList() {
final var childId = new NodeIdentifier(QName.create("foo", "foo"));
- doReturn(childId).when(child).getIdentifier();
+ doReturn(childId).when(child).name();
doReturn(List.of(child)).when(oldData).body();
doReturn(List.of()).when(newData).body();
doReturn(null).when(newData).childByArg(childId);
@Override
protected final MountPointContext createMountPointContext(final EffectiveModelContext schemaContext,
final ContainerNode mountData) {
- checkArgument(SCHEMA_MOUNTS.equals(mountData.getIdentifier()), "Unexpected top-level container %s", mountData);
+ checkArgument(SCHEMA_MOUNTS.equals(mountData.name()), "Unexpected top-level container %s", mountData);
final var mountPoint = mountData.childByArg(MOUNT_POINT);
if (mountPoint == null) {
*/
public @NonNull NormalizedMetadataWriter write(final NormalizedNode data, final NormalizedMetadata metadata)
throws IOException {
- final PathArgument dataId = data.getIdentifier();
+ final PathArgument dataId = data.name();
final PathArgument metaId = metadata.getIdentifier();
checkArgument(dataId.equals(metaId), "Mismatched data %s and metadata %s", dataId, metaId);
}
public static Optional<CaseSchemaNode> detectCase(final ChoiceSchemaNode schema, final DataContainerChild child) {
- final QName childId = child.getIdentifier().getNodeType();
+ final QName childId = child.name().getNodeType();
for (final CaseSchemaNode choiceCaseNode : schema.getCases()) {
if (choiceCaseNode.dataChildByName(childId) != null) {
return Optional.of(choiceCaseNode);
Code Review / yangtools.git / commitdiff