Update ParameterAwareNormalizedNodeWriter

Three distinct changes are being made here:

- use instanceof patterns to remove explicit casts
- reduce instanceof() checks by taking into account ordering
- eliminate childSizeHint() and use directly-exposed size()

Change-Id: If0ffaf9c34575ed4d7fef3a5a7c0dc13ce6ba687
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>

diff --git a/restconf/restconf-nb/src/main/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/ParameterAwareNormalizedNodeWriter.java b/restconf/restconf-nb/src/main/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/ParameterAwareNormalizedNodeWriter.java
index 7cb2365f853775eb0a74a51ab58c14b9be977dee..36c9daa12ac91e2cf5c478f1286f4f391d1efb34 100644 (file)
--- a/restconf/restconf-nb/src/main/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/ParameterAwareNormalizedNodeWriter.java
+++ b/restconf/restconf-nb/src/main/java/org/opendaylight/restconf/nb/rfc8040/jersey/providers/ParameterAwareNormalizedNodeWriter.java
@@ -8,18 +8,17 @@
 package org.opendaylight.restconf.nb.rfc8040.jersey.providers;
 
 import static java.util.Objects.requireNonNull;
-import static org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter.UNKNOWN_SIZE;
 
 import com.google.common.annotations.Beta;
 import com.google.common.collect.Iterables;
 import java.io.IOException;
-import java.util.Collection;
 import java.util.List;
 import java.util.Map.Entry;
 import java.util.Set;
 import javax.xml.transform.dom.DOMSource;
 import org.opendaylight.restconf.api.query.DepthParam;
 import org.opendaylight.restconf.nb.rfc8040.jersey.providers.api.RestconfNormalizedNodeWriter;
+import org.opendaylight.yangtools.yang.common.Ordering;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
 import org.opendaylight.yangtools.yang.data.api.schema.AnydataNode;
@@ -32,11 +31,10 @@ 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.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.SystemMapNode;
 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.UserLeafSetNode;
 import org.opendaylight.yangtools.yang.data.api.schema.UserMapNode;
 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
 import org.slf4j.Logger;
@@ -136,35 +134,20 @@ public class ParameterAwareNormalizedNodeWriter implements RestconfNormalizedNod
         writer.close();
     }
 
