Promote SchemaTracker to NormalizedNodeInferenceStack

SchemaTracker represents a well-defined construct rooted in the
relationship of NormalizedNode hierarchy (as represented by
NormalizedNodeStreamWriter) with yang.model.api model of YANG.

JIRA: YANGTOOLS-1247
Change-Id: I5babc74cb10145284693691896687943cd5276c3
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>

diff --git a/yang/yang-data-codec-gson/src/main/java/org/opendaylight/yangtools/yang/data/codec/gson/JSONNormalizedNodeStreamWriter.java b/yang/yang-data-codec-gson/src/main/java/org/opendaylight/yangtools/yang/data/codec/gson/JSONNormalizedNodeStreamWriter.java
index e1b3f1833ec033eb4a827e27bc190c02358c5c93..b8e574f2becbafde033e821eb794bf90d9e8c835 100644 (file)
--- a/yang/yang-data-codec-gson/src/main/java/org/opendaylight/yangtools/yang/data/codec/gson/JSONNormalizedNodeStreamWriter.java
+++ b/yang/yang-data-codec-gson/src/main/java/org/opendaylight/yangtools/yang/data/codec/gson/JSONNormalizedNodeStreamWriter.java
@@ -29,7 +29,7 @@ import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithV
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedAnydata;
 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriterExtension;
-import org.opendaylight.yangtools.yang.data.impl.codec.SchemaTracker;
+import org.opendaylight.yangtools.yang.data.util.NormalizedNodeInferenceStack;
 import org.opendaylight.yangtools.yang.model.api.AnydataSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
