Rename NormalizedNodeInferenceStack

This name is not accurate, as the inputs are not really inference,
but are driven by NormalizedNodeStreamWriter.
NormalizedNodeStreamWriterStack is a tad more accurate, preventing
confusion.

JIRA: YANGTOOLS-1247
Change-Id: I4a498526fa34c7df261978b23ef7b4d4c8d49d93
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 b8e574f2becbafde033e821eb794bf90d9e8c835..67e4c1f1b045225fe549b127a5b30f83a710aff1 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.util.NormalizedNodeInferenceStack;
+import org.opendaylight.yangtools.yang.data.util.NormalizedNodeStreamWriterStack;
 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,7 +54,7 @@ import org.w3c.dom.Text;
 public abstract class JSONNormalizedNodeStreamWriter implements NormalizedNodeStreamWriter,
         StreamWriterMountPointExtension {
     private static final class Exclusive extends JSONNormalizedNodeStreamWriter {
-        Exclusive(final JSONCodecFactory codecFactory, final NormalizedNodeInferenceStack tracker,
+        Exclusive(final JSONCodecFactory codecFactory, final NormalizedNodeStreamWriterStack tracker,
                 final JsonWriter writer, final JSONStreamWriterRootContext rootContext) {
             super(codecFactory, tracker, writer, rootContext);
         }
@@ -67,8 +67,8 @@ public abstract class JSONNormalizedNodeStreamWriter implements NormalizedNodeSt
     }
 
     private static final class Nested extends JSONNormalizedNodeStreamWriter {
-        Nested(final JSONCodecFactory codecFactory, final NormalizedNodeInferenceStack tracker, final JsonWriter writer,
-                final JSONStreamWriterRootContext rootContext) {
+        Nested(final JSONCodecFactory codecFactory, final NormalizedNodeStreamWriterStack 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 NormalizedNodeInferenceStack tracker;
+    private final NormalizedNodeStreamWriterStack tracker;
     private final JSONCodecFactory codecs;
     private final JsonWriter writer;
     private JSONStreamWriterContext context;
 
-    JSONNormalizedNodeStreamWriter(final JSONCodecFactory codecFactory, final NormalizedNodeInferenceStack tracker,
+    JSONNormalizedNodeStreamWriter(final JSONCodecFactory codecFactory, final NormalizedNodeStreamWriterStack tracker,
             final JsonWriter writer, final JSONStreamWriterRootContext rootContext) {
         this.writer = requireNonNull(writer);
         this.codecs = requireNonNull(codecFactory);
@@ -130,7 +130,7 @@ 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,
-            NormalizedNodeInferenceStack.of(codecFactory.getEffectiveModelContext(), path), jsonWriter,
+            NormalizedNodeStreamWriterStack.of(codecFactory.getEffectiveModelContext(), path), jsonWriter,
             new JSONStreamWriterExclusiveRootContext(initialNs));
     }
 
@@ -157,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, NormalizedNodeInferenceStack.of(rootNode), jsonWriter,
+        return new Exclusive(codecFactory, NormalizedNodeStreamWriterStack.of(rootNode), jsonWriter,
             new JSONStreamWriterExclusiveRootContext(initialNs));
     }
 
@@ -185,7 +185,7 @@ 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,
-            NormalizedNodeInferenceStack.of(codecFactory.getEffectiveModelContext(), path), jsonWriter,
+            NormalizedNodeStreamWriterStack.of(codecFactory.getEffectiveModelContext(), path), jsonWriter,
             new JSONStreamWriterExclusiveRootContext(initialNs));
     }
 
@@ -210,8 +210,9 @@ 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, NormalizedNodeInferenceStack.of(codecFactory.getEffectiveModelContext(), path),
-            jsonWriter, new JSONStreamWriterSharedRootContext(initialNs));
+        return new Nested(codecFactory,
+            NormalizedNodeStreamWriterStack.of(codecFactory.getEffectiveModelContext(), path), jsonWriter,
+            new JSONStreamWriterSharedRootContext(initialNs));
     }
 
     /**
@@ -235,8 +236,9 @@ 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, NormalizedNodeInferenceStack.of(codecFactory.getEffectiveModelContext(), path),
-            jsonWriter, new JSONStreamWriterSharedRootContext(initialNs));
+        return new Nested(codecFactory,
+            NormalizedNodeStreamWriterStack.of(codecFactory.getEffectiveModelContext(), path), jsonWriter,
+            new JSONStreamWriterSharedRootContext(initialNs));
     }
 
     /**
@@ -260,7 +262,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, NormalizedNodeInferenceStack.of(rootNode), jsonWriter,
+        return new Nested(codecFactory, NormalizedNodeStreamWriterStack.of(rootNode), jsonWriter,
             new JSONStreamWriterSharedRootContext(initialNs));
     }
 
@@ -365,7 +367,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), NormalizedNodeInferenceStack.of(ctx), writer,
+        return new Nested(codecs.rebaseTo(ctx), NormalizedNodeStreamWriterStack.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 70325a87f6dced4c93aab846730208c8d4eef5f1..54be0c26226856214a65f09a396760299e56e7f8 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.util.NormalizedNodeInferenceStack;
+import org.opendaylight.yangtools.yang.data.util.NormalizedNodeStreamWriterStack;
 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 NormalizedNodeInferenceStack tracker;
+    private final NormalizedNodeStreamWriterStack tracker;
     private final SchemaAwareXMLStreamWriterUtils streamUtils;
 
     SchemaAwareXMLStreamNormalizedNodeStreamWriter(final XMLStreamWriter writer, final EffectiveModelContext context,
-            final NormalizedNodeInferenceStack tracker) {
+            final NormalizedNodeStreamWriterStack 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 f0b688cd14c20abffa91b42629df9c5321c88e6f..3cb9b3865c94053cee2ddf962cc48d75e640fe17 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.util.NormalizedNodeInferenceStack;
+import org.opendaylight.yangtools.yang.data.util.NormalizedNodeStreamWriterStack;
 import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
 import org.opendaylight.yangtools.yang.model.api.EffectiveStatementInference;
 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
@@ -72,7 +72,7 @@ public abstract class XMLStreamNormalizedNodeStreamWriter<T> implements Normaliz
     public static @NonNull NormalizedNodeStreamWriter create(final XMLStreamWriter writer,
             final EffectiveModelContext context) {
         return new SchemaAwareXMLStreamNormalizedNodeStreamWriter(writer, context,
-            NormalizedNodeInferenceStack.of(context));
+            NormalizedNodeStreamWriterStack.of(context));
     }
 
     /**
@@ -85,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(),
-            NormalizedNodeInferenceStack.of(inference));
+            NormalizedNodeStreamWriterStack.of(inference));
     }
 
     /**
@@ -99,7 +99,7 @@ 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,
-            NormalizedNodeInferenceStack.of(context, path));
+            NormalizedNodeStreamWriterStack.of(context, path));
     }
 
     /**
@@ -113,7 +113,7 @@ 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,
-            NormalizedNodeInferenceStack.of(context, path));
+            NormalizedNodeStreamWriterStack.of(context, path));
     }
 
     /**
@@ -147,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,
-            NormalizedNodeInferenceStack.ofOperation(context, operationPath, qname));
+            NormalizedNodeStreamWriterStack.ofOperation(context, operationPath, qname));
     }
 
     /**

diff --git a/yang/yang-data-util/src/main/java/org/opendaylight/yangtools/yang/data/util/NormalizedNodeInferenceStack.java b/yang/yang-data-util/src/main/java/org/opendaylight/yangtools/yang/data/util/NormalizedNodeStreamWriterStack.java
similarity index 89%
rename from yang/yang-data-util/src/main/java/org/opendaylight/yangtools/yang/data/util/NormalizedNodeInferenceStack.java
rename to yang/yang-data-util/src/main/java/org/opendaylight/yangtools/yang/data/util/NormalizedNodeStreamWriterStack.java
index bd9a981b030d48b7130b115648a28677622b4731..3b35e13c60437487aee35fd602651d4991dedae1 100644 (file)
--- a/yang/yang-data-util/src/main/java/org/opendaylight/yangtools/yang/data/util/NormalizedNodeInferenceStack.java
+++ b/yang/yang-data-util/src/main/java/org/opendaylight/yangtools/yang/data/util/NormalizedNodeStreamWriterStack.java
@@ -62,19 +62,19 @@ import org.slf4j.LoggerFactory;
  * Utility class for tracking schema state underlying a {@link NormalizedNode} structure.
  */
 @Beta
