Bug 5019: Add QName param to NormalizedNodeWriter#leafSetEntryNode

[yangtools.git] / yang / yang-data-impl / src / main / java / org / opendaylight / yangtools / yang / data / impl / schema / ImmutableNormalizedNodeStreamWriter.java

diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/ImmutableNormalizedNodeStreamWriter.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/ImmutableNormalizedNodeStreamWriter.java
index c97819bb381c6b355b9ad8fd0662eedca27e1ca2..73202be3eea184bbe59fbbca57dd7f229f390a02 100644 (file)
--- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/ImmutableNormalizedNodeStreamWriter.java
+++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/ImmutableNormalizedNodeStreamWriter.java
@@ -11,12 +11,14 @@ import com.google.common.base.Preconditions;
 import java.util.ArrayDeque;
 import java.util.Collection;
 import java.util.Deque;
+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.NodeIdentifierWithPredicates;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
 import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
+import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
@@ -24,7 +26,9 @@ import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
 import org.opendaylight.yangtools.yang.data.api.schema.OrderedMapNode;
 import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
 import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode;
+import org.opendaylight.yangtools.yang.data.api.schema.YangModeledAnyXmlNode;
 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
+import org.opendaylight.yangtools.yang.data.api.schema.stream.SchemaAwareNormalizedNodeStreamWriter;
 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
@@ -37,9 +41,15 @@ import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableCo
 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetNodeBuilder;
 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableMapEntryNodeBuilder;
 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableMapNodeBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableOrderedLeafSetNodeBuilder;
 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableOrderedMapNodeBuilder;
 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableUnkeyedListEntryNodeBuilder;
 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableUnkeyedListNodeBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableYangModeledAnyXmlNodeBuilder;
+import org.opendaylight.yangtools.yang.data.util.LeafInterner;
+import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.YangModeledAnyXmlSchemaNode;
 
 /**
  *
@@ -54,16 +64,21 @@ import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableUn
  *
  *
  */
