X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fcds-access-api%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fcluster%2Faccess%2Fconcepts%2FMessage.java;h=1d198fc8a9c9f8039b9f5cc6955e3a37230f0d98;hp=87b0e6ef345d8ad0c142fd6259d0ab0b1a5f2b67;hb=598f290a8c88342f16379842ab7e4915e9fcea6c;hpb=e4959b48fbe437645fff11374ff7fe3fd200932e

diff --git a/opendaylight/md-sal/cds-access-api/src/main/java/org/opendaylight/controller/cluster/access/concepts/Message.java b/opendaylight/md-sal/cds-access-api/src/main/java/org/opendaylight/controller/cluster/access/concepts/Message.java
index 87b0e6ef34..1d198fc8a9 100644
--- a/opendaylight/md-sal/cds-access-api/src/main/java/org/opendaylight/controller/cluster/access/concepts/Message.java
+++ b/opendaylight/md-sal/cds-access-api/src/main/java/org/opendaylight/controller/cluster/access/concepts/Message.java
@@ -7,14 +7,15 @@
  */
 package org.opendaylight.controller.cluster.access.concepts;
 
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
 import com.google.common.annotations.Beta;
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.MoreObjects;
 import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.base.Preconditions;
-import com.google.common.base.Verify;
 import java.io.Serializable;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
 import org.opendaylight.controller.cluster.access.ABIVersion;
 import org.opendaylight.yangtools.concepts.Immutable;
 import org.opendaylight.yangtools.concepts.WritableIdentifier;
@@ -23,21 +24,26 @@ import org.opendaylight.yangtools.concepts.WritableIdentifier;
  * An abstract concept of a Message. This class cannot be instantiated directly, use its specializations {@link Request}
  * and {@link Response}.
  *
+ * <p>
  * Messages have a target and a sequence number. Sequence numbers are expected to be assigned monotonically on a
  * per-target basis, hence two targets can observe the same sequence number.
  *
+ * <p>
  * This class includes explicit versioning for forward- and backward- compatibility of serialization format. This is
  * achieved by using the serialization proxy pattern. Subclasses are in complete control of what proxy is used to
  * serialize a particular object on the wire. This class can serve as an explicit version marker, hence no further
  * action is necessary in the deserialization path.
  *
