Fix various warnings

[netconf.git] / restconf / sal-rest-connector / src / main / java / org / opendaylight / netconf / sal / rest / impl / DepthAwareNormalizedNodeWriter.java

diff --git a/restconf/sal-rest-connector/src/main/java/org/opendaylight/netconf/sal/rest/impl/DepthAwareNormalizedNodeWriter.java b/restconf/sal-rest-connector/src/main/java/org/opendaylight/netconf/sal/rest/impl/DepthAwareNormalizedNodeWriter.java
index 240839b61022c8204633a585863a7e74ef988e38..37f6cea6019108cfd09d48c8e9ba9571cdfc752a 100644 (file)
--- a/restconf/sal-rest-connector/src/main/java/org/opendaylight/netconf/sal/rest/impl/DepthAwareNormalizedNodeWriter.java
+++ b/restconf/sal-rest-connector/src/main/java/org/opendaylight/netconf/sal/rest/impl/DepthAwareNormalizedNodeWriter.java
@@ -11,7 +11,6 @@ import static org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedN
 
 import com.google.common.base.Optional;
 import com.google.common.base.Preconditions;
-import com.google.common.base.Predicate;
 import com.google.common.collect.Iterables;
 import java.io.IOException;
 import java.util.Collection;
@@ -69,12 +68,14 @@ public class DepthAwareNormalizedNodeWriter implements RestconfNormalizedNodeWri
      * @param writer Back-end writer
      * @return A new instance.
      */