-public final class NormalizedNodeInferenceStack implements Mutable {
-    private static final Logger LOG = LoggerFactory.getLogger(NormalizedNodeInferenceStack.class);
+public final class NormalizedNodeStreamWriterStack implements Mutable {
+    private static final Logger LOG = LoggerFactory.getLogger(NormalizedNodeStreamWriterStack.class);
 
     private final Deque<WithStatus> schemaStack = new ArrayDeque<>();
     private final SchemaInferenceStack dataTree;
     private final DataNodeContainer root;
 
-    private NormalizedNodeInferenceStack(final EffectiveModelContext context) {
+    private NormalizedNodeStreamWriterStack(final EffectiveModelContext context) {
         root = requireNonNull(context);
         dataTree = SchemaInferenceStack.of(context);
     }
 
-    private NormalizedNodeInferenceStack(final SchemaInferenceStack dataTree) {
+    private NormalizedNodeStreamWriterStack(final SchemaInferenceStack dataTree) {
         this.dataTree = requireNonNull(dataTree);
         if (!dataTree.isEmpty()) {
             final EffectiveStatement<?, ?> current = dataTree.currentStatement();
@@ -93,8 +93,8 @@ public final class NormalizedNodeInferenceStack implements Mutable {
      * @return A new {@link NormalizedNodeStreamWriter}
      * @throws NullPointerException if {@code root} is null
      */
-    public static @NonNull NormalizedNodeInferenceStack of(final EffectiveStatementInference root) {
-        return new NormalizedNodeInferenceStack(SchemaInferenceStack.ofInference(root));
+    public static @NonNull NormalizedNodeStreamWriterStack of(final EffectiveStatementInference root) {
+        return new NormalizedNodeStreamWriterStack(SchemaInferenceStack.ofInference(root));
     }
 
     /**
@@ -104,8 +104,8 @@ public final class NormalizedNodeInferenceStack implements Mutable {
      * @return A new {@link NormalizedNodeStreamWriter}
      * @throws NullPointerException if {@code root} is null
      */
-    public static @NonNull NormalizedNodeInferenceStack of(final Inference root) {
-        return new NormalizedNodeInferenceStack(root.toSchemaInferenceStack());
+    public static @NonNull NormalizedNodeStreamWriterStack of(final Inference root) {
+        return new NormalizedNodeStreamWriterStack(root.toSchemaInferenceStack());
     }
 
     /**
@@ -115,8 +115,8 @@ public final class NormalizedNodeInferenceStack implements Mutable {
      * @return A new {@link NormalizedNodeStreamWriter}
      * @throws NullPointerException if {@code context} is null
      */
-    public static @NonNull NormalizedNodeInferenceStack of(final EffectiveModelContext context) {
-        return new NormalizedNodeInferenceStack(context);
+    public static @NonNull NormalizedNodeStreamWriterStack of(final EffectiveModelContext context) {
+        return new NormalizedNodeStreamWriterStack(context);
     }
 
     /**
@@ -124,12 +124,13 @@ public final class NormalizedNodeInferenceStack implements Mutable {
      *
      * @param context Associated {@link EffectiveModelContext}
      * @param path schema path
-     * @return A new {@link NormalizedNodeInferenceStack}
+     * @return A new {@link NormalizedNodeStreamWriterStack}
      * @throws NullPointerException if any argument is null
      * @throws IllegalArgumentException if {@code path} does not point to a valid root
      */
-    public static @NonNull NormalizedNodeInferenceStack of(final EffectiveModelContext context, final Absolute path) {
-        return new NormalizedNodeInferenceStack(SchemaInferenceStack.of(context, path));
+    public static @NonNull NormalizedNodeStreamWriterStack of(final EffectiveModelContext context,
+            final Absolute path) {
+        return new NormalizedNodeStreamWriterStack(SchemaInferenceStack.of(context, path));
     }
 
     /**
@@ -137,13 +138,14 @@ public final class NormalizedNodeInferenceStack implements Mutable {
      *
      * @param context Associated {@link EffectiveModelContext}
      * @param path schema path
-     * @return A new {@link NormalizedNodeInferenceStack}
+     * @return A new {@link NormalizedNodeStreamWriterStack}
      * @throws NullPointerException if any argument is null
      * @throws IllegalArgumentException if {@code path} does not point to a valid root
      */
     @Deprecated
-    public static @NonNull NormalizedNodeInferenceStack of(final EffectiveModelContext context, final SchemaPath path) {
-        return new NormalizedNodeInferenceStack(SchemaInferenceStack.ofInstantiatedPath(context, path));
+    public static @NonNull NormalizedNodeStreamWriterStack of(final EffectiveModelContext context,
+            final SchemaPath path) {
+        return new NormalizedNodeStreamWriterStack(SchemaInferenceStack.ofInstantiatedPath(context, path));
     }
 
     /**
@@ -157,14 +159,14 @@ public final class NormalizedNodeInferenceStack implements Mutable {
      * @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 NormalizedNodeInferenceStack ofOperation(final EffectiveModelContext context,
+    public static @NonNull NormalizedNodeStreamWriterStack 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 NormalizedNodeInferenceStack(stack);
+        return new NormalizedNodeStreamWriterStack(stack);
     }
 
     /**