+ * <p>
  * For the serialization path an explicit call from the user is required to select the appropriate serialization
  * version. This is done via {@link #toVersion(ABIVersion)} method, which should return a copy of this object with
  * the requested ABI version recorded and should return the appropriate serialization proxy.
  *
+ * <p>
  * This workflow allows least disturbance across ABI versions, as all messages not affected by a ABI version bump
  * will remain working with the same serialization format for the new ABI version.
  *
+ * <p>
  * Note that this class specifies the {@link Immutable} contract, which means that all subclasses must follow this API
  * contract.
  *
@@ -50,28 +56,23 @@ import org.opendaylight.yangtools.concepts.WritableIdentifier;
 public abstract class Message<T extends WritableIdentifier, C extends Message<T, C>> implements Immutable,
         Serializable {
     private static final long serialVersionUID = 1L;
-    private final T target;
+
+    private final @NonNull ABIVersion version;
     private final long sequence;
-    private final ABIVersion version;
-    private final long retry;
+    private final @NonNull T target;
 
-    private Message(final ABIVersion version, final T target, final long sequence, final long retry) {
-        this.target = Preconditions.checkNotNull(target);
-        this.version = Preconditions.checkNotNull(version);
+    private Message(final ABIVersion version, final T target, final long sequence) {
+        this.target = requireNonNull(target);
+        this.version = requireNonNull(version);
         this.sequence = sequence;
-        this.retry = retry;
     }
 
-    Message(final T target, final long sequence, final long retry) {
-        this(ABIVersion.current(), target, sequence, retry);
+    Message(final T target, final long sequence) {
+        this(ABIVersion.current(), target, sequence);
     }
 
     Message(final C msg, final ABIVersion version) {
-        this(version, msg.getTarget(), msg.getSequence(), msg.getRetry());
-    }
-
-    Message(final C msg, final long retry) {
-        this(msg.getVersion(), msg.getTarget(), msg.getSequence(), retry);
+        this(version, msg.getTarget(), msg.getSequence());
     }
 
     /**
@@ -79,55 +80,46 @@ public abstract class Message<T extends WritableIdentifier, C extends Message<T,
      *
      * @return Target identifier
      */
-    public final @Nonnull T getTarget() {
+    public final @NonNull T getTarget() {
         return target;
     }
 
     /**
-     * Get the message sequence of this message.
+     * Get the logical sequence number.
      *
-     * @return Message sequence
+     * @return logical sequence number
      */
     public final long getSequence() {
         return sequence;
     }
 
     @VisibleForTesting
-    public final ABIVersion getVersion() {
+    public final @NonNull ABIVersion getVersion() {
         return version;
     }
 
-    /**
-     * Get the message retry counter.
-     *
-     * @return Retry counter
-     */
-    public final long getRetry() {
-        return retry;
-    }
-
     /**
      * Return a message which will end up being serialized in the specified {@link ABIVersion}.
      *
-     * @param version Request {@link ABIVersion}
+     * @param toVersion Request {@link ABIVersion}
      * @return A new message which will use ABIVersion as its serialization.
      */
     @SuppressWarnings("unchecked")
-    public final @Nonnull C toVersion(final @Nonnull ABIVersion version) {
-        if (this.version == version) {
+    public final @NonNull C toVersion(final @NonNull ABIVersion toVersion) {
+        if (this.version == toVersion) {
             return (C)this;
         }
 
-        switch (version) {
+        switch (toVersion) {
             case BORON:
-                return Verify.verifyNotNull(cloneAsVersion(version));
+            case NEON_SR2:
+            case SODIUM_SR1:
+                return verifyNotNull(cloneAsVersion(toVersion));
             case TEST_PAST_VERSION:
             case TEST_FUTURE_VERSION:
-                // Fall-through to throw
-                break;
+            default:
+                throw new IllegalArgumentException("Unhandled ABI version " + toVersion);
         }
-
-        throw new IllegalArgumentException("Unhandled ABI version " + version);
     }
 
     /**
@@ -135,29 +127,11 @@ public abstract class Message<T extends WritableIdentifier, C extends Message<T,
      * method should be implemented by the concrete final message class and should invoke the equivalent of
      * {@link #Message(Message, ABIVersion)}.
      *
-     * @param version target ABI version
+     * @param targetVersion target ABI version
      * @return A message with the specified serialization stream
      * @throws IllegalArgumentException if this message does not support the target ABI
      */
-    protected abstract @Nonnull C cloneAsVersion(@Nonnull ABIVersion version);
-
-    /**
-     * Return a message which will have the retry counter incremented by one.
-     *
-     * @return A message with the specified retry counter
-     */
-    public final @Nonnull C incrementRetry() {
-        return Verify.verifyNotNull(cloneAsRetry(retry +1));
-    }
-
-    /**
-     * Create a copy of this message which will have its retry count bumped. This method should be implemented by
-     * the concrete final message class and should invoked the equivalent of {@link #Message(Message, long)}.
-     *
-     * @param retry new retry count
-     * @return A message with the specified retry counter
-     */
-    protected abstract @Nonnull C cloneAsRetry(long retry);
+    protected abstract @NonNull C cloneAsVersion(@NonNull ABIVersion targetVersion);
 
     @Override
     public final String toString() {
@@ -172,8 +146,8 @@ public abstract class Message<T extends WritableIdentifier, C extends Message<T,
      * @return The {@link ToStringHelper} passed in as argument
      * @throws NullPointerException if toStringHelper is null
      */
-    protected @Nonnull ToStringHelper addToStringAttributes(final @Nonnull ToStringHelper toStringHelper) {
-        return toStringHelper.add("target", target).add("sequence", Long.toUnsignedString(sequence, 16));
+    protected @NonNull ToStringHelper addToStringAttributes(final @NonNull ToStringHelper toStringHelper) {
+        return toStringHelper.add("target", target).add("sequence", Long.toUnsignedString(sequence));
     }
 
     /**
@@ -181,10 +155,10 @@ public abstract class Message<T extends WritableIdentifier, C extends Message<T,
      * different objects for incompatible {@link ABIVersion}s. This method should never fail, as any compatibility
      * checks should have been done by {@link #cloneAsVersion(ABIVersion)}.
      *
-     * @param version Requested ABI version
+     * @param reqVersion Requested ABI version
      * @return Proxy for this object
      */
-    abstract @Nonnull AbstractMessageProxy<T, C> externalizableProxy(@Nonnull ABIVersion version);
+    abstract @NonNull AbstractMessageProxy<T, C> externalizableProxy(@NonNull ABIVersion reqVersion);
 
     protected final Object writeReplace() {
         return externalizableProxy(version);