-    public static DepthAwareNormalizedNodeWriter forStreamWriter(final NormalizedNodeStreamWriter writer, final int maxDepth) {
+    public static DepthAwareNormalizedNodeWriter forStreamWriter(final NormalizedNodeStreamWriter writer,
+                                                                 final int maxDepth) {
         return forStreamWriter(writer, true,  maxDepth);
     }
 
     /**
-     * Create a new writer backed by a {@link NormalizedNodeStreamWriter}. Unlike the simple {@link #forStreamWriter(NormalizedNodeStreamWriter, int)}
+     * Create a new writer backed by a {@link NormalizedNodeStreamWriter}.
+     * Unlike the simple {@link #forStreamWriter(NormalizedNodeStreamWriter, int)}
      * method, this allows the caller to switch off RFC6020 XML compliance, providing better
      * throughput. The reason is that the XML mapping rules in RFC6020 require the encoding
      * to emit leaf nodes which participate in a list's key first and in the order in which
@@ -87,13 +88,10 @@ public class DepthAwareNormalizedNodeWriter implements RestconfNormalizedNodeWri
      * @param orderKeyLeaves whether the returned instance should be RFC6020 XML compliant.
      * @return A new instance.
      */
-    public static DepthAwareNormalizedNodeWriter forStreamWriter(final NormalizedNodeStreamWriter writer, final boolean
-            orderKeyLeaves, final int maxDepth) {
-        if (orderKeyLeaves) {
-            return new OrderedDepthAwareNormalizedNodeWriter(writer, maxDepth);
-        } else {
-            return new DepthAwareNormalizedNodeWriter(writer, maxDepth);
-        }
+    public static DepthAwareNormalizedNodeWriter forStreamWriter(final NormalizedNodeStreamWriter writer,
+                                                                 final boolean orderKeyLeaves, final int maxDepth) {
+        return orderKeyLeaves ? new OrderedDepthAwareNormalizedNodeWriter(writer, maxDepth)
+                : new DepthAwareNormalizedNodeWriter(writer, maxDepth);
     }
 
     /**
@@ -101,9 +99,10 @@ public class DepthAwareNormalizedNodeWriter implements RestconfNormalizedNodeWri
      * events to the encapsulated {@link NormalizedNodeStreamWriter}.
      *
      * @param node Node
-     * @return
+     * @return DepthAwareNormalizedNodeWriter
      * @throws IOException when thrown from the backing writer.
      */
+    @Override
     public final DepthAwareNormalizedNodeWriter write(final NormalizedNode<?, ?> node) throws IOException {
         if (wasProcessedAsCompositeNode(node)) {
             return this;
@@ -136,7 +135,7 @@ public class DepthAwareNormalizedNodeWriter implements RestconfNormalizedNodeWri
      * @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;
+        return children instanceof Collection ? ((Collection<?>) children).size() : UNKNOWN_SIZE;
     }
 
     private boolean wasProcessAsSimpleNode(final NormalizedNode<?, ?> node) throws IOException {
@@ -153,8 +152,9 @@ public class DepthAwareNormalizedNodeWriter implements RestconfNormalizedNodeWri
             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());
+            if (writer instanceof NormalizedNodeStreamAttributeWriter) {
+                ((NormalizedNodeStreamAttributeWriter) writer)
+                        .leafNode(nodeAsLeaf.getIdentifier(), nodeAsLeaf.getValue(), nodeAsLeaf.getAttributes());
             } else {
                 writer.leafNode(nodeAsLeaf.getIdentifier(), nodeAsLeaf.getValue());
             }
@@ -194,7 +194,7 @@ public class DepthAwareNormalizedNodeWriter implements RestconfNormalizedNodeWri
         return true;
     }
 
-    private void writeOnlyKeys(Map<QName, Object> keyValues) throws IllegalArgumentException, IOException {
+    private void writeOnlyKeys(final Map<QName, Object> keyValues) throws IllegalArgumentException, IOException {
         for (Map.Entry<QName, Object> entry : keyValues.entrySet()) {
             writer.leafNode(new NodeIdentifier(entry.getKey()), entry.getValue());
         }
@@ -203,7 +203,7 @@ public class DepthAwareNormalizedNodeWriter implements RestconfNormalizedNodeWri
     }
 
     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 {
@@ -219,51 +219,44 @@ public class DepthAwareNormalizedNodeWriter implements RestconfNormalizedNodeWri
         boolean processedAsCompositeNode = false;
         if (node instanceof ContainerNode) {
             final ContainerNode n = (ContainerNode) node;
-            if(writer instanceof NormalizedNodeStreamAttributeWriter) {
-                ((NormalizedNodeStreamAttributeWriter) writer).startContainerNode(n.getIdentifier(), childSizeHint(n.getValue()), n.getAttributes());
+            if (writer instanceof NormalizedNodeStreamAttributeWriter) {
+                ((NormalizedNodeStreamAttributeWriter) writer)
+                        .startContainerNode(n.getIdentifier(), childSizeHint(n.getValue()), n.getAttributes());
             } else {
                 writer.startContainerNode(n.getIdentifier(), childSizeHint(n.getValue()));
             }
             currentDepth++;
             processedAsCompositeNode = writeChildren(n.getValue());
             currentDepth--;
-        }
-        else if (node instanceof MapEntryNode) {
-            processedAsCompositeNode =  writeMapEntryNode((MapEntryNode) node);
-        }
-        else if (node instanceof UnkeyedListEntryNode) {
+        } else if (node instanceof MapEntryNode) {
+            processedAsCompositeNode = writeMapEntryNode((MapEntryNode) node);
+        } else if (node instanceof UnkeyedListEntryNode) {
             final UnkeyedListEntryNode n = (UnkeyedListEntryNode) node;
             writer.startUnkeyedListItem(n.getIdentifier(), childSizeHint(n.getValue()));
             currentDepth++;
             processedAsCompositeNode = writeChildren(n.getValue());
             currentDepth--;
-        }
-        else if (node instanceof ChoiceNode) {
+        } else if (node instanceof ChoiceNode) {
             final ChoiceNode n = (ChoiceNode) node;
             writer.startChoiceNode(n.getIdentifier(), childSizeHint(n.getValue()));
             processedAsCompositeNode = writeChildren(n.getValue());
-        }
-        else if (node instanceof AugmentationNode) {
+        } else if (node instanceof AugmentationNode) {
             final AugmentationNode n = (AugmentationNode) node;
             writer.startAugmentationNode(n.getIdentifier());
             processedAsCompositeNode = writeChildren(n.getValue());
-        }
-        else if (node instanceof UnkeyedListNode) {
+        } else if (node instanceof UnkeyedListNode) {
             final UnkeyedListNode n = (UnkeyedListNode) node;
             writer.startUnkeyedList(n.getIdentifier(), childSizeHint(n.getValue()));
             processedAsCompositeNode = writeChildren(n.getValue());
-        }
-        else if (node instanceof OrderedMapNode) {
+        } else if (node instanceof OrderedMapNode) {
             final OrderedMapNode n = (OrderedMapNode) node;
             writer.startOrderedMapNode(n.getIdentifier(), childSizeHint(n.getValue()));
             processedAsCompositeNode = writeChildren(n.getValue());
-        }
-        else if (node instanceof MapNode) {
+        } else if (node instanceof MapNode) {
             final MapNode n = (MapNode) node;
             writer.startMapNode(n.getIdentifier(), childSizeHint(n.getValue()));
             processedAsCompositeNode = writeChildren(n.getValue());
-        }
-        else if (node instanceof LeafSetNode) {
+        } else if (node instanceof LeafSetNode) {
             final LeafSetNode<?> n = (LeafSetNode<?>) node;
             if (node instanceof OrderedLeafSetNode) {
                 writer.startOrderedLeafSet(n.getIdentifier(), childSizeHint(n.getValue()));
@@ -288,8 +281,9 @@ public class DepthAwareNormalizedNodeWriter implements RestconfNormalizedNodeWri
         @Override
         protected boolean writeMapEntryNode(final MapEntryNode node) throws IOException {
             final NormalizedNodeStreamWriter writer = getWriter();
-            if(writer instanceof NormalizedNodeStreamAttributeWriter) {
-                ((NormalizedNodeStreamAttributeWriter) writer).startMapEntryNode(node.getIdentifier(), childSizeHint(node.getValue()), node.getAttributes());
+            if (writer instanceof NormalizedNodeStreamAttributeWriter) {
+                ((NormalizedNodeStreamAttributeWriter) writer)
+                        .startMapEntryNode(node.getIdentifier(), childSizeHint(node.getValue()), node.getAttributes());
             } else {
                 writer.startMapEntryNode(node.getIdentifier(), childSizeHint(node.getValue()));
             }
@@ -307,19 +301,16 @@ public class DepthAwareNormalizedNodeWriter implements RestconfNormalizedNodeWri
 
             // Write all the rest
             currentDepth++;
-            boolean result = writeChildren(Iterables.filter(node.getValue(), new Predicate<NormalizedNode<?, ?>>() {
-                @Override
-                public boolean apply(final NormalizedNode<?, ?> input) {
-                    if (input instanceof AugmentationNode) {
-                        return true;
-                    }
-                    if (!qnames.contains(input.getNodeType())) {
-                        return true;
-                    }
-
-                    LOG.debug("Skipping key child {}", input);
-                    return false;
+            boolean result = writeChildren(Iterables.filter(node.getValue(), input -> {
+                if (input instanceof AugmentationNode) {
+                    return true;
+                }
+                if (!qnames.contains(input.getNodeType())) {
+                    return true;
                 }
+
+                LOG.debug("Skipping key child {}", input);
+                return false;
             }));
             currentDepth--;
             return result;