Fix checkstyle reported by odlparent-3.0.0

[controller.git] / opendaylight / md-sal / sal-distributed-datastore / src / main / java / org / opendaylight / controller / cluster / datastore / persisted / DataTreeCandidateInputOutput.java

diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/persisted/DataTreeCandidateInputOutput.java b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/persisted/DataTreeCandidateInputOutput.java
index 9d0153f6b7bfb5381de72586b8ee9708615da8b4..bc1fca165544174c96043136a9f98e176c57e777 100644 (file)
--- a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/persisted/DataTreeCandidateInputOutput.java
+++ b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/persisted/DataTreeCandidateInputOutput.java
@@ -17,7 +17,6 @@ import java.util.Collections;
 import org.opendaylight.controller.cluster.datastore.node.utils.stream.NormalizedNodeDataInput;
 import org.opendaylight.controller.cluster.datastore.node.utils.stream.NormalizedNodeDataOutput;
 import org.opendaylight.controller.cluster.datastore.node.utils.stream.NormalizedNodeInputOutput;
-import org.opendaylight.controller.cluster.datastore.node.utils.stream.NormalizedNodeInputStreamReader;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
 import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
@@ -80,41 +79,51 @@ public final class DataTreeCandidateInputOutput {
     private static DataTreeCandidateNode readNode(final NormalizedNodeDataInput in) throws IOException {
         final byte type = in.readByte();
         switch (type) {
-        case APPEARED:
-            return readModifiedNode(ModificationType.APPEARED, in);
-        case DELETE:
-            return DeletedDataTreeCandidateNode.create(in.readPathArgument());
-        case DISAPPEARED:
-            return readModifiedNode(ModificationType.DISAPPEARED, in);
-        case SUBTREE_MODIFIED:
-            return readModifiedNode(ModificationType.SUBTREE_MODIFIED, in);
-        case UNMODIFIED:
-            return null;
-        case WRITE:
-            return DataTreeCandidateNodes.fromNormalizedNode(in.readNormalizedNode());
-        default:
-            throw new IllegalArgumentException("Unhandled node type " + type);
+            case APPEARED:
+                return readModifiedNode(ModificationType.APPEARED, in);
+            case DELETE:
+                return DeletedDataTreeCandidateNode.create(in.readPathArgument());
+            case DISAPPEARED:
+                return readModifiedNode(ModificationType.DISAPPEARED, in);
+            case SUBTREE_MODIFIED:
+                return readModifiedNode(ModificationType.SUBTREE_MODIFIED, in);
+            case UNMODIFIED:
+                return null;
+            case WRITE:
+                return DataTreeCandidateNodes.fromNormalizedNode(in.readNormalizedNode());
+            default:
+                throw new IllegalArgumentException("Unhandled node type " + type);
         }
     }
 
     public static DataTreeCandidate readDataTreeCandidate(final DataInput in) throws IOException {
-        final NormalizedNodeDataInput reader = new NormalizedNodeInputStreamReader(in);
+        final NormalizedNodeDataInput reader = NormalizedNodeInputOutput.newDataInput(in);
         final YangInstanceIdentifier rootPath = reader.readYangInstanceIdentifier();
         final byte type = reader.readByte();
 
         final DataTreeCandidateNode rootNode;
         switch (type) {
-        case DELETE:
-            rootNode = DeletedDataTreeCandidateNode.create();
-            break;
-        case SUBTREE_MODIFIED:
-            rootNode = ModifiedDataTreeCandidateNode.create(readChildren(reader));
-            break;
-        case WRITE:
-            rootNode = DataTreeCandidateNodes.fromNormalizedNode(reader.readNormalizedNode());
-            break;
-        default:
-            throw new IllegalArgumentException("Unhandled node type " + type);
+            case APPEARED:
+                rootNode = ModifiedDataTreeCandidateNode.create(ModificationType.APPEARED, readChildren(reader));
+                break;
+            case DELETE:
+                rootNode = DeletedDataTreeCandidateNode.create();
+                break;
+            case DISAPPEARED:
+                rootNode = ModifiedDataTreeCandidateNode.create(ModificationType.DISAPPEARED, readChildren(reader));
+                break;
+            case SUBTREE_MODIFIED:
+                rootNode = ModifiedDataTreeCandidateNode.create(ModificationType.SUBTREE_MODIFIED,
+                        readChildren(reader));
+                break;
+            case WRITE:
+                rootNode = DataTreeCandidateNodes.fromNormalizedNode(reader.readNormalizedNode());
+                break;
+            case UNMODIFIED:
+                rootNode = AbstractDataTreeCandidateNode.createUnmodified();
+                break;
+            default:
+                throw new IllegalArgumentException("Unhandled node type " + type);
         }
 
         return DataTreeCandidates.newDataTreeCandidate(rootPath, rootNode);
@@ -132,68 +141,72 @@ public final class DataTreeCandidateInputOutput {
     private static void writeNode(final NormalizedNodeDataOutput out, final DataTreeCandidateNode node)
             throws IOException {
         switch (node.getModificationType()) {
-        case APPEARED:
-            out.writeByte(APPEARED);
-            out.writePathArgument(node.getIdentifier());
-            writeChildren(out, node.getChildNodes());
-            break;
-        case DELETE:
-            out.writeByte(DELETE);
-            out.writePathArgument(node.getIdentifier());
-            break;
-        case DISAPPEARED:
-            out.writeByte(DISAPPEARED);
-            out.writePathArgument(node.getIdentifier());
-            writeChildren(out, node.getChildNodes());
-            break;
-        case SUBTREE_MODIFIED:
-            out.writeByte(SUBTREE_MODIFIED);
-            out.writePathArgument(node.getIdentifier());
-            writeChildren(out, node.getChildNodes());
-            break;
-        case WRITE:
-            out.writeByte(WRITE);
-            out.writeNormalizedNode(node.getDataAfter().get());
-            break;
-        case UNMODIFIED:
-            out.writeByte(UNMODIFIED);
-            break;
-        default:
-            throw new IllegalArgumentException("Unhandled node type " + node.getModificationType());
-        }
-    }
-
-    public static void writeDataTreeCandidate(final DataOutput out, DataTreeCandidate candidate) throws IOException {
-        try (final NormalizedNodeDataOutput writer = NormalizedNodeInputOutput.newDataOutput(out)) {
-            writer.writeYangInstanceIdentifier(candidate.getRootPath());
-
-            final DataTreeCandidateNode node = candidate.getRootNode();
-            switch (node.getModificationType()) {
             case APPEARED:
-                writer.writeByte(APPEARED);
-                writeChildren(writer, node.getChildNodes());
+                out.writeByte(APPEARED);
+                out.writePathArgument(node.getIdentifier());
+                writeChildren(out, node.getChildNodes());
                 break;
             case DELETE:
-                writer.writeByte(DELETE);
+                out.writeByte(DELETE);
+                out.writePathArgument(node.getIdentifier());
                 break;
             case DISAPPEARED:
-                writer.writeByte(DISAPPEARED);
-                writeChildren(writer, node.getChildNodes());
+                out.writeByte(DISAPPEARED);
+                out.writePathArgument(node.getIdentifier());
+                writeChildren(out, node.getChildNodes());
                 break;
             case SUBTREE_MODIFIED:
-                writer.writeByte(SUBTREE_MODIFIED);
-                writeChildren(writer, node.getChildNodes());
-                break;
-            case UNMODIFIED:
-                writer.writeByte(UNMODIFIED);
+                out.writeByte(SUBTREE_MODIFIED);
+                out.writePathArgument(node.getIdentifier());
+                writeChildren(out, node.getChildNodes());
                 break;
             case WRITE:
-                writer.writeByte(WRITE);
-                writer.writeNormalizedNode(node.getDataAfter().get());
+                out.writeByte(WRITE);
+                out.writeNormalizedNode(node.getDataAfter().get());
+                break;
+            case UNMODIFIED:
+                out.writeByte(UNMODIFIED);
                 break;
             default:
-                throw new IllegalArgumentException("Unhandled node type " + node.getModificationType());
+                throwUnhandledNodeType(node);
+        }
+    }
+
+    public static void writeDataTreeCandidate(final DataOutput out, DataTreeCandidate candidate) throws IOException {
+        try (NormalizedNodeDataOutput writer = NormalizedNodeInputOutput.newDataOutput(out)) {
+            writer.writeYangInstanceIdentifier(candidate.getRootPath());
+
+            final DataTreeCandidateNode node = candidate.getRootNode();
+            switch (node.getModificationType()) {
+                case APPEARED:
+                    writer.writeByte(APPEARED);
+                    writeChildren(writer, node.getChildNodes());
+                    break;
+                case DELETE:
+                    writer.writeByte(DELETE);
+                    break;
+                case DISAPPEARED:
+                    writer.writeByte(DISAPPEARED);
+                    writeChildren(writer, node.getChildNodes());
+                    break;
+                case SUBTREE_MODIFIED:
+                    writer.writeByte(SUBTREE_MODIFIED);
+                    writeChildren(writer, node.getChildNodes());
+                    break;
+                case UNMODIFIED:
+                    writer.writeByte(UNMODIFIED);
+                    break;
+                case WRITE:
+                    writer.writeByte(WRITE);
+                    writer.writeNormalizedNode(node.getDataAfter().get());
+                    break;
+                default:
+                    throwUnhandledNodeType(node);
             }
         }
     }
+
+    private static void throwUnhandledNodeType(final DataTreeCandidateNode node) {
+        throw new IllegalArgumentException("Unhandled node type " + node.getModificationType());
+    }
 }