X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-distributed-datastore%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fcluster%2Fdatastore%2Fpersisted%2FDataTreeCandidateInputOutput.java;h=ee829e8a13ce27644d5951d98f0e393691c58f6c;hp=30bbca235b3839cc1c775d5bd263e62a53df9891;hb=04f22714755ee8e52a63386cc1f4290402659838;hpb=a2b838f96589b502578fa4e15cef2769f886a378 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 30bbca235b..ee829e8a13 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 @@ -7,24 +7,29 @@ */ package org.opendaylight.controller.cluster.datastore.persisted; +import static java.util.Objects.requireNonNull; + import com.google.common.annotations.Beta; +import com.google.common.annotations.VisibleForTesting; 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 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.eclipse.jdt.annotation.NonNullByDefault; +import org.opendaylight.yangtools.concepts.Immutable; 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; import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidates; import org.opendaylight.yangtools.yang.data.api.schema.tree.ModificationType; -import org.opendaylight.yangtools.yang.data.impl.schema.ReusableImmutableNormalizedNodeStreamWriter; +import org.opendaylight.yangtools.yang.data.codec.binfmt.NormalizedNodeDataInput; +import org.opendaylight.yangtools.yang.data.codec.binfmt.NormalizedNodeDataOutput; +import org.opendaylight.yangtools.yang.data.codec.binfmt.NormalizedNodeStreamVersion; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -48,12 +53,10 @@ public final class DataTreeCandidateInputOutput { throw new UnsupportedOperationException(); } - private static DataTreeCandidateNode readModifiedNode(final ModificationType type, - final NormalizedNodeDataInput in, final ReusableImmutableNormalizedNodeStreamWriter writer) - 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, writer); + final Collection children = readChildren(in, receiver); if (children.isEmpty()) { LOG.debug("Modified node {} does not have any children, not instantiating it", identifier); return null; @@ -63,7 +66,7 @@ public final class DataTreeCandidateInputOutput { } private static Collection readChildren(final NormalizedNodeDataInput in, - final ReusableImmutableNormalizedNodeStreamWriter writer) throws IOException { + final ReusableStreamReceiver receiver) throws IOException { final int size = in.readInt(); if (size == 0) { return ImmutableList.of(); @@ -71,7 +74,7 @@ public final class DataTreeCandidateInputOutput { final Collection ret = new ArrayList<>(size); for (int i = 0; i < size; ++i) { - final DataTreeCandidateNode child = readNode(in, writer); + final DataTreeCandidateNode child = readNode(in, receiver); if (child != null) { ret.add(child); } @@ -80,29 +83,49 @@ public final class DataTreeCandidateInputOutput { } private static DataTreeCandidateNode readNode(final NormalizedNodeDataInput in, - final ReusableImmutableNormalizedNodeStreamWriter writer) throws IOException { + final ReusableStreamReceiver receiver) throws IOException { final byte type = in.readByte(); switch (type) { case APPEARED: - return readModifiedNode(ModificationType.APPEARED, in, writer); + return readModifiedNode(ModificationType.APPEARED, in, receiver); case DELETE: return DeletedDataTreeCandidateNode.create(in.readPathArgument()); case DISAPPEARED: - return readModifiedNode(ModificationType.DISAPPEARED, in, writer); + return readModifiedNode(ModificationType.DISAPPEARED, in, receiver); case SUBTREE_MODIFIED: - return readModifiedNode(ModificationType.SUBTREE_MODIFIED, in, writer); + return readModifiedNode(ModificationType.SUBTREE_MODIFIED, in, receiver); case UNMODIFIED: return null; case WRITE: - return DataTreeCandidateNodes.written(in.readNormalizedNode(writer)); + return DataTreeCandidateNodes.written(in.readNormalizedNode(receiver)); default: throw new IllegalArgumentException("Unhandled node type " + type); } } - public static DataTreeCandidate readDataTreeCandidate(final DataInput in, - final ReusableImmutableNormalizedNodeStreamWriter writer) throws IOException { - final NormalizedNodeDataInput reader = NormalizedNodeInputOutput.newDataInput(in); + @NonNullByDefault + public static final class DataTreeCandidateWithVersion implements Immutable { + private final DataTreeCandidate candidate; + private final NormalizedNodeStreamVersion version; + + public DataTreeCandidateWithVersion(final DataTreeCandidate candidate, + final NormalizedNodeStreamVersion version) { + this.candidate = requireNonNull(candidate); + this.version = requireNonNull(version); + } + + public DataTreeCandidate getCandidate() { + return candidate; + } + + public NormalizedNodeStreamVersion getVersion() { + return version; + } + } + + public static DataTreeCandidateWithVersion readDataTreeCandidate(final DataInput in, + final ReusableStreamReceiver receiver) throws IOException { + final NormalizedNodeDataInput reader = NormalizedNodeDataInput.newDataInput(in); final YangInstanceIdentifier rootPath = reader.readYangInstanceIdentifier(); final byte type = reader.readByte(); @@ -110,21 +133,21 @@ public final class DataTreeCandidateInputOutput { switch (type) { case APPEARED: rootNode = ModifiedDataTreeCandidateNode.create(ModificationType.APPEARED, - readChildren(reader, writer)); + readChildren(reader, receiver)); break; case DELETE: rootNode = DeletedDataTreeCandidateNode.create(); break; case DISAPPEARED: rootNode = ModifiedDataTreeCandidateNode.create(ModificationType.DISAPPEARED, - readChildren(reader, writer)); + readChildren(reader, receiver)); break; case SUBTREE_MODIFIED: rootNode = ModifiedDataTreeCandidateNode.create(ModificationType.SUBTREE_MODIFIED, - readChildren(reader, writer)); + readChildren(reader, receiver)); break; case WRITE: - rootNode = DataTreeCandidateNodes.written(reader.readNormalizedNode(writer)); + rootNode = DataTreeCandidateNodes.written(reader.readNormalizedNode(receiver)); break; case UNMODIFIED: rootNode = AbstractDataTreeCandidateNode.createUnmodified(); @@ -133,7 +156,8 @@ public final class DataTreeCandidateInputOutput { throw new IllegalArgumentException("Unhandled node type " + type); } - return DataTreeCandidates.newDataTreeCandidate(rootPath, rootNode); + return new DataTreeCandidateWithVersion(DataTreeCandidates.newDataTreeCandidate(rootPath, rootNode), + reader.getVersion()); } private static void writeChildren(final NormalizedNodeDataOutput out, @@ -178,10 +202,10 @@ public final class DataTreeCandidateInputOutput { } } - public static void writeDataTreeCandidate(final DataOutput out, final DataTreeCandidate candidate) - throws IOException { - try (NormalizedNodeDataOutput writer = NormalizedNodeInputOutput.newDataOutput(out, - PayloadVersion.current().getStreamVersion())) { + @VisibleForTesting + public static void writeDataTreeCandidate(final DataOutput out, final PayloadVersion version, + final DataTreeCandidate candidate) throws IOException { + try (NormalizedNodeDataOutput writer = version.getStreamVersion().newDataOutput(out)) { writer.writeYangInstanceIdentifier(candidate.getRootPath()); final DataTreeCandidateNode node = candidate.getRootNode(); @@ -214,6 +238,11 @@ public final class DataTreeCandidateInputOutput { } } + public static void writeDataTreeCandidate(final DataOutput out, final DataTreeCandidate candidate) + throws IOException { + writeDataTreeCandidate(out, PayloadVersion.current(), candidate); + } + private static void throwUnhandledNodeType(final DataTreeCandidateNode node) { throw new IllegalArgumentException("Unhandled node type " + node.getModificationType()); }