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=1a005d856e30ceb3b9cd359b5fd14ef42bc14cf0;hb=437beb82ffebfa9d11bbed88a2800d226bfbc66f;hpb=6d73d16b194435ea1ea783a37d1b51fc1f558a1f 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 1a005d856e..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,75 +5,179 @@ * 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 org.opendaylight.controller.protobuff.messages.persistent.PersistentMessages; -import org.opendaylight.controller.sal.core.spi.data.DOMStoreWriteTransaction; -import org.opendaylight.yangtools.yang.model.api.SchemaContext; +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; import java.util.ArrayList; 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.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 {@link org.opendaylight.controller.cluster.datastore.modification.MutableCompositeModification#addModification(Modification)} + * MutableCompositeModification is just a mutable version of a CompositeModification. */ -public class MutableCompositeModification - implements CompositeModification { - - private static final long serialVersionUID = 1163377899140186790L; +public class MutableCompositeModification extends VersionedExternalizableMessage implements CompositeModification { + private static final long serialVersionUID = 1L; private final List modifications = new ArrayList<>(); + private List immutableModifications = null; + + public MutableCompositeModification() { + this(DataStoreVersions.CURRENT_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(final DataTreeModification transaction) { + for (Modification modification : modifications) { + modification.apply(transaction); + } + } + + @Override + public byte getType() { + return COMPOSITE; + } + /** - * Add a new Modification to the list of Modifications represented by this - * composite + * Add a new Modification to the list of Modifications represented by this composite. * - * @param modification + * @param modification the modification to add. */ - public void addModification(Modification modification) { - modifications.add(modification); + public void addModification(final Modification modification) { + modifications.add(requireNonNull(modification)); + } + + public void addModifications(final Iterable newMods) { + for (Modification mod : newMods) { + addModification(mod); + } } + @Override public List getModifications() { - return Collections.unmodifiableList(modifications); + if (immutableModifications == null) { + immutableModifications = Collections.unmodifiableList(modifications); + } + + return immutableModifications; } - @Override public Object toSerializable() { - PersistentMessages.CompositeModification.Builder builder = - PersistentMessages.CompositeModification.newBuilder(); + @Override + public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException { + super.readExternal(in); + final int size = in.readInt(); + if (size > 0) { + if (getVersion() >= DataStoreVersions.PHOSPHORUS_VERSION) { + readExternalModern(NormalizedNodeDataInput.newDataInput(in), size); + } else { + readExternalLegacy(in, size); + } + } + } + + @Override + 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); + } + } + } - for (Modification m : modifications) { - builder.addModification( - (PersistentMessages.Modification) m.toSerializable()); + 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; + } } + } - return builder.build(); + private void writeExternalLegacy(final ObjectOutput out) throws IOException { + try (NormalizedNodeDataOutput stream = getStreamVersion().newDataOutput(out)) { + for (Modification mod : modifications) { + out.writeByte(mod.getType()); + mod.writeTo(stream); + } + } } - public static MutableCompositeModification fromSerializable(Object serializable, SchemaContext schemaContext){ - PersistentMessages.CompositeModification o = (PersistentMessages.CompositeModification) serializable; - MutableCompositeModification compositeModification = new 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; + } + } + } - for(PersistentMessages.Modification m : o.getModificationList()){ - if(m.getType().equals(DeleteModification.class.toString())){ - compositeModification.addModification(DeleteModification.fromSerializable(m)); - } else if(m.getType().equals(WriteModification.class.toString())){ - compositeModification.addModification(WriteModification.fromSerializable(m, schemaContext)); - } else if(m.getType().equals(MergeModification.class.toString())){ - compositeModification.addModification(MergeModification.fromSerializable(m, schemaContext)); + 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); } } + } - return compositeModification; + 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(); } }