Revert "Add support for keyed entries"

[mdsal.git] / dom / mdsal-dom-spi / src / main / java / org / opendaylight / mdsal / dom / spi / query / DOMQueryEvaluator.java

diff --git a/dom/mdsal-dom-spi/src/main/java/org/opendaylight/mdsal/dom/spi/query/DOMQueryEvaluator.java b/dom/mdsal-dom-spi/src/main/java/org/opendaylight/mdsal/dom/spi/query/DOMQueryEvaluator.java
index 950593e1fa6fb04d67360f026f65bb101b194f42..e5483eb35008719467cc0f83540151fbc654f5bd 100644 (file)
--- a/dom/mdsal-dom-spi/src/main/java/org/opendaylight/mdsal/dom/spi/query/DOMQueryEvaluator.java
+++ b/dom/mdsal-dom-spi/src/main/java/org/opendaylight/mdsal/dom/spi/query/DOMQueryEvaluator.java
@@ -7,15 +7,11 @@
  */
 package org.opendaylight.mdsal.dom.spi.query;
 
-import com.google.common.collect.ImmutableList;
 import java.util.AbstractMap.SimpleImmutableEntry;
-import java.util.ArrayDeque;
-import java.util.ArrayList;
-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.PathArgument;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
@@ -27,49 +23,44 @@ public final class DOMQueryEvaluator {
 
     }
 
-    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(query, queryRoot) : new LazyDOMQueryResult(query, queryRoot);
     }
 
-    private static List<? extends Entry<YangInstanceIdentifier, NormalizedNode<?, ?>>> evalPath(
-            final ArrayDeque<PathArgument> remaining, final NormalizedNode<?,?> data, final DOMQuery query) {
-        final List<Entry<YangInstanceIdentifier, NormalizedNode<?, ?>>> result = new ArrayList<>();
-        evalPath(result, query.getRoot(), remaining, data, query);
-        return result;
-    }
-
-    private static void evalPath(final List<Entry<YangInstanceIdentifier, NormalizedNode<?,?>>> result,
-            final YangInstanceIdentifier 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<>(query.getRoot(), 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(root, arg);
+            if (next.isEmpty()) {
+                return DOMQueryResult.of();
             }
-            return;
+            evalRoot = next.orElseThrow();
         }
-
-        // TODO: this is probably insufficient
-        NormalizedNodes.findNode(data, next)
-            .ifPresent(child -> evalPath(result, path.node(next), remaining, child, query));
-        remaining.push(next);
+        return evaluateOn(query, evalRoot);
     }
 
-    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 boolean matches(final NormalizedNode<?, ?> data, final DOMQuery query) {
-        for (DOMQueryPredicate pred : query.getPredicates()) {
-            if (!pred.test(data)) {
-                return false;
-            }
-        }
-        return true;
+    private static DOMQueryResult evalSingle(final DOMQuery query, final NormalizedNode<?, ?> data) {
+        return LazyDOMQueryResultIterator.matches(data, query.getPredicates()) ? DOMQueryResult.of()
+                : DOMQueryResult.of(new SimpleImmutableEntry<>(query.getRoot(), data));
     }
 }