Allow startAnyxmlNode() to handle differing object models

[yangtools.git] / yang / yang-data-api / src / main / java / org / opendaylight / yangtools / yang / data / api / schema / stream / NormalizedNodeWriter.java

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 7a7bbf7a7eaba33c21bdd58d3fd5181a11ea2f6d..87aa4d680bcbd0c01efce22bbb48589a5aaf2fa9 100644 (file)
--- 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
@@ -7,6 +7,7 @@
  */
 package org.opendaylight.yangtools.yang.data.api.schema.stream;
 
+import static com.google.common.base.Verify.verify;
 import static java.util.Objects.requireNonNull;
 import static org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter.UNKNOWN_SIZE;
 
@@ -19,9 +20,12 @@ import java.util.Collection;
 import java.util.Optional;
 import java.util.Set;
 import javax.xml.stream.XMLStreamReader;
+import javax.xml.transform.dom.DOMSource;
+import org.eclipse.jdt.annotation.NonNull;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
+import org.opendaylight.yangtools.yang.data.api.schema.AnydataNode;
+import org.opendaylight.yangtools.yang.data.api.schema.AnyxmlNode;
 import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
 import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
@@ -47,7 +51,9 @@ import org.slf4j.LoggerFactory;
  */
 @Beta
 public class NormalizedNodeWriter implements Closeable, Flushable {
-    private final NormalizedNodeStreamWriter writer;
+    private static final Logger LOG = LoggerFactory.getLogger(NormalizedNodeWriter.class);
+
+    private final @NonNull NormalizedNodeStreamWriter writer;
 
     protected NormalizedNodeWriter(final NormalizedNodeStreamWriter writer) {
         this.writer = requireNonNull(writer);
@@ -131,27 +137,42 @@ public class NormalizedNodeWriter implements Closeable, Flushable {
     protected boolean wasProcessAsSimpleNode(final NormalizedNode<?, ?> node) throws IOException {
         if (node instanceof LeafSetEntryNode) {
             final LeafSetEntryNode<?> nodeAsLeafList = (LeafSetEntryNode<?>)node;
-            final QName name = nodeAsLeafList.getIdentifier().getNodeType();
-            if (writer instanceof NormalizedNodeStreamAttributeWriter) {
-                ((NormalizedNodeStreamAttributeWriter) writer).leafSetEntryNode(name, nodeAsLeafList.getValue(),
-                        nodeAsLeafList.getAttributes());
-            } else {
-                writer.leafSetEntryNode(name, nodeAsLeafList.getValue());
-            }
+            writer.startLeafSetEntryNode(nodeAsLeafList.getIdentifier());
+            writer.scalarValue(nodeAsLeafList.getValue());
+            writer.endNode();
             return true;
         } else if (node instanceof LeafNode) {
             final LeafNode<?> nodeAsLeaf = (LeafNode<?>)node;
-            if (writer instanceof NormalizedNodeStreamAttributeWriter) {
-                ((NormalizedNodeStreamAttributeWriter) writer).leafNode(nodeAsLeaf.getIdentifier(),
-                    nodeAsLeaf.getValue(), nodeAsLeaf.getAttributes());
-            } else {
-                writer.leafNode(nodeAsLeaf.getIdentifier(), nodeAsLeaf.getValue());
-            }
-            return true;
-        } else if (node instanceof AnyXmlNode) {
-            final AnyXmlNode anyXmlNode = (AnyXmlNode)node;
-            writer.anyxmlNode(anyXmlNode.getIdentifier(), anyXmlNode.getValue());
+            writer.startLeafNode(nodeAsLeaf.getIdentifier());
+            writer.scalarValue(nodeAsLeaf.getValue());
+            writer.endNode();
             return true;
+        } else if (node instanceof AnyxmlNode) {
+            final AnyxmlNode<?> anyxmlNode = (AnyxmlNode<?>)node;
+            final Class<?> model = anyxmlNode.getValueObjectModel();
+            if (writer.startAnyxmlNode(anyxmlNode.getIdentifier(), model)) {
+                final Object value = node.getValue();
+                if (DOMSource.class.isAssignableFrom(model)) {
+                    verify(value instanceof DOMSource, "Inconsistent anyxml node %s", anyxmlNode);
+                    writer.domSourceValue((DOMSource) value);
+                } else {
+                    writer.scalarValue(value);
+                }
+                writer.endNode();
+                return true;
+            }
+
+            LOG.debug("Ignoring unhandled anyxml node {}", anyxmlNode);
+        } else if (node instanceof AnydataNode) {
+            final AnydataNode<?> anydata = (AnydataNode<?>) node;
+            final Class<?> model = anydata.getValueObjectModel();
+            if (writer.startAnydataNode(anydata.getIdentifier(), model)) {
+                writer.scalarValue(anydata.getValue());
+                writer.endNode();
+                return true;
+            }
+
+            LOG.debug("Writer {} does not support anydata in form of {}", writer, model);
         }
 
         return false;
@@ -174,34 +195,19 @@ public class NormalizedNodeWriter implements Closeable, Flushable {
     }
 
     protected boolean writeMapEntryNode(final MapEntryNode node) throws IOException {
-        if (writer instanceof NormalizedNodeStreamAttributeWriter) {
-            ((NormalizedNodeStreamAttributeWriter) writer)
-                    .startMapEntryNode(node.getIdentifier(), childSizeHint(node.getValue()), node.getAttributes());
-        } else {
-            writer.startMapEntryNode(node.getIdentifier(), childSizeHint(node.getValue()));
-        }
+        writer.startMapEntryNode(node.getIdentifier(), childSizeHint(node.getValue()));
         return writeChildren(node.getValue());
     }
 
     protected boolean wasProcessedAsCompositeNode(final NormalizedNode<?, ?> node) throws IOException {
         if (node instanceof ContainerNode) {
             final ContainerNode n = (ContainerNode) node;
-            if (writer instanceof NormalizedNodeStreamAttributeWriter) {
-                ((NormalizedNodeStreamAttributeWriter) writer).startContainerNode(n.getIdentifier(),
-                    childSizeHint(n.getValue()), n.getAttributes());
-            } else {
-                writer.startContainerNode(n.getIdentifier(), childSizeHint(n.getValue()));
-            }
+            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()));
-            }
+            writer.startYangModeledAnyXmlNode(n.getIdentifier(), childSizeHint(n.getValue()));
             return writeChildren(n.getValue());
         }
         if (node instanceof MapEntryNode) {
@@ -261,14 +267,9 @@ public class NormalizedNodeWriter implements Closeable, Flushable {
         @Override
         protected boolean writeMapEntryNode(final MapEntryNode node) throws IOException {
             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()));
-            }
+            nnWriter.startMapEntryNode(node.getIdentifier(), childSizeHint(node.getValue()));
 
-            final Set<QName> qnames = node.getIdentifier().getKeyValues().keySet();
+            final Set<QName> qnames = node.getIdentifier().keySet();
             // Write out all the key children
             for (final QName qname : qnames) {
                 final Optional<? extends NormalizedNode<?, ?>> child = node.getChild(new NodeIdentifier(qname));