X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-distributed-datastore%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fcluster%2Fdatastore%2Fpersisted%2FDataTreeCandidateInputOutput.java;h=53894de9ba23ff7406357b5d56008e7fb4f6d7a8;hb=178ebab612c3ddd338e759ca7e929c25c623b0b3;hp=fb9b07a5d00973d48169ab095e20cfeaf9931663;hpb=763995ce31cdaed38be580781df1f5c20edf5225;p=controller.git 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 fb9b07a5d0..53894de9ba 100644 --- 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 @@ -8,17 +8,18 @@ package org.opendaylight.controller.cluster.datastore.persisted; import com.google.common.annotations.Beta; +import com.google.common.collect.ImmutableList; import java.io.DataInput; import java.io.DataOutput; import java.io.IOException; import java.util.ArrayList; import java.util.Collection; -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.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument; +import org.opendaylight.yangtools.yang.data.api.schema.stream.ReusableStreamReceiver; import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate; import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode; import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNodes; @@ -47,56 +48,58 @@ public final class DataTreeCandidateInputOutput { throw new UnsupportedOperationException(); } - private static DataTreeCandidateNode readModifiedNode(final ModificationType type, - final NormalizedNodeDataInput in) throws IOException { - + private static DataTreeCandidateNode readModifiedNode(final ModificationType type, final NormalizedNodeDataInput in, + final ReusableStreamReceiver receiver) throws IOException { final PathArgument identifier = in.readPathArgument(); - final Collection children = readChildren(in); + final Collection children = readChildren(in, receiver); if (children.isEmpty()) { LOG.debug("Modified node {} does not have any children, not instantiating it", identifier); return null; - } else { - return ModifiedDataTreeCandidateNode.create(identifier, type, children); } + + return ModifiedDataTreeCandidateNode.create(identifier, type, children); } - private static Collection readChildren(final NormalizedNodeDataInput in) throws IOException { + private static Collection readChildren(final NormalizedNodeDataInput in, + final ReusableStreamReceiver receiver) throws IOException { final int size = in.readInt(); - if (size != 0) { - final Collection ret = new ArrayList<>(size); - for (int i = 0; i < size; ++i) { - final DataTreeCandidateNode child = readNode(in); - if (child != null) { - ret.add(child); - } + if (size == 0) { + return ImmutableList.of(); + } + + final Collection ret = new ArrayList<>(size); + for (int i = 0; i < size; ++i) { + final DataTreeCandidateNode child = readNode(in, receiver); + if (child != null) { + ret.add(child); } - return ret; - } else { - return Collections.emptyList(); } + return ret; } - private static DataTreeCandidateNode readNode(final NormalizedNodeDataInput in) throws IOException { + private static DataTreeCandidateNode readNode(final NormalizedNodeDataInput in, + final ReusableStreamReceiver receiver) throws IOException { final byte type = in.readByte(); switch (type) { case APPEARED: - return readModifiedNode(ModificationType.APPEARED, in); + return readModifiedNode(ModificationType.APPEARED, in, receiver); case DELETE: return DeletedDataTreeCandidateNode.create(in.readPathArgument()); case DISAPPEARED: - return readModifiedNode(ModificationType.DISAPPEARED, in); + return readModifiedNode(ModificationType.DISAPPEARED, in, receiver); case SUBTREE_MODIFIED: - return readModifiedNode(ModificationType.SUBTREE_MODIFIED, in); + return readModifiedNode(ModificationType.SUBTREE_MODIFIED, in, receiver); case UNMODIFIED: return null; case WRITE: - return DataTreeCandidateNodes.fromNormalizedNode(in.readNormalizedNode()); + return DataTreeCandidateNodes.written(in.readNormalizedNode(receiver)); default: throw new IllegalArgumentException("Unhandled node type " + type); } } - public static DataTreeCandidate readDataTreeCandidate(final DataInput in) throws IOException { + public static DataTreeCandidate readDataTreeCandidate(final DataInput in, final ReusableStreamReceiver receiver) + throws IOException { final NormalizedNodeDataInput reader = NormalizedNodeInputOutput.newDataInput(in); final YangInstanceIdentifier rootPath = reader.readYangInstanceIdentifier(); final byte type = reader.readByte(); @@ -104,20 +107,22 @@ public final class DataTreeCandidateInputOutput { final DataTreeCandidateNode rootNode; switch (type) { case APPEARED: - rootNode = ModifiedDataTreeCandidateNode.create(ModificationType.APPEARED, readChildren(reader)); + rootNode = ModifiedDataTreeCandidateNode.create(ModificationType.APPEARED, + readChildren(reader, receiver)); break; case DELETE: rootNode = DeletedDataTreeCandidateNode.create(); break; case DISAPPEARED: - rootNode = ModifiedDataTreeCandidateNode.create(ModificationType.DISAPPEARED, readChildren(reader)); + rootNode = ModifiedDataTreeCandidateNode.create(ModificationType.DISAPPEARED, + readChildren(reader, receiver)); break; case SUBTREE_MODIFIED: rootNode = ModifiedDataTreeCandidateNode.create(ModificationType.SUBTREE_MODIFIED, - readChildren(reader)); + readChildren(reader, receiver)); break; case WRITE: - rootNode = DataTreeCandidateNodes.fromNormalizedNode(reader.readNormalizedNode()); + rootNode = DataTreeCandidateNodes.written(reader.readNormalizedNode(receiver)); break; case UNMODIFIED: rootNode = AbstractDataTreeCandidateNode.createUnmodified(); @@ -129,7 +134,6 @@ public final class DataTreeCandidateInputOutput { return DataTreeCandidates.newDataTreeCandidate(rootPath, rootNode); } - private static void writeChildren(final NormalizedNodeDataOutput out, final Collection children) throws IOException { out.writeInt(children.size()); @@ -168,12 +172,14 @@ public final class DataTreeCandidateInputOutput { 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)) { + public static void writeDataTreeCandidate(final DataOutput out, final DataTreeCandidate candidate) + throws IOException { + try (NormalizedNodeDataOutput writer = NormalizedNodeInputOutput.newDataOutput(out, + PayloadVersion.current().getStreamVersion())) { writer.writeYangInstanceIdentifier(candidate.getRootPath()); final DataTreeCandidateNode node = candidate.getRootNode(); @@ -201,8 +207,12 @@ public final class DataTreeCandidateInputOutput { writer.writeNormalizedNode(node.getDataAfter().get()); break; default: - throw new IllegalArgumentException("Unhandled node type " + node.getModificationType()); + throwUnhandledNodeType(node); } } } + + private static void throwUnhandledNodeType(final DataTreeCandidateNode node) { + throw new IllegalArgumentException("Unhandled node type " + node.getModificationType()); + } }