*/
package org.opendaylight.yangtools.yang.data.api.schema;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
-
/**
* Node representing data instance of <code>choice</code>.
*
default Class<ChoiceNode> contract() {
return ChoiceNode.class;
}
-
- @Override
- NodeIdentifier getIdentifier();
}
*/
package org.opendaylight.yangtools.yang.data.api.schema;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
-
/**
* Data subtree with cardinality 0..1 in the context of parent node.
*
default Class<ContainerNode> contract() {
return ContainerNode.class;
}
-
- @Override
- NodeIdentifier getIdentifier();
}
*/
package org.opendaylight.yangtools.yang.data.api.schema;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+
/**
* Marker interface for direct children of {@link DataContainerNode}.
*
* </ul>
*/
public interface DataContainerChild extends NormalizedNode {
-
+ @Override
+ NodeIdentifier getIdentifier();
}
*/
package org.opendaylight.yangtools.yang.data.api.schema;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
/**
* Abstract node which does not have value but contains valid {@link DataContainerChild} nodes. Schema of this node is
* </ul>
*/
public interface DataContainerNode
- extends DistinctNodeContainer<PathArgument, DataContainerChild>, OrderingAware.System {
+ extends DistinctNodeContainer<NodeIdentifier, DataContainerChild>, OrderingAware.System {
@Override
int hashCode();
import com.google.common.annotations.Beta;
import javax.xml.transform.dom.DOMSource;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
/**
* A NormalizedNode holding a value in some foreign object model. The object model is identified by a single class,
*/
@Beta
public sealed interface ForeignDataNode<V> extends DataContainerChild permits AnydataNode, AnyxmlNode {
- @Override
- NodeIdentifier getIdentifier();
-
/**
* {@inheritDoc}
*
*/
package org.opendaylight.yangtools.yang.data.api.schema;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
-
/**
* Leaf node with multiplicity 0..1.
*
default Class<LeafNode> contract() {
return LeafNode.class;
}
-
- @Override
- NodeIdentifier getIdentifier();
}
*/
package org.opendaylight.yangtools.yang.data.api.schema;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
/**
@Override
@SuppressWarnings("rawtypes")
Class<? extends LeafSetNode> contract();
-
- @Override
- NodeIdentifier getIdentifier();
}
import java.util.Collection;
import java.util.Map;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
/**
@Override
Class<? extends MapNode> contract();
- @Override
- NodeIdentifier getIdentifier();
-
/**
* Return a {@link Map} view of this node. Note that the iteration order of the returned is map is not defined in
* this interface.
requireNonNull(path, "Path must not be null").getPathArguments());
}
- @SuppressWarnings({ "unchecked", "rawtypes" })
public static Optional<NormalizedNode> getDirectChild(final NormalizedNode node,
final PathArgument pathArg) {
- if (node instanceof DataContainerNode dataContainer) {
- return (Optional) dataContainer.findChildByArg(pathArg);
+ final NormalizedNode child;
+ if (node instanceof DataContainerNode dataContainer && pathArg instanceof NodeIdentifier nid) {
+ child = dataContainer.childByArg(nid);
} else if (node instanceof MapNode map && pathArg instanceof NodeIdentifierWithPredicates nip) {
- return (Optional) map.findChildByArg(nip);
+ child = map.childByArg(nip);
} else if (node instanceof LeafSetNode<?> leafSet && pathArg instanceof NodeWithValue<?> nwv) {
- return (Optional) leafSet.findChildByArg(nwv);
+ child = leafSet.childByArg(nwv);
+ } else {
+ // Anything else, including ValueNode
+ child = null;
}
- // Anything else, including ValueNode
- return Optional.empty();
+ return Optional.ofNullable(child);
}
/**
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.doCallRealMethod;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
final var mockedDataContainerNode = mock(DataContainerNode.class);
final var mockedContainerNode = mock(ContainerNode.class);
- doReturn(mockedContainerNode).when(mockedDataContainerNode).childByArg(any(PathArgument.class));
- doCallRealMethod().when(mockedDataContainerNode).findChildByArg(any(PathArgument.class));
+ doReturn(mockedContainerNode).when(mockedDataContainerNode).childByArg(any());
assertEquals(Optional.of(mockedContainerNode),
NormalizedNodes.getDirectChild(mockedDataContainerNode, mockedPathArgument));
final var nodeIdentifierWithPredicates = NodeIdentifierWithPredicates.of(listQName, listKeyQName, "str-value");
final var mockedMapEntryNode = mock(MapEntryNode.class);
doReturn(mockedMapEntryNode).when(mockedMapNode).childByArg(any(NodeIdentifierWithPredicates.class));
- doCallRealMethod().when(mockedMapNode).findChildByArg(any(NodeIdentifierWithPredicates.class));
assertEquals(Optional.of(mockedMapEntryNode),
NormalizedNodes.getDirectChild(mockedMapNode, nodeIdentifierWithPredicates));
final QName leafListQName = QName.create("test-ns", "test-leaf-list");
final NodeWithValue<?> nodeWithValue = new NodeWithValue<>(leafListQName, "str-value");
doReturn(mockedLeafSetEntryNode).when(mockedLeafSetNode).childByArg(any(NodeWithValue.class));
- doCallRealMethod().when(mockedLeafSetNode).findChildByArg(any(NodeWithValue.class));
assertEquals(Optional.of(mockedLeafSetEntryNode),
NormalizedNodes.getDirectChild(mockedLeafSetNode, nodeWithValue));
}
final DataContainerNode mockedDataContainerNode = mock(DataContainerNode.class);
final ContainerNode mockedContainerNode = mock(ContainerNode.class);
final LeafNode<?> mockedLeafNode = mock(LeafNode.class);
- doReturn(mockedContainerNode).when(mockedDataContainerNode).childByArg(any(PathArgument.class));
- doCallRealMethod().when(mockedDataContainerNode).findChildByArg(any(PathArgument.class));
- doReturn(mockedLeafNode).when(mockedContainerNode).childByArg(any(PathArgument.class));
- doCallRealMethod().when(mockedContainerNode).findChildByArg(any(PathArgument.class));
+ doReturn(mockedContainerNode).when(mockedDataContainerNode).childByArg(any());
+ doReturn(mockedLeafNode).when(mockedContainerNode).childByArg(any());
final QName node1QName = QName.create("test-ns", "2016-09-16", "node1");
final QName node2Qname = QName.create("test-ns", "2016-09-16", "node2");
private boolean dirty;
AbstractImmutableDataContainerNodeBuilder() {
- this.value = newHashMap();
- this.dirty = false;
+ value = newHashMap();
+ dirty = false;
+ nodeIdentifier = null;
}
AbstractImmutableDataContainerNodeBuilder(final int sizeHint) {
if (sizeHint >= 0) {
- this.value = newHashMap(sizeHint);
+ value = newHashMap(sizeHint);
} else {
- this.value = newHashMap();
+ value = newHashMap();
}
- this.dirty = false;
+ dirty = false;
+ nodeIdentifier = null;
}
AbstractImmutableDataContainerNodeBuilder(final AbstractImmutableDataContainerNode<I, R> node) {
- this.nodeIdentifier = node.getIdentifier();
+ nodeIdentifier = node.getIdentifier();
/*
* This quite awkward. What we actually want to be saying here is: give me a copy-on-write view of your
* children. The API involved in that could be a bit hairy, so we do the next best thing and rely on the fact
* that the returned object implements a specific interface, which leaks the functionality we need.
*/
- this.value = node.getChildren();
- this.dirty = true;
+ value = node.getChildren();
+ dirty = true;
}
protected final I getNodeIdentifier() {
@Override
public DataContainerNodeBuilder<I, R> withoutChild(final PathArgument key) {
checkDirty();
- this.value.remove(key);
+ value.remove(key);
return this;
}
@Override
public DataContainerNodeBuilder<I, R> withNodeIdentifier(final I withNodeIdentifier) {
- this.nodeIdentifier = withNodeIdentifier;
+ nodeIdentifier = withNodeIdentifier;
return this;
}
import java.util.Collection;
import java.util.Map;
import org.opendaylight.yangtools.util.ImmutableOffsetMap;
+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.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode;
}
@Override
- public final DataContainerChild childByArg(final PathArgument child) {
+ public final DataContainerChild childByArg(final NodeIdentifier child) {
return LazyLeafOperations.getChild(children, child);
}
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
import java.util.Optional;
import java.util.Set;
import java.util.function.Predicate;
values.add(node.body());
return;
}
- if (node instanceof LeafSetNode<?>) {
- for (final NormalizedNode entry : ((LeafSetNode<?>) node).body()) {
+ if (node instanceof LeafSetNode<?> leafSet) {
+ for (var entry : leafSet.body()) {
values.add(entry.body());
}
return;
return;
}
- final PathArgument pathArgument = new NodeIdentifier(next.getQName());
- if (node instanceof DataContainerNode) {
- processChildNode(values, (DataContainerNode) node, pathArgument, next.getQNamePredicates(), path, current);
- } else if (node instanceof MapNode) {
- Stream<MapEntryNode> entries = ((MapNode) node).body().stream();
+ final var pathArgument = new NodeIdentifier(next.getQName());
+ if (node instanceof DataContainerNode dataContainer) {
+ processChildNode(values, dataContainer, pathArgument, next.getQNamePredicates(), path, current);
+ } else if (node instanceof MapNode map) {
+ Stream<MapEntryNode> entries = map.body().stream();
if (!nodePredicates.isEmpty() && current != null) {
entries = entries.filter(createMapEntryPredicate(nodePredicates, current));
}
}
private void processChildNode(final Set<Object> values, final DataContainerNode parent,
- final PathArgument arg, final List<QNamePredicate> nodePredicates, final Deque<QNameWithPredicate> path,
+ final NodeIdentifier arg, final List<QNamePredicate> nodePredicates, final Deque<QNameWithPredicate> path,
final YangInstanceIdentifier current) {
- final DataContainerChild child = parent.childByArg(arg);
+ final var child = parent.childByArg(arg);
if (child == null) {
// FIXME: YANGTOOLS-901. We have SchemaContext nearby, hence we should be able to cache how to get
// to the leaf with with specified QName, without having to iterate through Choices.
// That perhaps means we should not have QNameWithPredicates, but NodeIdentifierWithPredicates as
// the path specification.
- for (final DataContainerChild mixin : parent.body()) {
+ for (var mixin : parent.body()) {
if (mixin instanceof ChoiceNode) {
addValues(values, mixin, nodePredicates, path, current);
}
private Predicate<MapEntryNode> createMapEntryPredicate(final List<QNamePredicate> nodePredicates,
final YangInstanceIdentifier current) {
- final Map<QName, Set<?>> keyValues = new HashMap<>();
- for (QNamePredicate predicate : nodePredicates) {
+ final var keyValues = new HashMap<QName, Set<?>>();
+ for (var predicate : nodePredicates) {
keyValues.put(predicate.getIdentifier(), getPathKeyExpressionValues(predicate.getPathKeyExpression(),
current));
}
return mapEntry -> {
- for (final Entry<QName, Object> entryKeyValue : mapEntry.getIdentifier().entrySet()) {
- final Set<?> allowedValues = keyValues.get(entryKeyValue.getKey());
+ for (var entryKeyValue : mapEntry.getIdentifier().entrySet()) {
+ final var allowedValues = keyValues.get(entryKeyValue.getKey());
if (allowedValues != null && !allowedValues.contains(entryKeyValue.getValue())) {
return false;
}
};
}
- private void addNextValues(final Set<Object> values, final NormalizedNode node,
+ private void addNextValues(final Set<Object> values, final DataContainerChild node,
final List<QNamePredicate> nodePredicates, final Deque<QNameWithPredicate> path,
final YangInstanceIdentifier current) {
final QNameWithPredicate element = path.pop();
private Set<?> getPathKeyExpressionValues(final LeafRefPath predicatePathKeyExpression,
final YangInstanceIdentifier current) {
return findParentNode(Optional.of(root), current).map(parent -> {
- final Deque<QNameWithPredicate> path = createPath(predicatePathKeyExpression);
+ final var path = createPath(predicatePathKeyExpression);
path.pollFirst();
return computeValues(parent, path, null);
}).orElse(ImmutableSet.of());
Code Review / yangtools.git / commitdiff