-public class ImmutableNormalizedNodeStreamWriter implements NormalizedNodeStreamWriter {
+public class ImmutableNormalizedNodeStreamWriter implements SchemaAwareNormalizedNodeStreamWriter {
 
     @SuppressWarnings("rawtypes")
     private final Deque<NormalizedNodeContainerBuilder> builders = new ArrayDeque<>();
+    private DataSchemaNode nextSchema;
 
     @SuppressWarnings("rawtypes")
-    private ImmutableNormalizedNodeStreamWriter( final NormalizedNodeContainerBuilder topLevelBuilder) {
+    protected ImmutableNormalizedNodeStreamWriter(final NormalizedNodeContainerBuilder topLevelBuilder) {
         builders.push(topLevelBuilder);
     }
 
+    protected ImmutableNormalizedNodeStreamWriter(final NormalizedNodeResult result) {
+        this(new NormalizedNodeResultBuilder(result));
+    }
+
     /**
      * Creates a {@link NormalizedNodeStreamWriter} which creates instances of supplied
      * {@link NormalizedNode}s and writes them to supplied builder as child nodes.
@@ -80,7 +95,6 @@ public class ImmutableNormalizedNodeStreamWriter implements NormalizedNodeStream
     }
 
     /**
-     *
      * Creates a {@link NormalizedNodeStreamWriter} which creates one instance of top
      * level {@link NormalizedNode} (type of NormalizedNode) is determined by first
      * start event.
@@ -99,10 +113,9 @@ public class ImmutableNormalizedNodeStreamWriter implements NormalizedNodeStream
      * @return {@link NormalizedNodeStreamWriter} which will write item to supplied result holder.
      */
     public static final NormalizedNodeStreamWriter from(final NormalizedNodeResult result) {
-        return new ImmutableNormalizedNodeStreamWriter(new NormalizedNodeResultBuilder(result));
+        return new ImmutableNormalizedNodeStreamWriter(result);
     }
 
-
     @SuppressWarnings("rawtypes")
     private NormalizedNodeContainerBuilder getCurrent() {
         return builders.peek();
@@ -111,10 +124,11 @@ public class ImmutableNormalizedNodeStreamWriter implements NormalizedNodeStream
     @SuppressWarnings("rawtypes")
     private void enter(final NormalizedNodeContainerBuilder next) {
         builders.push(next);
+        nextSchema = null;
     }
 
     @SuppressWarnings("unchecked")
-    private void writeChild(final NormalizedNode<?, ?> child) {
+    protected void writeChild(final NormalizedNode<?, ?> child) {
         getCurrent().addChild(child);
     }
 
@@ -123,42 +137,72 @@ public class ImmutableNormalizedNodeStreamWriter implements NormalizedNodeStream
     public void endNode() {
         final NormalizedNodeContainerBuilder finishedBuilder = builders.poll();
         Preconditions.checkState(finishedBuilder != null, "Node which should be closed does not exists.");
-        NormalizedNodeContainerBuilder current = getCurrent();
+        final NormalizedNodeContainerBuilder current = getCurrent();
         Preconditions.checkState(current != null, "Reached top level node, which could not be closed in this writer.");
-        NormalizedNode<PathArgument, ?> product = finishedBuilder.build();
+        final NormalizedNode<PathArgument, ?> product = finishedBuilder.build();
         current.addChild(product);
+        nextSchema = null;
     }
 
     @Override
-    public void leafNode(final NodeIdentifier name, final Object value) throws IllegalArgumentException {
+    public void leafNode(final NodeIdentifier name, final Object value) {
         checkDataNodeContainer();
-        writeChild(ImmutableNodes.leafNode(name, value));
+
+        final LeafNode<Object> sample = ImmutableNodes.leafNode(name, value);
+        final LeafNode<Object> node;
+        if (nextSchema instanceof LeafSchemaNode) {
+            node = LeafInterner.forSchema((LeafSchemaNode)nextSchema).intern(sample);
+        } else {
+            node = sample;
+        }
+
+        writeChild(node);
+        nextSchema = null;
     }
 
     @Override
-    public void startLeafSet(final NodeIdentifier name, final int childSizeHint) throws IllegalArgumentException {
+    public void startLeafSet(final NodeIdentifier name, final int childSizeHint) {
         checkDataNodeContainer();
-        ListNodeBuilder<Object, LeafSetEntryNode<Object>> builder = UNKNOWN_SIZE == childSizeHint ?
-                ImmutableLeafSetNodeBuilder.create() : ImmutableLeafSetNodeBuilder.create(childSizeHint);
+        final ListNodeBuilder<Object, LeafSetEntryNode<Object>> builder = UNKNOWN_SIZE == childSizeHint ?
+                InterningLeafSetNodeBuilder.create(nextSchema) :
+                    InterningLeafSetNodeBuilder.create(nextSchema, childSizeHint);
         builder.withNodeIdentifier(name);
         enter(builder);
     }
 
     @Override
-    public void leafSetEntryNode(final Object value) throws IllegalArgumentException {
-        Preconditions.checkArgument(getCurrent() instanceof ImmutableLeafSetNodeBuilder<?>);
-        @SuppressWarnings("unchecked")
-        ListNodeBuilder<Object, LeafSetEntryNode<Object>> builder = ((ImmutableLeafSetNodeBuilder<Object>) getCurrent());
-        builder.withChildValue(value);
+    public void leafSetEntryNode(final QName name, final Object value) {
+        if (getCurrent() instanceof ImmutableOrderedLeafSetNodeBuilder) {
+            @SuppressWarnings("unchecked")
+            ListNodeBuilder<Object, LeafSetEntryNode<Object>> builder = ((ImmutableOrderedLeafSetNodeBuilder<Object>) getCurrent());
+            builder.withChildValue(value);
+        } else if (getCurrent() instanceof ImmutableLeafSetNodeBuilder) {
+            @SuppressWarnings("unchecked")
+            ListNodeBuilder<Object, LeafSetEntryNode<Object>> builder = ((ImmutableLeafSetNodeBuilder<Object>) getCurrent());
+            builder.withChildValue(value);
+        } else {
+            throw new IllegalArgumentException("LeafSetEntryNode is not valid for parent " + getCurrent());
+        }
+
+        nextSchema = null;
+    }
+
+    @Override
+    public void startOrderedLeafSet(final NodeIdentifier name, final int childSizeHint) {
+        checkDataNodeContainer();
+        final ListNodeBuilder<Object, LeafSetEntryNode<Object>> builder = Builders.orderedLeafSetBuilder();
+        builder.withNodeIdentifier(name);
+        enter(builder);
     }
 
     @Override
-    public void anyxmlNode(final NodeIdentifier name, final Object value) throws IllegalArgumentException {
+    public void anyxmlNode(final NodeIdentifier name, final Object value) {
         checkDataNodeContainer();
+        nextSchema = null;
     }
 
     @Override
-    public void startContainerNode(final NodeIdentifier name, final int childSizeHint) throws IllegalArgumentException {
+    public void startContainerNode(final NodeIdentifier name, final int childSizeHint) {
         checkDataNodeContainer();
 
         final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> builder = UNKNOWN_SIZE == childSizeHint ?
@@ -167,7 +211,19 @@ public class ImmutableNormalizedNodeStreamWriter implements NormalizedNodeStream
     }
 
     @Override
-    public void startUnkeyedList(final NodeIdentifier name, final int childSizeHint) throws IllegalArgumentException {
+    public void startYangModeledAnyXmlNode(final NodeIdentifier name, final int childSizeHint) {
+        checkDataNodeContainer();
+
+        Preconditions.checkArgument(nextSchema instanceof YangModeledAnyXmlSchemaNode,
+                "Schema of this node should be instance of YangModeledAnyXmlSchemaNode");
+        final DataContainerNodeAttrBuilder<NodeIdentifier, YangModeledAnyXmlNode> builder = UNKNOWN_SIZE == childSizeHint ? ImmutableYangModeledAnyXmlNodeBuilder
+                .create((YangModeledAnyXmlSchemaNode) nextSchema) : ImmutableYangModeledAnyXmlNodeBuilder.create(
+                (YangModeledAnyXmlSchemaNode) nextSchema, childSizeHint);
+        enter(builder.withNodeIdentifier(name));
+    }
+
+    @Override
+    public void startUnkeyedList(final NodeIdentifier name, final int childSizeHint) {
         checkDataNodeContainer();
 
         final CollectionNodeBuilder<UnkeyedListEntryNode, UnkeyedListNode> builder = UNKNOWN_SIZE == childSizeHint ?
@@ -176,16 +232,16 @@ public class ImmutableNormalizedNodeStreamWriter implements NormalizedNodeStream
     }
 
     @Override
-    public void startUnkeyedListItem(final NodeIdentifier name, final int childSizeHint) throws IllegalStateException {
-        Preconditions.checkArgument(getCurrent() instanceof ImmutableUnkeyedListNodeBuilder);
-
+    public void startUnkeyedListItem(final NodeIdentifier name, final int childSizeHint) {
+        Preconditions.checkArgument((getCurrent() instanceof NormalizedNodeResultBuilder)
+                || getCurrent() instanceof ImmutableUnkeyedListNodeBuilder);
         final DataContainerNodeAttrBuilder<NodeIdentifier, UnkeyedListEntryNode> builder = UNKNOWN_SIZE == childSizeHint ?
                 ImmutableUnkeyedListEntryNodeBuilder.create() : ImmutableUnkeyedListEntryNodeBuilder.create(childSizeHint);
         enter(builder.withNodeIdentifier(name));
     }
 
     @Override
-    public void startMapNode(final NodeIdentifier name, final int childSizeHint) throws IllegalArgumentException {
+    public void startMapNode(final NodeIdentifier name, final int childSizeHint) {
         checkDataNodeContainer();
 
         final CollectionNodeBuilder<MapEntryNode, MapNode> builder = UNKNOWN_SIZE == childSizeHint ?
@@ -194,7 +250,7 @@ public class ImmutableNormalizedNodeStreamWriter implements NormalizedNodeStream
     }
 
     @Override
-    public void startMapEntryNode(final NodeIdentifierWithPredicates identifier, final int childSizeHint) throws IllegalArgumentException {
+    public void startMapEntryNode(final NodeIdentifierWithPredicates identifier, final int childSizeHint) {
         if(!(getCurrent() instanceof NormalizedNodeResultBuilder)) {
             Preconditions.checkArgument(getCurrent() instanceof ImmutableMapNodeBuilder || getCurrent() instanceof ImmutableOrderedMapNodeBuilder);
         }
@@ -205,7 +261,7 @@ public class ImmutableNormalizedNodeStreamWriter implements NormalizedNodeStream
     }
 
     @Override
-    public void startOrderedMapNode(final NodeIdentifier name, final int childSizeHint) throws IllegalArgumentException {
+    public void startOrderedMapNode(final NodeIdentifier name, final int childSizeHint) {
         checkDataNodeContainer();
 
         final CollectionNodeBuilder<MapEntryNode, OrderedMapNode> builder = UNKNOWN_SIZE == childSizeHint ?
@@ -214,7 +270,7 @@ public class ImmutableNormalizedNodeStreamWriter implements NormalizedNodeStream
     }
 
     @Override
-    public void startChoiceNode(final NodeIdentifier name, final int childSizeHint) throws IllegalArgumentException {
+    public void startChoiceNode(final NodeIdentifier name, final int childSizeHint) {
         checkDataNodeContainer();
 
         final DataContainerNodeBuilder<NodeIdentifier, ChoiceNode> builder = UNKNOWN_SIZE == childSizeHint ?
@@ -223,7 +279,7 @@ public class ImmutableNormalizedNodeStreamWriter implements NormalizedNodeStream
     }
 
     @Override
-    public void startAugmentationNode(final AugmentationIdentifier identifier) throws IllegalArgumentException {
+    public void startAugmentationNode(final AugmentationIdentifier identifier) {
         checkDataNodeContainer();
         Preconditions.checkArgument(!(getCurrent() instanceof ImmutableAugmentationNodeBuilder));
         enter(Builders.augmentationBuilder().withNodeIdentifier(identifier));
@@ -231,9 +287,10 @@ public class ImmutableNormalizedNodeStreamWriter implements NormalizedNodeStream
 
     private void checkDataNodeContainer() {
         @SuppressWarnings("rawtypes")
+        final
         NormalizedNodeContainerBuilder current = getCurrent();
-        if(!(current instanceof NormalizedNodeResultBuilder)) {
-        Preconditions.checkArgument(current instanceof DataContainerNodeBuilder<?, ?>, "Invalid nesting of data.");
+        if (!(current instanceof NormalizedNodeResultBuilder)) {
+            Preconditions.checkArgument(current instanceof DataContainerNodeBuilder<?, ?>, "Invalid nesting of data.");
         }
     }
 
@@ -288,4 +345,9 @@ public class ImmutableNormalizedNodeStreamWriter implements NormalizedNodeStream
     public void close() {
         // no-op
     }
+
+    @Override
+    public void nextDataSchemaNode(final DataSchemaNode schema) {
+        nextSchema = Preconditions.checkNotNull(schema);
+    }
 }