X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=yang%2Fyang-data-api%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fdata%2Fapi%2Fschema%2Fstream%2FNormalizedNodeWriter.java;h=be22c5091a1a7ef09b9f467b420cbe1e83d53fee;hb=82af449e4ef07d80490e79484d0402b81009541e;hp=7b567f6423bbbcf79d326ceee66f54c25b1187d6;hpb=c13036931c60458dfd78875ecd0ac3bb1610c7f6;p=yangtools.git

diff --git a/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/stream/NormalizedNodeWriter.java b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/stream/NormalizedNodeWriter.java
index 7b567f6423..be22c5091a 100644
--- a/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/stream/NormalizedNodeWriter.java
+++ b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/stream/NormalizedNodeWriter.java
@@ -32,9 +32,11 @@ import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.schema.OrderedLeafSetNode;
 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.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -48,7 +50,7 @@ import org.slf4j.LoggerFactory;
 public class NormalizedNodeWriter implements Closeable, Flushable {
     private final NormalizedNodeStreamWriter writer;
 
-    private NormalizedNodeWriter(final NormalizedNodeStreamWriter writer) {
+    protected NormalizedNodeWriter(final NormalizedNodeStreamWriter writer) {
         this.writer = Preconditions.checkNotNull(writer);
     }
 
@@ -93,10 +95,10 @@ public class NormalizedNodeWriter implements Closeable, Flushable {
      * events to the encapsulated {@link NormalizedNodeStreamWriter}.
      *
      * @param node Node
-     * @return
+     * @return NormalizedNodeWriter this
      * @throws IOException when thrown from the backing writer.
      */
-    public final NormalizedNodeWriter write(final NormalizedNode<?, ?> node) throws IOException {
+    public NormalizedNodeWriter write(final NormalizedNode<?, ?> node) throws IOException {
         if (wasProcessedAsCompositeNode(node)) {
             return this;
         }
@@ -127,22 +129,24 @@ public class NormalizedNodeWriter implements Closeable, Flushable {
      * @param children Child nodes
      * @return Best estimate of the collection size required to hold all the children.
      */
-    static final int childSizeHint(final Iterable<?> children) {
+    protected static int childSizeHint(final Iterable<?> children) {
         return (children instanceof Collection) ? ((Collection<?>) children).size() : UNKNOWN_SIZE;
     }
 
-    private boolean wasProcessAsSimpleNode(final NormalizedNode<?, ?> node) throws IOException {
+    protected boolean wasProcessAsSimpleNode(final NormalizedNode<?, ?> node) throws IOException {
         if (node instanceof LeafSetEntryNode) {
             final LeafSetEntryNode<?> nodeAsLeafList = (LeafSetEntryNode<?>)node;
-            if(writer instanceof NormalizedNodeStreamAttributeWriter) {
-                ((NormalizedNodeStreamAttributeWriter) writer).leafSetEntryNode(nodeAsLeafList.getValue(), nodeAsLeafList.getAttributes());
+            final QName name = nodeAsLeafList.getIdentifier().getNodeType();
+            if (writer instanceof NormalizedNodeStreamAttributeWriter) {
+                ((NormalizedNodeStreamAttributeWriter) writer).leafSetEntryNode(name, nodeAsLeafList.getValue(),
+                        nodeAsLeafList.getAttributes());
             } else {
-                writer.leafSetEntryNode(nodeAsLeafList.getValue());
+                writer.leafSetEntryNode(name, nodeAsLeafList.getValue());
             }
             return true;
         } else if (node instanceof LeafNode) {
             final LeafNode<?> nodeAsLeaf = (LeafNode<?>)node;
-            if(writer instanceof NormalizedNodeStreamAttributeWriter) {
+            if (writer instanceof NormalizedNodeStreamAttributeWriter) {
                 ((NormalizedNodeStreamAttributeWriter) writer).leafNode(nodeAsLeaf.getIdentifier(), nodeAsLeaf.getValue(), nodeAsLeaf.getAttributes());
             } else {
                 writer.leafNode(nodeAsLeaf.getIdentifier(), nodeAsLeaf.getValue());
@@ -164,8 +168,8 @@ public class NormalizedNodeWriter implements Closeable, Flushable {
      * @return True
      * @throws IOException when the writer reports it
      */
-    protected final boolean writeChildren(final Iterable<? extends NormalizedNode<?, ?>> children) throws IOException {
-        for (NormalizedNode<?, ?> child : children) {
+    protected boolean writeChildren(final Iterable<? extends NormalizedNode<?, ?>> children) throws IOException {
+        for (final NormalizedNode<?, ?> child : children) {
             write(child);
         }
 
@@ -174,7 +178,7 @@ public class NormalizedNodeWriter implements Closeable, Flushable {
     }
 
     protected boolean writeMapEntryNode(final MapEntryNode node) throws IOException {
-        if(writer instanceof NormalizedNodeStreamAttributeWriter) {
+        if (writer instanceof NormalizedNodeStreamAttributeWriter) {
             ((NormalizedNodeStreamAttributeWriter) writer)
                     .startMapEntryNode(node.getIdentifier(), childSizeHint(node.getValue()), node.getAttributes());
         } else {
@@ -183,16 +187,25 @@ public class NormalizedNodeWriter implements Closeable, Flushable {
         return writeChildren(node.getValue());
     }
 
-    private boolean wasProcessedAsCompositeNode(final NormalizedNode<?, ?> node) throws IOException {
+    protected boolean wasProcessedAsCompositeNode(final NormalizedNode<?, ?> node) throws IOException {
         if (node instanceof ContainerNode) {
             final ContainerNode n = (ContainerNode) node;
-            if(writer instanceof NormalizedNodeStreamAttributeWriter) {
+            if (writer instanceof NormalizedNodeStreamAttributeWriter) {
                 ((NormalizedNodeStreamAttributeWriter) writer).startContainerNode(n.getIdentifier(), childSizeHint(n.getValue()), n.getAttributes());
             } else {
                 writer.startContainerNode(n.getIdentifier(), childSizeHint(n.getValue()));
             }
             return writeChildren(n.getValue());
         }
+        if (node instanceof YangModeledAnyXmlNode) {
+            final YangModeledAnyXmlNode n = (YangModeledAnyXmlNode) node;
+            if (writer instanceof NormalizedNodeStreamAttributeWriter) {
+                ((NormalizedNodeStreamAttributeWriter) writer).startYangModeledAnyXmlNode(n.getIdentifier(), childSizeHint(n.getValue()), n.getAttributes());
+            } else {
+                writer.startYangModeledAnyXmlNode(n.getIdentifier(), childSizeHint(n.getValue()));
+            }
+            return writeChildren(n.getValue());
+        }
         if (node instanceof MapEntryNode) {
             return writeMapEntryNode((MapEntryNode) node);
         }
@@ -226,8 +239,12 @@ public class NormalizedNodeWriter implements Closeable, Flushable {
             writer.startMapNode(n.getIdentifier(), childSizeHint(n.getValue()));
             return writeChildren(n.getValue());
         }
+        if (node instanceof OrderedLeafSetNode) {
+            final LeafSetNode<?> n = (LeafSetNode<?>) node;
+            writer.startOrderedLeafSet(n.getIdentifier(), childSizeHint(n.getValue()));
+            return writeChildren(n.getValue());
+        }
         if (node instanceof LeafSetNode) {
-            //covers also OrderedLeafSetNode for which doesn't exist start* method
             final LeafSetNode<?> n = (LeafSetNode<?>) node;
             writer.startLeafSet(n.getIdentifier(), childSizeHint(n.getValue()));
             return writeChildren(n.getValue());
@@ -245,11 +262,16 @@ public class NormalizedNodeWriter implements Closeable, Flushable {
 
         @Override
         protected boolean writeMapEntryNode(final MapEntryNode node) throws IOException {
-            getWriter().startMapEntryNode(node.getIdentifier(), childSizeHint(node.getValue()));
+            final NormalizedNodeStreamWriter nnWriter = getWriter();
+            if (nnWriter instanceof NormalizedNodeStreamAttributeWriter) {
+                ((NormalizedNodeStreamAttributeWriter) nnWriter).startMapEntryNode(node.getIdentifier(), childSizeHint(node.getValue()), node.getAttributes());
+            } else {
+                nnWriter.startMapEntryNode(node.getIdentifier(), childSizeHint(node.getValue()));
+            }
 
             final Set<QName> qnames = node.getIdentifier().getKeyValues().keySet();
             // Write out all the key children
-            for (QName qname : qnames) {
+            for (final QName qname : qnames) {
                 final Optional<? extends NormalizedNode<?, ?>> child = node.getChild(new NodeIdentifier(qname));
                 if (child.isPresent()) {
                     write(child.get());