-    /**
-     * Emit a best guess of a hint for a particular set of children. It evaluates the
-     * iterable to see if the size can be easily gotten to. If it is, we hint at the
-     * real number of child nodes. Otherwise we emit UNKNOWN_SIZE.
-     *
-     * @param children Child nodes
-     * @return Best estimate of the collection size required to hold all the children.
-     */
-    static final int childSizeHint(final Iterable<?> children) {
-        return children instanceof Collection ? ((Collection<?>) children).size() : UNKNOWN_SIZE;
-    }
-
     private boolean wasProcessAsSimpleNode(final NormalizedNode node) throws IOException {
-        if (node instanceof LeafSetEntryNode) {
+        if (node instanceof LeafSetEntryNode<?> nodeAsLeafList) {
             if (selectedByParameters(node, false)) {
-                final LeafSetEntryNode<?> nodeAsLeafList = (LeafSetEntryNode<?>) node;
                 writer.startLeafSetEntryNode(nodeAsLeafList.getIdentifier());
                 writer.scalarValue(nodeAsLeafList.body());
                 writer.endNode();
             }
             return true;
-        } else if (node instanceof LeafNode) {
-            final LeafNode<?> nodeAsLeaf = (LeafNode<?>)node;
+        } else if (node instanceof LeafNode<?> nodeAsLeaf) {
             writer.startLeafNode(nodeAsLeaf.getIdentifier());
             writer.scalarValue(nodeAsLeaf.body());
             writer.endNode();
             return true;
-        } else if (node instanceof AnyxmlNode) {
-            final AnyxmlNode<?> anyxmlNode = (AnyxmlNode<?>)node;
+        } else if (node instanceof AnyxmlNode<?> anyxmlNode) {
             final Class<?> objectModel = anyxmlNode.bodyObjectModel();
             if (writer.startAnyxmlNode(anyxmlNode.getIdentifier(), objectModel)) {
                 if (DOMSource.class.isAssignableFrom(objectModel)) {
@@ -175,8 +158,7 @@ public class ParameterAwareNormalizedNodeWriter implements RestconfNormalizedNod
                 writer.endNode();
             }
             return true;
-        } else if (node instanceof AnydataNode) {
-            final AnydataNode<?> anydataNode = (AnydataNode<?>)node;
+        } else if (node instanceof AnydataNode<?> anydataNode) {
             final Class<?> objectModel = anydataNode.bodyObjectModel();
             if (writer.startAnydataNode(anydataNode.getIdentifier(), objectModel)) {
                 writer.scalarValue(anydataNode.body());
@@ -258,7 +240,7 @@ public class ParameterAwareNormalizedNodeWriter implements RestconfNormalizedNod
     }
 
     protected boolean writeMapEntryNode(final MapEntryNode node) throws IOException {
-        writer.startMapEntryNode(node.getIdentifier(), childSizeHint(node.body()));
+        writer.startMapEntryNode(node.getIdentifier(), node.size());
         currentDepth++;
         writeMapEntryChildren(node);
         currentDepth--;
@@ -269,7 +251,7 @@ public class ParameterAwareNormalizedNodeWriter implements RestconfNormalizedNod
         boolean processedAsCompositeNode = false;
         if (node instanceof ContainerNode n) {
             if (!n.getIdentifier().getNodeType().withoutRevision().equals(ROOT_DATA_QNAME)) {
-                writer.startContainerNode(n.getIdentifier(), childSizeHint(n.body()));
+                writer.startContainerNode(n.getIdentifier(), n.size());
                 currentDepth++;
                 processedAsCompositeNode = writeChildren(n.body(), false);
                 currentDepth--;
@@ -284,34 +266,33 @@ public class ParameterAwareNormalizedNodeWriter implements RestconfNormalizedNod
                 }
                 processedAsCompositeNode = true;
             }
-        } else if (node instanceof MapEntryNode) {
-            processedAsCompositeNode = writeMapEntryNode((MapEntryNode) node);
+        } else if (node instanceof MapEntryNode n) {
+            processedAsCompositeNode = writeMapEntryNode(n);
         } else if (node instanceof UnkeyedListEntryNode n) {
-            writer.startUnkeyedListItem(n.getIdentifier(), childSizeHint(n.body()));
+            writer.startUnkeyedListItem(n.getIdentifier(), n.size());
             currentDepth++;
             processedAsCompositeNode = writeChildren(n.body(), false);
             currentDepth--;
         } else if (node instanceof ChoiceNode n) {
-            writer.startChoiceNode(n.getIdentifier(), childSizeHint(n.body()));
+            writer.startChoiceNode(n.getIdentifier(), n.size());
             processedAsCompositeNode = writeChildren(n.body(), true);
         } else if (node instanceof AugmentationNode n) {
             writer.startAugmentationNode(n.getIdentifier());
             processedAsCompositeNode = writeChildren(n.body(), true);
         } else if (node instanceof UnkeyedListNode n) {
-            writer.startUnkeyedList(n.getIdentifier(), childSizeHint(n.body()));
+            writer.startUnkeyedList(n.getIdentifier(), n.size());
             processedAsCompositeNode = writeChildren(n.body(), false);
         } else if (node instanceof UserMapNode n) {
-            writer.startOrderedMapNode(n.getIdentifier(), childSizeHint(n.body()));
+            writer.startOrderedMapNode(n.getIdentifier(), n.size());
             processedAsCompositeNode = writeChildren(n.body(), true);
-        } else if (node instanceof MapNode n) {
-            writer.startMapNode(n.getIdentifier(), childSizeHint(n.body()));
+        } else if (node instanceof SystemMapNode n) {
+            writer.startMapNode(n.getIdentifier(), n.size());
             processedAsCompositeNode = writeChildren(n.body(), true);
-        } else if (node instanceof LeafSetNode) {
-            final LeafSetNode<?> n = (LeafSetNode<?>) node;
-            if (node instanceof UserLeafSetNode) {
-                writer.startOrderedLeafSet(n.getIdentifier(), childSizeHint(n.body()));
+        } else if (node instanceof LeafSetNode<?> n) {
+            if (n.ordering() == Ordering.USER) {
+                writer.startOrderedLeafSet(n.getIdentifier(), n.size());
             } else {
-                writer.startLeafSet(n.getIdentifier(), childSizeHint(n.body()));
+                writer.startLeafSet(n.getIdentifier(), n.size());
             }
             currentDepth++;
             processedAsCompositeNode = writeChildren(n.body(), true);
@@ -332,7 +313,7 @@ public class ParameterAwareNormalizedNodeWriter implements RestconfNormalizedNod
         @Override
         protected boolean writeMapEntryNode(final MapEntryNode node) throws IOException {
             final NormalizedNodeStreamWriter writer = getWriter();
-            writer.startMapEntryNode(node.getIdentifier(), childSizeHint(node.body()));
+            writer.startMapEntryNode(node.getIdentifier(), node.size());
 
             final Set<QName> qnames = node.getIdentifier().keySet();
             // Write out all the key children