import static com.google.common.base.Preconditions.checkArgument;
-import com.google.common.collect.ImmutableList;
import java.util.AbstractMap.SimpleImmutableEntry;
import java.util.ArrayDeque;
import java.util.ArrayList;
+import java.util.Deque;
import java.util.List;
import java.util.Map.Entry;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.opendaylight.mdsal.dom.api.query.DOMQuery;
import org.opendaylight.mdsal.dom.api.query.DOMQueryPredicate;
+import org.opendaylight.mdsal.dom.api.query.DOMQueryResult;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
}
- public static List<? extends Entry<YangInstanceIdentifier, NormalizedNode<?, ?>>> evaluate(final DOMQuery query,
- final NormalizedNode<?, ?> root) {
+ /**
+ * Evaluate {@link DOMQuery} on its data element. The element is expected to correspond to
+ * {@link DOMQuery#getRoot()}.
+ *
+ * @param query Query to execute
+ * @param queryRoot Query root object
+ * @return Result of evaluation
+ * @throws NullPointerException if any argument is null
+ */
+ public static DOMQueryResult evaluateOn(final DOMQuery query, final NormalizedNode<?, ?> queryRoot) {
final YangInstanceIdentifier path = query.getSelect();
- return path.isEmpty() ? evalSingle(root, query)
- : evalPath(new ArrayDeque<>(path.getPathArguments()), root, query);
+ return path.isEmpty() ? evalSingle(queryRoot, query)
+ : evalPath(new ArrayDeque<>(path.getPathArguments()), queryRoot, query);
}
- private static List<? extends Entry<YangInstanceIdentifier, NormalizedNode<?, ?>>> evalPath(
- final ArrayDeque<PathArgument> remaining, final NormalizedNode<?,?> data, final DOMQuery query) {
- NormalizedNode<?, ?> evalRoot = data;
+ /**
+ * Evaluate {@link DOMQuery} on a conceptual root. The element is expected to correspond to the conceptual data tree
+ * root. This method will first find the {@link DOMQuery#getRoot()} and then defer to
+ * {@link #evaluateOn(DOMQuery, NormalizedNode)}.
+ *
+ * @param query Query to execute
+ * @param root Conceptual root object
+ * @return Result of evaluation
+ * @throws NullPointerException if any argument is null
+ */
+ public static DOMQueryResult evaluateOnRoot(final DOMQuery query, final NormalizedNode<?, ?> root) {
+ NormalizedNode<?, ?> evalRoot = root;
for (PathArgument arg : query.getRoot().getPathArguments()) {
- final Optional<NormalizedNode<?, ?>> next = NormalizedNodes.findNode(data, arg);
+ final Optional<NormalizedNode<?, ?>> next = NormalizedNodes.findNode(root, arg);
if (next.isEmpty()) {
- return ImmutableList.of();
+ return EagerDOMQueryResult.of();
}
evalRoot = next.orElseThrow();
}
+ return evaluateOn(query, evalRoot);
+ }
+ private static DOMQueryResult evalPath(final ArrayDeque<PathArgument> remaining, final NormalizedNode<?, ?> data,
+ final DOMQuery query) {
final List<Entry<YangInstanceIdentifier, NormalizedNode<?, ?>>> result = new ArrayList<>();
- evalPath(result, query.getRoot(), remaining, evalRoot, query);
- return result;
+ evalPath(result, new ArrayDeque<>(query.getRoot().getPathArguments()), remaining, data, query);
+ return EagerDOMQueryResult.of(result);
}
private static void evalPath(final List<Entry<YangInstanceIdentifier, NormalizedNode<?,?>>> result,
- final
YangInstanceIdentifier path, final ArrayDeque<PathArgument> remaining,
+ final
Deque<PathArgument> path, final ArrayDeque<PathArgument> remaining,
final NormalizedNode<?, ?> data, final DOMQuery query) {
final PathArgument next = remaining.poll();
if (next == null) {
if (matches(data, query)) {
- result.add(new SimpleImmutableEntry<>(path, data));
+ result.add(new SimpleImmutableEntry<>(YangInstanceIdentifier.create(path), data));
}
return;
}
if (data instanceof MapNode && next instanceof NodeIdentifier) {
checkArgument(data.getIdentifier().equals(next), "Unexpected step %s", next);
for (MapEntryNode child : ((MapNode) data).getValue()) {
- evalPath(result, path.node(child.getIdentifier()), remaining, child, query);
+ evalChild(result, path, remaining, query, child);
}
} else {
NormalizedNodes.getDirectChild(data, next).ifPresent(
- child -> evalPath(result, path.node(next), remaining, child, query));
+ child -> evalChild(result, path, remaining, query, child));
}
remaining.push(next);
}
- private static List<? extends Entry<YangInstanceIdentifier, NormalizedNode<?, ?>>> evalSingle(
- final NormalizedNode<?, ?> data, final DOMQuery query) {
- return matches(data, query) ? ImmutableList.of()
- : ImmutableList.of(new SimpleImmutableEntry<>(query.getRoot(), data));
+ private static void evalChild(final List<Entry<YangInstanceIdentifier, NormalizedNode<?,?>>> result,
+ final Deque<PathArgument> path, final ArrayDeque<PathArgument> remaining, final DOMQuery query,
+ final NormalizedNode<?, ?> child) {
+ path.addLast(child.getIdentifier());
+ evalPath(result, path, remaining, child, query);
+ path.removeLast();
+ }
+
+ private static DOMQueryResult evalSingle(final NormalizedNode<?, ?> data, final DOMQuery query) {
+ return matches(data, query) ? EagerDOMQueryResult.of()
+ : EagerDOMQueryResult.of(new SimpleImmutableEntry<>(query.getRoot(), data));
}
private static boolean matches(final NormalizedNode<?, ?> data, final DOMQuery query) {
for (DOMQueryPredicate pred : query.getPredicates()) {
- if (!pred.test(NormalizedNodes.findNode(data, pred.getPath()).orElse(null))) {
+ // Okay, now we need to deal with predicates, but do it in a smart fashion, so we do not end up iterating
+ // all over the place. Typically we will be matching just a leaf.
+ final YangInstanceIdentifier path = pred.getPath();
+ final Optional<NormalizedNode<?, ?>> node;
+ if (path.coerceParent().isEmpty()) {
+ node = NormalizedNodes.getDirectChild(data, path.getLastPathArgument());
+ } else {
+ node = NormalizedNodes.findNode(data, path);
+ }
+
+ if (!pred.test(node.orElse(null))) {
return false;
}
}
Code Review / mdsal.git / blobdiff