Remove NormalizedNodePruner

[controller.git] / opendaylight / md-sal / sal-clustering-commons / src / main / java / org / opendaylight / controller / cluster / datastore / node / utils / transformer / AbstractNormalizedNodePruner.java

diff --git a/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/transformer/AbstractNormalizedNodePruner.java b/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/transformer/AbstractNormalizedNodePruner.java
index c3628ad1e8208eab7c85485b78824e94f8688f4f..f0ef49645a66954b4e15f5d393c1abe40be9ec7a 100644 (file)
--- a/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/transformer/AbstractNormalizedNodePruner.java
+++ b/opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/transformer/AbstractNormalizedNodePruner.java
@@ -8,6 +8,7 @@
 package org.opendaylight.controller.cluster.datastore.node.utils.transformer;
 
 import static com.google.common.base.Preconditions.checkState;
+import static com.google.common.base.Verify.verify;
 import static java.util.Objects.requireNonNull;
 
 import java.io.IOException;
@@ -44,13 +45,13 @@ abstract class AbstractNormalizedNodePruner implements NormalizedNodeStreamWrite
     }
 
     @FunctionalInterface
-    private interface WriterMethod<T extends PathArgument> {
+    interface WriterMethod<T extends PathArgument> {
 
         void apply(ReusableImmutableNormalizedNodeStreamWriter writer, T name) throws IOException;
     }
 
     @FunctionalInterface
-    private interface SizedWriterMethod<T extends PathArgument> {
+    interface SizedWriterMethod<T extends PathArgument> {
 
         void apply(ReusableImmutableNormalizedNodeStreamWriter writer, T name, int childSizeHint) throws IOException;
     }
@@ -63,12 +64,10 @@ abstract class AbstractNormalizedNodePruner implements NormalizedNodeStreamWrite
     private final DataSchemaContextTree tree;
 
     private DataSchemaContextNode<?> nodePathSchemaNode;
+    private NormalizedNode<?, ?> normalizedNode;
     private State state = State.UNITIALIZED;
     private int unknown;
 
-    // FIXME: package-private to support unguarded NormalizedNodePruner access
-    NormalizedNode<?, ?> normalizedNode;
-
     AbstractNormalizedNodePruner(final DataSchemaContextTree tree) {
         this.tree = requireNonNull(tree);
     }
@@ -91,17 +90,17 @@ abstract class AbstractNormalizedNodePruner implements NormalizedNodeStreamWrite
     }
 
     @Override
-    public void startLeafNode(final NodeIdentifier name) throws IOException {
+    public final void startLeafNode(final NodeIdentifier name) throws IOException {
         enter(ReusableImmutableNormalizedNodeStreamWriter::startLeafNode, name);
     }
 
     @Override
-    public void startLeafSet(final NodeIdentifier name, final int childSizeHint) throws IOException {
+    public final void startLeafSet(final NodeIdentifier name, final int childSizeHint) throws IOException {
         enter(ReusableImmutableNormalizedNodeStreamWriter::startLeafSet, name, childSizeHint);
     }
 
     @Override
-    public void startOrderedLeafSet(final NodeIdentifier name, final int childSizeHint) throws IOException {
+    public final void startOrderedLeafSet(final NodeIdentifier name, final int childSizeHint) throws IOException {
         enter(ReusableImmutableNormalizedNodeStreamWriter::startOrderedLeafSet, name, childSizeHint);
     }
 
@@ -111,28 +110,28 @@ abstract class AbstractNormalizedNodePruner implements NormalizedNodeStreamWrite
     }
 
     @Override
-    public void startContainerNode(final NodeIdentifier name, final int childSizeHint) throws IOException {
+    public final void startContainerNode(final NodeIdentifier name, final int childSizeHint) throws IOException {
         enter(ReusableImmutableNormalizedNodeStreamWriter::startContainerNode, name, childSizeHint);
     }
 
     @Override
-    public void startYangModeledAnyXmlNode(final NodeIdentifier nodeIdentifier, final int count) {
+    public final void startYangModeledAnyXmlNode(final NodeIdentifier nodeIdentifier, final int count) {
         // FIXME: implement this
         throw new UnsupportedOperationException("Not implemented yet");
     }
 
     @Override
-    public void startUnkeyedList(final NodeIdentifier name, final int childSizeHint) throws IOException {
+    public final void startUnkeyedList(final NodeIdentifier name, final int childSizeHint) throws IOException {
         enter(ReusableImmutableNormalizedNodeStreamWriter::startUnkeyedList, name, childSizeHint);
     }
 
     @Override
-    public void startUnkeyedListItem(final NodeIdentifier name, final int childSizeHint) throws IOException {
+    public final void startUnkeyedListItem(final NodeIdentifier name, final int childSizeHint) throws IOException {
         enter(ReusableImmutableNormalizedNodeStreamWriter::startUnkeyedListItem, name, childSizeHint);
     }
 
     @Override
-    public void startMapNode(final NodeIdentifier name, final int childSizeHint) throws IOException {
+    public final void startMapNode(final NodeIdentifier name, final int childSizeHint) throws IOException {
         enter(ReusableImmutableNormalizedNodeStreamWriter::startMapNode, name, childSizeHint);
     }
 
@@ -143,27 +142,37 @@ abstract class AbstractNormalizedNodePruner implements NormalizedNodeStreamWrite
     }
 
     @Override
-    public void startOrderedMapNode(final NodeIdentifier name, final int childSizeHint) throws IOException {
+    public final void startOrderedMapNode(final NodeIdentifier name, final int childSizeHint) throws IOException {
         enter(ReusableImmutableNormalizedNodeStreamWriter::startOrderedMapNode, name, childSizeHint);
     }
 
     @Override
-    public void startChoiceNode(final NodeIdentifier name, final int childSizeHint) throws IOException {
+    public final void startChoiceNode(final NodeIdentifier name, final int childSizeHint) throws IOException {
         enter(ReusableImmutableNormalizedNodeStreamWriter::startChoiceNode, name, childSizeHint);
     }
 
     @Override
-    public void startAugmentationNode(final AugmentationIdentifier identifier) throws IOException {
+    public final void startAugmentationNode(final AugmentationIdentifier identifier) throws IOException {
         enter(ReusableImmutableNormalizedNodeStreamWriter::startAugmentationNode, identifier);
     }
 
     @Override
-    public void startAnyxmlNode(final NodeIdentifier name) throws IOException {
-        enter(ReusableImmutableNormalizedNodeStreamWriter::startAnyxmlNode, name);
+    public final  boolean startAnyxmlNode(final NodeIdentifier name, final Class<?> objectModel) throws IOException {
+        if (enter(name)) {
+            verify(delegate.startAnyxmlNode(name, objectModel),
+                "Unexpected failure to stream DOMSource node %s model %s", name, objectModel);
+        }
+        return true;
     }
 
     @Override
-    public void domSourceValue(final DOMSource value) throws IOException {
+    public final boolean startAnydataNode(final NodeIdentifier name, final Class<?> objectModel) throws IOException {
+        // FIXME: we do not support anydata nodes yet
+        return false;
+    }
+
+    @Override
+    public final  void domSourceValue(final DOMSource value) throws IOException {
         checkNotSealed();
         if (unknown == 0) {
             delegate.domSourceValue(value);
@@ -171,10 +180,10 @@ abstract class AbstractNormalizedNodePruner implements NormalizedNodeStreamWrite
     }
 
     @Override
-    public void scalarValue(final Object value) throws IOException {
+    public final void scalarValue(final Object value) throws IOException {
         checkNotSealed();
         if (unknown == 0) {
-            delegate.scalarValue(translateScalar(stack.peek(), value));
+            delegate.scalarValue(translateScalar(currentSchema(), value));
         }
     }
 
@@ -184,7 +193,7 @@ abstract class AbstractNormalizedNodePruner implements NormalizedNodeStreamWrite
     }
 
     @Override
-    public void endNode() throws IOException {
+    public final void endNode() throws IOException {
         checkNotSealed();
 
         if (unknown == 0) {
@@ -209,14 +218,14 @@ abstract class AbstractNormalizedNodePruner implements NormalizedNodeStreamWrite
     }
 
     @Override
-    public void close() throws IOException {
+    public final void close() throws IOException {
         state = State.CLOSED;
         stack.clear();
         delegate.close();
     }
 
     @Override
-    public void flush() throws IOException {
+    public final void flush() throws IOException {
         delegate.flush();
     }
 
@@ -245,7 +254,7 @@ abstract class AbstractNormalizedNodePruner implements NormalizedNodeStreamWrite
         }
 
         final DataSchemaContextNode<?> schema;
-        final DataSchemaContextNode<?> parent = stack.peek();
+        final DataSchemaContextNode<?> parent = currentSchema();
         if (parent != null) {
             schema = parent.getChild(name);
         } else {
@@ -266,16 +275,20 @@ abstract class AbstractNormalizedNodePruner implements NormalizedNodeStreamWrite
         return true;
     }
 
-    private <A extends PathArgument> void enter(final WriterMethod<A> method, final A name) throws IOException {
+    final <A extends PathArgument> void enter(final WriterMethod<A> method, final A name) throws IOException {
         if (enter(name)) {
             method.apply(delegate, name);
         }
     }
 
-    private <A extends PathArgument> void enter(final SizedWriterMethod<A> method, final A name, final int size)
+    final <A extends PathArgument> void enter(final SizedWriterMethod<A> method, final A name, final int size)
             throws IOException {
         if (enter(name)) {
             method.apply(delegate, name, size);
         }
     }
+
+    final DataSchemaContextNode<?> currentSchema() {
+        return stack.peek();
+    }
 }