@@ -54,8 +54,8 @@ import org.w3c.dom.Text;
 public abstract class JSONNormalizedNodeStreamWriter implements NormalizedNodeStreamWriter,
         StreamWriterMountPointExtension {
     private static final class Exclusive extends JSONNormalizedNodeStreamWriter {
-        Exclusive(final JSONCodecFactory codecFactory, final SchemaTracker tracker, final JsonWriter writer,
-                final JSONStreamWriterRootContext rootContext) {
+        Exclusive(final JSONCodecFactory codecFactory, final NormalizedNodeInferenceStack tracker,
+                final JsonWriter writer, final JSONStreamWriterRootContext rootContext) {
             super(codecFactory, tracker, writer, rootContext);
         }
 
@@ -67,7 +67,7 @@ public abstract class JSONNormalizedNodeStreamWriter implements NormalizedNodeSt
     }
 
     private static final class Nested extends JSONNormalizedNodeStreamWriter {
-        Nested(final JSONCodecFactory codecFactory, final SchemaTracker tracker, final JsonWriter writer,
+        Nested(final JSONCodecFactory codecFactory, final NormalizedNodeInferenceStack tracker, final JsonWriter writer,
                 final JSONStreamWriterRootContext rootContext) {
             super(codecFactory, tracker, writer, rootContext);
         }
@@ -93,12 +93,12 @@ public abstract class JSONNormalizedNodeStreamWriter implements NormalizedNodeSt
     private static final String NOT_DECIMAL_NUMBER_STRING = "-?\\d+";
     private static final Pattern NOT_DECIMAL_NUMBER_PATTERN = Pattern.compile(NOT_DECIMAL_NUMBER_STRING);
 
-    private final SchemaTracker tracker;
+    private final NormalizedNodeInferenceStack tracker;
     private final JSONCodecFactory codecs;
     private final JsonWriter writer;
     private JSONStreamWriterContext context;
 
-    JSONNormalizedNodeStreamWriter(final JSONCodecFactory codecFactory, final SchemaTracker tracker,
+    JSONNormalizedNodeStreamWriter(final JSONCodecFactory codecFactory, final NormalizedNodeInferenceStack tracker,
             final JsonWriter writer, final JSONStreamWriterRootContext rootContext) {
         this.writer = requireNonNull(writer);
         this.codecs = requireNonNull(codecFactory);
@@ -129,8 +129,9 @@ public abstract class JSONNormalizedNodeStreamWriter implements NormalizedNodeSt
      */
     public static NormalizedNodeStreamWriter createExclusiveWriter(final JSONCodecFactory codecFactory,
             final SchemaPath path, final XMLNamespace initialNs, final JsonWriter jsonWriter) {
-        return new Exclusive(codecFactory, SchemaTracker.create(codecFactory.getEffectiveModelContext(), path),
-            jsonWriter, new JSONStreamWriterExclusiveRootContext(initialNs));
+        return new Exclusive(codecFactory,
+            NormalizedNodeInferenceStack.of(codecFactory.getEffectiveModelContext(), path), jsonWriter,
+            new JSONStreamWriterExclusiveRootContext(initialNs));
     }
 
     /**
@@ -156,7 +157,7 @@ public abstract class JSONNormalizedNodeStreamWriter implements NormalizedNodeSt
      */
     public static NormalizedNodeStreamWriter createExclusiveWriter(final JSONCodecFactory codecFactory,
             final EffectiveStatementInference rootNode, final XMLNamespace initialNs, final JsonWriter jsonWriter) {
-        return new Exclusive(codecFactory, SchemaTracker.create(rootNode), jsonWriter,
+        return new Exclusive(codecFactory, NormalizedNodeInferenceStack.of(rootNode), jsonWriter,
             new JSONStreamWriterExclusiveRootContext(initialNs));
     }
 
@@ -183,8 +184,9 @@ public abstract class JSONNormalizedNodeStreamWriter implements NormalizedNodeSt
      */
     public static NormalizedNodeStreamWriter createExclusiveWriter(final JSONCodecFactory codecFactory,
             final Absolute path, final XMLNamespace initialNs, final JsonWriter jsonWriter) {
-        return new Exclusive(codecFactory, SchemaTracker.create(codecFactory.getEffectiveModelContext(), path),
-            jsonWriter, new JSONStreamWriterExclusiveRootContext(initialNs));
+        return new Exclusive(codecFactory,
+            NormalizedNodeInferenceStack.of(codecFactory.getEffectiveModelContext(), path), jsonWriter,
+            new JSONStreamWriterExclusiveRootContext(initialNs));
     }
 
     /**
@@ -208,8 +210,8 @@ public abstract class JSONNormalizedNodeStreamWriter implements NormalizedNodeSt
      */
     public static NormalizedNodeStreamWriter createNestedWriter(final JSONCodecFactory codecFactory,
             final SchemaPath path, final XMLNamespace initialNs, final JsonWriter jsonWriter) {
-        return new Nested(codecFactory, SchemaTracker.create(codecFactory.getEffectiveModelContext(), path), jsonWriter,
-            new JSONStreamWriterSharedRootContext(initialNs));
+        return new Nested(codecFactory, NormalizedNodeInferenceStack.of(codecFactory.getEffectiveModelContext(), path),
+            jsonWriter, new JSONStreamWriterSharedRootContext(initialNs));
     }
 
     /**
@@ -233,8 +235,8 @@ public abstract class JSONNormalizedNodeStreamWriter implements NormalizedNodeSt
      */
     public static NormalizedNodeStreamWriter createNestedWriter(final JSONCodecFactory codecFactory,
             final Absolute path, final XMLNamespace initialNs, final JsonWriter jsonWriter) {
-        return new Nested(codecFactory, SchemaTracker.create(codecFactory.getEffectiveModelContext(), path), jsonWriter,
-            new JSONStreamWriterSharedRootContext(initialNs));
+        return new Nested(codecFactory, NormalizedNodeInferenceStack.of(codecFactory.getEffectiveModelContext(), path),
+            jsonWriter, new JSONStreamWriterSharedRootContext(initialNs));
     }
 
     /**
@@ -258,7 +260,7 @@ public abstract class JSONNormalizedNodeStreamWriter implements NormalizedNodeSt
      */
     public static NormalizedNodeStreamWriter createNestedWriter(final JSONCodecFactory codecFactory,
             final EffectiveStatementInference rootNode, final XMLNamespace initialNs, final JsonWriter jsonWriter) {
-        return new Nested(codecFactory, SchemaTracker.create(rootNode), jsonWriter,
+        return new Nested(codecFactory, NormalizedNodeInferenceStack.of(rootNode), jsonWriter,
             new JSONStreamWriterSharedRootContext(initialNs));
     }
 
@@ -363,7 +365,7 @@ public abstract class JSONNormalizedNodeStreamWriter implements NormalizedNodeSt
     public final NormalizedNodeStreamWriter startMountPoint(final MountPointIdentifier mountId,
             final MountPointContext mountCtx) throws IOException {
         final EffectiveModelContext ctx = mountCtx.getEffectiveModelContext();
-        return new Nested(codecs.rebaseTo(ctx), SchemaTracker.create(ctx), writer,
+        return new Nested(codecs.rebaseTo(ctx), NormalizedNodeInferenceStack.of(ctx), writer,
             new JSONStreamWriterSharedRootContext(context.getNamespace()));
     }
 

diff --git a/yang/yang-data-codec-xml/src/main/java/org/opendaylight/yangtools/yang/data/codec/xml/SchemaAwareXMLStreamNormalizedNodeStreamWriter.java b/yang/yang-data-codec-xml/src/main/java/org/opendaylight/yangtools/yang/data/codec/xml/SchemaAwareXMLStreamNormalizedNodeStreamWriter.java
index 5bfe7055ca146126802b9ffbd4d869f923aad325..70325a87f6dced4c93aab846730208c8d4eef5f1 100644 (file)
--- a/yang/yang-data-codec-xml/src/main/java/org/opendaylight/yangtools/yang/data/codec/xml/SchemaAwareXMLStreamNormalizedNodeStreamWriter.java
+++ b/yang/yang-data-codec-xml/src/main/java/org/opendaylight/yangtools/yang/data/codec/xml/SchemaAwareXMLStreamNormalizedNodeStreamWriter.java
@@ -23,7 +23,7 @@ import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.Augmentat
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
-import org.opendaylight.yangtools.yang.data.impl.codec.SchemaTracker;
+import org.opendaylight.yangtools.yang.data.util.NormalizedNodeInferenceStack;
 import org.opendaylight.yangtools.yang.model.api.AnydataSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.ContainerLike;
@@ -37,11 +37,11 @@ import org.opendaylight.yangtools.yang.model.api.TypedDataSchemaNode;
 
 final class SchemaAwareXMLStreamNormalizedNodeStreamWriter
         extends XMLStreamNormalizedNodeStreamWriter<TypedDataSchemaNode> implements EffectiveModelContextProvider {
-    private final SchemaTracker tracker;
+    private final NormalizedNodeInferenceStack tracker;
     private final SchemaAwareXMLStreamWriterUtils streamUtils;
 
     SchemaAwareXMLStreamNormalizedNodeStreamWriter(final XMLStreamWriter writer, final EffectiveModelContext context,
-            final SchemaTracker tracker) {
+            final NormalizedNodeInferenceStack tracker) {
         super(writer);
         this.tracker = requireNonNull(tracker);
         this.streamUtils = new SchemaAwareXMLStreamWriterUtils(context);

diff --git a/yang/yang-data-codec-xml/src/main/java/org/opendaylight/yangtools/yang/data/codec/xml/XMLStreamNormalizedNodeStreamWriter.java b/yang/yang-data-codec-xml/src/main/java/org/opendaylight/yangtools/yang/data/codec/xml/XMLStreamNormalizedNodeStreamWriter.java
index 1152bb9744eb936c8693767c3d88715e87029192..f0b688cd14c20abffa91b42629df9c5321c88e6f 100644 (file)
--- a/yang/yang-data-codec-xml/src/main/java/org/opendaylight/yangtools/yang/data/codec/xml/XMLStreamNormalizedNodeStreamWriter.java
+++ b/yang/yang-data-codec-xml/src/main/java/org/opendaylight/yangtools/yang/data/codec/xml/XMLStreamNormalizedNodeStreamWriter.java
@@ -29,7 +29,7 @@ import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgum
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedAnydata;
 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriterExtension;
-import org.opendaylight.yangtools.yang.data.impl.codec.SchemaTracker;
+import org.opendaylight.yangtools.yang.data.util.NormalizedNodeInferenceStack;
 import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
 import org.opendaylight.yangtools.yang.model.api.EffectiveStatementInference;
 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
@@ -71,7 +71,8 @@ public abstract class XMLStreamNormalizedNodeStreamWriter<T> implements Normaliz
      */
     public static @NonNull NormalizedNodeStreamWriter create(final XMLStreamWriter writer,
             final EffectiveModelContext context) {
-        return new SchemaAwareXMLStreamNormalizedNodeStreamWriter(writer, context, SchemaTracker.create(context));
+        return new SchemaAwareXMLStreamNormalizedNodeStreamWriter(writer, context,
+            NormalizedNodeInferenceStack.of(context));
     }
 
     /**
@@ -84,7 +85,7 @@ public abstract class XMLStreamNormalizedNodeStreamWriter<T> implements Normaliz
     public static @NonNull NormalizedNodeStreamWriter create(final XMLStreamWriter writer,
             final EffectiveStatementInference inference) {
         return new SchemaAwareXMLStreamNormalizedNodeStreamWriter(writer, inference.getEffectiveModelContext(),
-            SchemaTracker.create(inference));
+            NormalizedNodeInferenceStack.of(inference));
     }
 
     /**
@@ -97,7 +98,8 @@ public abstract class XMLStreamNormalizedNodeStreamWriter<T> implements Normaliz
      */
     public static @NonNull NormalizedNodeStreamWriter create(final XMLStreamWriter writer,
             final EffectiveModelContext context, final SchemaPath path) {
-        return new SchemaAwareXMLStreamNormalizedNodeStreamWriter(writer, context, SchemaTracker.create(context, path));
+        return new SchemaAwareXMLStreamNormalizedNodeStreamWriter(writer, context,
+            NormalizedNodeInferenceStack.of(context, path));
     }
 
     /**
@@ -110,7 +112,8 @@ public abstract class XMLStreamNormalizedNodeStreamWriter<T> implements Normaliz
      */
     public static @NonNull NormalizedNodeStreamWriter create(final XMLStreamWriter writer,
             final EffectiveModelContext context, final Absolute path) {
-        return new SchemaAwareXMLStreamNormalizedNodeStreamWriter(writer, context, SchemaTracker.create(context, path));
+        return new SchemaAwareXMLStreamNormalizedNodeStreamWriter(writer, context,
+            NormalizedNodeInferenceStack.of(context, path));
     }
 
     /**
@@ -144,7 +147,7 @@ public abstract class XMLStreamNormalizedNodeStreamWriter<T> implements Normaliz
     private static @NonNull NormalizedNodeStreamWriter forOperation(final XMLStreamWriter writer,
             final EffectiveModelContext context, final Absolute operationPath, final QName qname) {
         return new SchemaAwareXMLStreamNormalizedNodeStreamWriter(writer, context,
-            SchemaTracker.forOperation(context, operationPath, qname));
+            NormalizedNodeInferenceStack.ofOperation(context, operationPath, qname));
     }
 
     /**

diff --git a/yang/yang-data-util/src/main/java/module-info.java b/yang/yang-data-util/src/main/java/module-info.java
index 10d109568735c1b6a287a720898cb18131e24d89..df98a7065a57be292c993acb478dd559b7019881 100644 (file)
--- a/yang/yang-data-util/src/main/java/module-info.java
+++ b/yang/yang-data-util/src/main/java/module-info.java
@@ -12,13 +12,14 @@ module org.opendaylight.yangtools.yang.data.util {
     requires transitive org.opendaylight.yangtools.odlext.model.api;
     requires transitive org.opendaylight.yangtools.rfc7952.data.api;
     requires transitive org.opendaylight.yangtools.rfc8528.data.api;
+    requires transitive org.opendaylight.yangtools.yang.model.util;
 
     requires com.google.common;
     requires org.opendaylight.yangtools.yang.model.spi;
-    requires org.opendaylight.yangtools.yang.model.util;
     requires org.opendaylight.yangtools.util;
     requires org.slf4j;
 
     // Annotations
     requires static org.eclipse.jdt.annotation;
+    requires org.opendaylight.yangtools.concepts;
 }

diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/codec/SchemaTracker.java b/yang/yang-data-util/src/main/java/org/opendaylight/yangtools/yang/data/util/NormalizedNodeInferenceStack.java
similarity index 80%
rename from yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/codec/SchemaTracker.java
rename to yang/yang-data-util/src/main/java/org/opendaylight/yangtools/yang/data/util/NormalizedNodeInferenceStack.java
index 455c1fe23bcfc77c82d175fc65b5daa086fcddac..bd9a981b030d48b7130b115648a28677622b4731 100644 (file)
--- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/codec/SchemaTracker.java
+++ b/yang/yang-data-util/src/main/java/org/opendaylight/yangtools/yang/data/util/NormalizedNodeInferenceStack.java
@@ -5,7 +5,7 @@
  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
  * and is available at http://www.eclipse.org/legal/epl-v10.html
  */
-package org.opendaylight.yangtools.yang.data.impl.codec;
+package org.opendaylight.yangtools.yang.data.util;
 
 import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Verify.verify;
@@ -17,14 +17,17 @@ import java.io.IOException;
 import java.util.ArrayDeque;
 import java.util.Deque;
 import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Collectors;
 import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.yangtools.concepts.Mutable;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
-import org.opendaylight.yangtools.yang.data.impl.schema.SchemaUtils;
 import org.opendaylight.yangtools.yang.model.api.AnydataSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
@@ -56,22 +59,22 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 /**
- * Utility class for tracking the underlying state of the underlying schema node.
+ * Utility class for tracking schema state underlying a {@link NormalizedNode} structure.
  */
 @Beta
-public final class SchemaTracker {
-    private static final Logger LOG = LoggerFactory.getLogger(SchemaTracker.class);
+public final class NormalizedNodeInferenceStack implements Mutable {
+    private static final Logger LOG = LoggerFactory.getLogger(NormalizedNodeInferenceStack.class);
 
     private final Deque<WithStatus> schemaStack = new ArrayDeque<>();
     private final SchemaInferenceStack dataTree;
     private final DataNodeContainer root;
 
-    private SchemaTracker(final EffectiveModelContext context) {
+    private NormalizedNodeInferenceStack(final EffectiveModelContext context) {
         root = requireNonNull(context);
         dataTree = SchemaInferenceStack.of(context);
     }
 
-    private SchemaTracker(final SchemaInferenceStack dataTree) {
+    private NormalizedNodeInferenceStack(final SchemaInferenceStack dataTree) {
         this.dataTree = requireNonNull(dataTree);
         if (!dataTree.isEmpty()) {
             final EffectiveStatement<?, ?> current = dataTree.currentStatement();
@@ -90,8 +93,8 @@ public final class SchemaTracker {
      * @return A new {@link NormalizedNodeStreamWriter}
      * @throws NullPointerException if {@code root} is null
      */
-    public static @NonNull SchemaTracker create(final EffectiveStatementInference root) {
-        return new SchemaTracker(SchemaInferenceStack.ofInference(root));
+    public static @NonNull NormalizedNodeInferenceStack of(final EffectiveStatementInference root) {
+        return new NormalizedNodeInferenceStack(SchemaInferenceStack.ofInference(root));
     }
 
     /**
@@ -101,8 +104,8 @@ public final class SchemaTracker {
      * @return A new {@link NormalizedNodeStreamWriter}
      * @throws NullPointerException if {@code root} is null
      */
-    public static @NonNull SchemaTracker create(final Inference root) {
-        return new SchemaTracker(root.toSchemaInferenceStack());
+    public static @NonNull NormalizedNodeInferenceStack of(final Inference root) {
+        return new NormalizedNodeInferenceStack(root.toSchemaInferenceStack());
     }
 
     /**
@@ -112,8 +115,8 @@ public final class SchemaTracker {
      * @return A new {@link NormalizedNodeStreamWriter}
      * @throws NullPointerException if {@code context} is null
      */
-    public static @NonNull SchemaTracker create(final EffectiveModelContext context) {
-        return new SchemaTracker(context);
+    public static @NonNull NormalizedNodeInferenceStack of(final EffectiveModelContext context) {
+        return new NormalizedNodeInferenceStack(context);
     }
 
     /**
@@ -121,12 +124,12 @@ public final class SchemaTracker {
      *
      * @param context Associated {@link EffectiveModelContext}
      * @param path schema path
-     * @return A new {@link SchemaTracker}
+     * @return A new {@link NormalizedNodeInferenceStack}
      * @throws NullPointerException if any argument is null
      * @throws IllegalArgumentException if {@code path} does not point to a valid root
      */
-    public static @NonNull SchemaTracker create(final EffectiveModelContext context, final Absolute path) {
-        return new SchemaTracker(SchemaInferenceStack.of(context, path));
+    public static @NonNull NormalizedNodeInferenceStack of(final EffectiveModelContext context, final Absolute path) {
+        return new NormalizedNodeInferenceStack(SchemaInferenceStack.of(context, path));
     }
 
     /**
@@ -134,12 +137,13 @@ public final class SchemaTracker {
      *
      * @param context Associated {@link EffectiveModelContext}
      * @param path schema path
-     * @return A new {@link SchemaTracker}
+     * @return A new {@link NormalizedNodeInferenceStack}
      * @throws NullPointerException if any argument is null
      * @throws IllegalArgumentException if {@code path} does not point to a valid root
      */
-    public static @NonNull SchemaTracker create(final EffectiveModelContext context, final SchemaPath path) {
-        return new SchemaTracker(SchemaInferenceStack.ofInstantiatedPath(context, path));
+    @Deprecated
+    public static @NonNull NormalizedNodeInferenceStack of(final EffectiveModelContext context, final SchemaPath path) {
+        return new NormalizedNodeInferenceStack(SchemaInferenceStack.ofInstantiatedPath(context, path));
     }
 
     /**
@@ -153,14 +157,14 @@ public final class SchemaTracker {
      * @throws IllegalArgumentException if {@code operation} does not point to an actual operation or if {@code qname}
      *                                  does not identify a valid root underneath it.
      */
-    public static @NonNull SchemaTracker forOperation(final EffectiveModelContext context, final Absolute operation,
-            final QName qname) {
+    public static @NonNull NormalizedNodeInferenceStack ofOperation(final EffectiveModelContext context,
+            final Absolute operation, final QName qname) {
         final SchemaInferenceStack stack = SchemaInferenceStack.of(context, operation);
         final EffectiveStatement<?, ?> current = stack.currentStatement();
         checkArgument(current instanceof RpcEffectiveStatement || current instanceof ActionEffectiveStatement,
             "Path %s resolved into non-operation %s", operation, current);
         stack.enterSchemaTree(qname);
-        return new SchemaTracker(stack);
+        return new NormalizedNodeInferenceStack(stack);
     }
 
     /**
@@ -220,9 +224,8 @@ public final class SchemaTracker {
         if (parent instanceof LeafListSchemaNode) {
             return (LeafListSchemaNode) parent;
         }
-
-        // FIXME: when would this trigger?
-        final SchemaNode child = SchemaUtils.findDataChildSchemaByQName((SchemaNode) parent, qname);
+        checkArgument(parent instanceof DataNodeContainer, "Cannot lookup %s in parent %s", qname, parent);
+        final DataSchemaNode child = ((DataNodeContainer) parent).dataChildByName(qname);
         checkArgument(child instanceof LeafListSchemaNode,
             "Node %s is neither a leaf-list nor currently in a leaf-list", child);
         return (LeafListSchemaNode) child;
@@ -250,6 +253,28 @@ public final class SchemaTracker {
         return schema;
     }
 
+    public void startAnyxmlNode(final NodeIdentifier name) {
+        final SchemaNode schema = enterDataTree(name);
+        checkArgument(schema instanceof AnyxmlSchemaNode, "Node %s is not anyxml", schema);
+        schemaStack.push(schema);
+    }
+
+    public void startAnydataNode(final NodeIdentifier name) {
+        final SchemaNode schema = enterDataTree(name);
+        checkArgument(schema instanceof AnydataSchemaNode, "Node %s is not anydata", schema);
+        schemaStack.push(schema);
+    }
+
+    public Object endNode() {
+        final Object ret = schemaStack.pop();
+        // If this is a data tree node, make sure it is updated. Before that, though, we need to check if this is not
+        // actually listEntry -> list or leafListEntry -> leafList exit.
+        if (!(ret instanceof AugmentationSchemaNode) && getParent() != ret) {
+            dataTree.exit();
+        }
+        return ret;
+    }
+
     public AugmentationSchemaNode startAugmentationNode(final AugmentationIdentifier identifier) {
         LOG.debug("Enter augmentation {}", identifier);
         Object parent = getParent();
@@ -260,7 +285,7 @@ public final class SchemaTracker {
             parent = findCaseByChild((ChoiceSchemaNode) parent, name);
         }
         checkArgument(parent instanceof DataNodeContainer, "Augmentation allowed only in DataNodeContainer", parent);
-        final AugmentationSchemaNode schema = SchemaUtils.findSchemaForAugment((AugmentationTarget) parent,
+        final AugmentationSchemaNode schema = findSchemaForAugment((AugmentationTarget) parent,
             identifier.getPossibleChildNames());
         final AugmentationSchemaNode resolvedSchema = EffectiveAugmentationSchema.create(schema,
             (DataNodeContainer) parent);
@@ -268,6 +293,22 @@ public final class SchemaTracker {
         return resolvedSchema;
     }
 
+    // FIXME: 7.0.0: can we get rid of this?
+    private static @NonNull AugmentationSchemaNode findSchemaForAugment(final AugmentationTarget schema,
+            final Set<QName> qnames) {
+        for (final AugmentationSchemaNode augment : schema.getAvailableAugmentations()) {
+            if (qnames.equals(augment.getChildNodes().stream()
+                .map(DataSchemaNode::getQName)
+                .collect(Collectors.toUnmodifiableSet()))) {
+                return augment;
+            }
+        }
+
+        throw new IllegalStateException(
+            "Unknown augmentation node detected, identified by: " + qnames + ", in: " + schema);
+    }
+
+    // FIXME: 7.0.0: can we get rid of this?
     private static SchemaNode findCaseByChild(final ChoiceSchemaNode parent, final QName qname) {
         for (final CaseSchemaNode caze : parent.getCases()) {
             final Optional<DataSchemaNode> potential = caze.findDataChildByName(qname);
@@ -277,26 +318,4 @@ public final class SchemaTracker {
         }
         return null;
     }
-
-    public void startAnyxmlNode(final NodeIdentifier name) {
-        final SchemaNode schema = enterDataTree(name);
-        checkArgument(schema instanceof AnyxmlSchemaNode, "Node %s is not anyxml", schema);
-        schemaStack.push(schema);
-    }
-
-    public void startAnydataNode(final NodeIdentifier name) {
-        final SchemaNode schema = enterDataTree(name);
-        checkArgument(schema instanceof AnydataSchemaNode, "Node %s is not anydata", schema);
-        schemaStack.push(schema);
-    }
-
-    public Object endNode() {
-        final Object ret = schemaStack.pop();
-        // If this is a data tree node, make sure it is updated. Before that, though, we need to check if this is not
-        // actually listEntry -> list or leafListEntry -> leafList exit.
-        if (!(ret instanceof AugmentationSchemaNode) && getParent() != ret) {
-            dataTree.exit();
-        }
-        return ret;
-    }
 }