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%2Fmodification%2FMutableCompositeModification.java;h=a9ffe9b1ba877c40718a946df5ecf6bf591d4ca2;hp=f2a8c00d19035120b8bcac7b522d3d97465cd29e;hb=437beb82ffebfa9d11bbed88a2800d226bfbc66f;hpb=8f2b69d0944fe8ebc7e4300bb7a05265c7c290d7 diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/modification/MutableCompositeModification.java b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/modification/MutableCompositeModification.java index f2a8c00d19..a9ffe9b1ba 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/modification/MutableCompositeModification.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/modification/MutableCompositeModification.java @@ -5,10 +5,11 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ - package org.opendaylight.controller.cluster.datastore.modification; -import com.google.common.base.Preconditions; +import static com.google.common.base.Preconditions.checkArgument; +import static java.util.Objects.requireNonNull; + import java.io.IOException; import java.io.ObjectInput; import java.io.ObjectOutput; @@ -17,11 +18,12 @@ import java.util.Collections; import java.util.List; import org.opendaylight.controller.cluster.datastore.DataStoreVersions; import org.opendaylight.controller.cluster.datastore.messages.VersionedExternalizableMessage; -import org.opendaylight.controller.cluster.datastore.node.utils.stream.NormalizedNodeInputOutput; -import org.opendaylight.controller.cluster.datastore.node.utils.stream.NormalizedNodeInputStreamReader; -import org.opendaylight.controller.cluster.datastore.node.utils.stream.SerializationUtils; -import org.opendaylight.controller.sal.core.spi.data.DOMStoreWriteTransaction; +import org.opendaylight.mdsal.dom.spi.store.DOMStoreWriteTransaction; +import org.opendaylight.yangtools.yang.data.api.schema.stream.ReusableStreamReceiver; import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification; +import org.opendaylight.yangtools.yang.data.codec.binfmt.NormalizedNodeDataInput; +import org.opendaylight.yangtools.yang.data.codec.binfmt.NormalizedNodeDataOutput; +import org.opendaylight.yangtools.yang.data.impl.schema.ReusableImmutableNormalizedNodeStreamWriter; /** * MutableCompositeModification is just a mutable version of a CompositeModification. @@ -36,19 +38,19 @@ public class MutableCompositeModification extends VersionedExternalizableMessage this(DataStoreVersions.CURRENT_VERSION); } - public MutableCompositeModification(short version) { + public MutableCompositeModification(final short version) { super(version); } @Override - public void apply(DOMStoreWriteTransaction transaction) { + public void apply(final DOMStoreWriteTransaction transaction) { for (Modification modification : modifications) { modification.apply(transaction); } } @Override - public void apply(DataTreeModification transaction) { + public void apply(final DataTreeModification transaction) { for (Modification modification : modifications) { modification.apply(transaction); } @@ -64,12 +66,11 @@ public class MutableCompositeModification extends VersionedExternalizableMessage * * @param modification the modification to add. */ - public void addModification(Modification modification) { - Preconditions.checkNotNull(modification); - modifications.add(modification); + public void addModification(final Modification modification) { + modifications.add(requireNonNull(modification)); } - public void addModifications(Iterable newMods) { + public void addModifications(final Iterable newMods) { for (Modification mod : newMods) { addModification(mod); } @@ -85,61 +86,98 @@ public class MutableCompositeModification extends VersionedExternalizableMessage } @Override - public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { + public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException { super.readExternal(in); - - int size = in.readInt(); - - if (size > 1) { - SerializationUtils.REUSABLE_READER_TL.set(new NormalizedNodeInputStreamReader(in)); - } - - try { - for (int i = 0; i < size; i++) { - byte type = in.readByte(); - switch (type) { - case Modification.WRITE: - modifications.add(WriteModification.fromStream(in, getVersion())); - break; - - case Modification.MERGE: - modifications.add(MergeModification.fromStream(in, getVersion())); - break; - - case Modification.DELETE: - modifications.add(DeleteModification.fromStream(in, getVersion())); - break; - default: - break; - } + final int size = in.readInt(); + if (size > 0) { + if (getVersion() >= DataStoreVersions.PHOSPHORUS_VERSION) { + readExternalModern(NormalizedNodeDataInput.newDataInput(in), size); + } else { + readExternalLegacy(in, size); } - } finally { - SerializationUtils.REUSABLE_READER_TL.remove(); } } @Override - public void writeExternal(ObjectOutput out) throws IOException { + public void writeExternal(final ObjectOutput out) throws IOException { super.writeExternal(out); + final int size = modifications.size(); + out.writeInt(size); + if (size > 0) { + if (getVersion() >= DataStoreVersions.PHOSPHORUS_VERSION) { + writeExternalModern(out); + } else { + writeExternalLegacy(out); + } + } + } - out.writeInt(modifications.size()); - - if (modifications.size() > 1) { - SerializationUtils.REUSABLE_WRITER_TL.set(NormalizedNodeInputOutput.newDataOutput(out)); + private void readExternalLegacy(final ObjectInput in, final int size) throws IOException { + final NormalizedNodeDataInput input = NormalizedNodeDataInput.newDataInputWithoutValidation(in); + final ReusableStreamReceiver receiver = ReusableImmutableNormalizedNodeStreamWriter.create(); + for (int i = 0; i < size; i++) { + final byte type = in.readByte(); + switch (type) { + case Modification.WRITE: + modifications.add(WriteModification.fromStream(input, getVersion(), receiver)); + break; + case Modification.MERGE: + modifications.add(MergeModification.fromStream(input, getVersion(), receiver)); + break; + case Modification.DELETE: + modifications.add(DeleteModification.fromStream(input, getVersion())); + break; + default: + break; + } } + } - try { - for (Modification mod: modifications) { + private void writeExternalLegacy(final ObjectOutput out) throws IOException { + try (NormalizedNodeDataOutput stream = getStreamVersion().newDataOutput(out)) { + for (Modification mod : modifications) { out.writeByte(mod.getType()); - mod.writeExternal(out); + mod.writeTo(stream); } - } finally { - SerializationUtils.REUSABLE_WRITER_TL.remove(); } } - public static MutableCompositeModification fromSerializable(Object serializable) { - Preconditions.checkArgument(serializable instanceof MutableCompositeModification); + private void readExternalModern(final NormalizedNodeDataInput in, final int size) throws IOException { + final ReusableStreamReceiver receiver = ReusableImmutableNormalizedNodeStreamWriter.create(); + for (int i = 0; i < size; i++) { + final byte type = in.readByte(); + switch (type) { + case Modification.WRITE: + modifications.add(WriteModification.fromStream(in, getVersion(), receiver)); + break; + case Modification.MERGE: + modifications.add(MergeModification.fromStream(in, getVersion(), receiver)); + break; + case Modification.DELETE: + modifications.add(DeleteModification.fromStream(in, getVersion())); + break; + default: + break; + } + } + } + + private void writeExternalModern(final ObjectOutput out) throws IOException { + try (NormalizedNodeDataOutput stream = getStreamVersion().newDataOutput(out)) { + for (Modification mod : modifications) { + stream.writeByte(mod.getType()); + mod.writeTo(stream); + } + } + } + + public static MutableCompositeModification fromSerializable(final Object serializable) { + checkArgument(serializable instanceof MutableCompositeModification); return (MutableCompositeModification)serializable; } + + @Override + public void writeTo(final NormalizedNodeDataOutput out) throws IOException { + throw new UnsupportedOperationException(); + } }