INTERNA: Change callback method for mutate operation.

src/main/java/net/spy/memcached/MemcachedClient.java

@@ -60,6 +60,7 @@
 import net.spy.memcached.ops.GetOperation;
 import net.spy.memcached.ops.GetsOperation;
 import net.spy.memcached.ops.Mutator;
+import net.spy.memcached.ops.MutatorOperation;
 import net.spy.memcached.ops.Operation;
 import net.spy.memcached.ops.OperationCallback;
 import net.spy.memcached.ops.OperationStatus;
@@ -1789,15 +1790,24 @@ private OperationFuture<Long> asyncMutate(Mutator m, String key, int by, long de
     final OperationFuture<Long> rv = new OperationFuture<>(
             latch, operationTimeout);
     Operation op = addOp(key, opFact.mutate(m, key, by, def, exp,
-        new OperationCallback() {
-          public void receivedStatus(OperationStatus s) {
-            rv.set(Long.parseLong(s.isSuccess() ? s.getMessage() : "-1"), s);
+        new MutatorOperation.Callback() {
+          private Long value;
+
+          @Override
+          public void receivedStatus(OperationStatus status) {
+            rv.set(value, status);
           }
 
+          @Override
           public void complete() {
             latch.countDown();
           }
-        }));
+
+          @Override
+          public void gotMutatedValue(Long result) {
+            value = result;
+          }
+      }));
     rv.setOperation(op);
     return rv;
   }

src/main/java/net/spy/memcached/OperationFactory.java

@@ -182,7 +182,7 @@ public interface OperationFactory {
    * @return the new mutator operation
    */
   MutatorOperation mutate(Mutator m, String key, int by,
-                          long def, int exp, OperationCallback cb);
+                          long def, int exp, MutatorOperation.Callback cb);
 
   /**
    * Get a new StatsOperation.

src/main/java/net/spy/memcached/ops/BaseOperationFactory.java

@@ -71,7 +71,7 @@ public Collection<Operation> clone(KeyedOperation op) {
       MutatorOperation mo = (MutatorOperation) op;
       rv.add(mutate(mo.getType(), first(op.getKeys()),
               mo.getBy(), mo.getDefault(), mo.getExpiration(),
-              op.getCallback()));
+              (MutatorOperation.Callback) op.getCallback()));
     } else if (op instanceof StoreOperation) {
       StoreOperation so = (StoreOperation) op;
       rv.add(store(so.getStoreType(), first(op.getKeys()), so.getFlags(),

src/main/java/net/spy/memcached/ops/MutatorOperation.java

@@ -24,4 +24,13 @@ public interface MutatorOperation extends KeyedOperation {
    * Get the expiration to set in case of a new entry.
    */
   int getExpiration();
+
+  interface Callback extends OperationCallback {
+    /**
+     * Callback for mutate operation.
+     *
+     * @param result the value that was mutated.
+     */
+    void gotMutatedValue(Long result);
+  }
 }

src/main/java/net/spy/memcached/protocol/ascii/AsciiOperationFactory.java

@@ -119,7 +119,7 @@ public GetsOperation mgets(Collection<String> keys, GetsOperation.Callback cb) {
   }
 
   public MutatorOperation mutate(Mutator m, String key, int by,
-                                 long def, int exp, OperationCallback cb) {
+                                 long def, int exp, MutatorOperation.Callback cb) {
     return new MutatorOperationImpl(m, key, by, def, exp, cb);
   }
 

src/main/java/net/spy/memcached/protocol/ascii/MutatorOperationImpl.java

@@ -28,7 +28,6 @@
 import net.spy.memcached.ops.APIType;
 import net.spy.memcached.ops.Mutator;
 import net.spy.memcached.ops.MutatorOperation;
-import net.spy.memcached.ops.OperationCallback;
 import net.spy.memcached.ops.OperationState;
 import net.spy.memcached.ops.OperationStatus;
 import net.spy.memcached.ops.OperationType;
@@ -52,15 +51,17 @@ final class MutatorOperationImpl extends OperationImpl
   private final int amount;
   private final long def;
   private final int exp;
+  private final MutatorOperation.Callback cb;
 
   public MutatorOperationImpl(Mutator m, String k, int amt, long d, int e,
-                              OperationCallback c) {
-    super(c);
+                              MutatorOperation.Callback cb) {
+    super(cb);
     mutator = m;
     key = k;
     amount = amt;
     def = d;
     exp = e;
+    this.cb = cb;
     if (m == Mutator.incr) {
       setAPIType(APIType.INCR);
     } else if (m == Mutator.decr) {
@@ -88,13 +89,15 @@ public void handleLine(String line) {
     // <result value>\r\n
     boolean allDigit = line.chars().allMatch(Character::isDigit);
     OperationStatus status;
+    long result = -1L;
     if (allDigit) {
       status = new OperationStatus(true, line, StatusCode.SUCCESS);
+      result = Long.parseLong(line);
     } else {
       status = matchStatus(line, NOT_FOUND, TYPE_MISMATCH);
     }
-
-    getCallback().receivedStatus(status);
+    cb.gotMutatedValue(result);
+    cb.receivedStatus(status);
     transitionState(OperationState.COMPLETE);
   }
 

src/main/java/net/spy/memcached/protocol/binary/BinaryOperationFactory.java

@@ -124,7 +124,7 @@ public GetsOperation mgets(Collection<String> keys, GetsOperation.Callback cb) {
   }
 
   public MutatorOperation mutate(Mutator m, String key, int by,
-                                 long def, int exp, OperationCallback cb) {
+                                 long def, int exp, MutatorOperation.Callback cb) {
     return new MutatorOperationImpl(m, key, by, def, exp, cb);
   }
 

src/test/java/net/spy/memcached/OperationFactoryTestBase.java

@@ -32,6 +32,7 @@ public abstract class OperationFactoryTestBase extends MockObjectTestCase {
   public final static String TEST_KEY = "someKey";
   protected OperationFactory ofact = null;
   protected OperationCallback genericCallback;
+  protected MutatorOperation.Callback genericMutationCallback;
   private byte[] testData;
 
   @Override
@@ -47,6 +48,21 @@ public void receivedStatus(OperationStatus status) {
         fail("Unexpected status:  " + status);
       }
     };
+    genericMutationCallback = new MutatorOperation.Callback() {
+      @Override
+      public void gotMutatedValue(Long result) {
+      }
+
+      @Override
+      public void receivedStatus(OperationStatus status) {
+        fail("Unexpected status:  " + status);
+      }
+
+      @Override
+      public void complete() {
+        fail("Unexpected invocation");
+      }
+    };
 
     testData = new byte[64];
     new Random().nextBytes(testData);
@@ -83,31 +99,31 @@ public void testMutatorOperationIncrCloning() {
     long def = 28775;
     int by = 7735;
     MutatorOperation op = ofact.mutate(Mutator.incr, TEST_KEY, by, def,
-            exp, genericCallback);
+            exp, genericMutationCallback);
 
     MutatorOperation op2 = cloneOne(MutatorOperation.class, op);
     assertKey(op2);
     assertEquals(exp, op2.getExpiration());
     assertEquals(def, op2.getDefault());
     assertEquals(by, op2.getBy());
     assertSame(Mutator.incr, op2.getType());
-    assertCallback(op2);
+    assertMutationCallback(op2);
   }
 
   public void testMutatorOperationDecrCloning() {
     int exp = 823862;
     long def = 28775;
     int by = 7735;
     MutatorOperation op = ofact.mutate(Mutator.decr, TEST_KEY, by, def,
-            exp, genericCallback);
+            exp, genericMutationCallback);
 
     MutatorOperation op2 = cloneOne(MutatorOperation.class, op);
     assertKey(op2);
     assertEquals(exp, op2.getExpiration());
     assertEquals(def, op2.getDefault());
     assertEquals(by, op2.getBy());
     assertSame(Mutator.decr, op2.getType());
-    assertCallback(op2);
+    assertMutationCallback(op2);
   }
 
   public void testStoreOperationAddCloning() {
@@ -287,6 +303,10 @@ protected void assertCallback(Operation op) {
     assertSame(genericCallback, op.getCallback());
   }
 
+  protected void assertMutationCallback(Operation op) {
+    assertSame(genericMutationCallback, op.getCallback());
+  }
+
   private void assertBytes(byte[] bytes) {
     assertTrue(Arrays.equals(testData, bytes));
   }

src/test/java/net/spy/memcached/protocol/ascii/OperationFactoryTest.java

@@ -18,15 +18,15 @@ public void testMutatorOperationIncrCloning() {
     long def = 28775;
     int by = 7735;
     MutatorOperation op = ofact.mutate(Mutator.incr, TEST_KEY, by, def,
-            exp, genericCallback);
+            exp, genericMutationCallback);
 
     MutatorOperation op2 = cloneOne(MutatorOperation.class, op);
     assertKey(op2);
     assertEquals(-1, op2.getExpiration());
     assertEquals(-1, op2.getDefault());
     assertEquals(by, op2.getBy());
     assertSame(Mutator.incr, op2.getType());
-    assertCallback(op2);
+    assertMutationCallback(op2);
   }
 
   @Override
@@ -35,15 +35,15 @@ public void testMutatorOperationDecrCloning() {
     long def = 28775;
     int by = 7735;
     MutatorOperation op = ofact.mutate(Mutator.decr, TEST_KEY, by, def,
-            exp, genericCallback);
+            exp, genericMutationCallback);
 
     MutatorOperation op2 = cloneOne(MutatorOperation.class, op);
     assertKey(op2);
     assertEquals(-1, op2.getExpiration());
     assertEquals(-1, op2.getDefault());
     assertEquals(by, op2.getBy());
     assertSame(Mutator.decr, op2.getType());
-    assertCallback(op2);
+    assertMutationCallback(op2);
   }
 
 }

src/test/manual/net/spy/memcached/MultibyteKeyTest.java

@@ -68,6 +68,7 @@
 import net.spy.memcached.ops.GetAttrOperation;
 import net.spy.memcached.ops.GetsOperation;
 import net.spy.memcached.ops.Mutator;
+import net.spy.memcached.ops.MutatorOperation;
 import net.spy.memcached.ops.OperationCallback;
 import net.spy.memcached.ops.OperationStatus;
 import net.spy.memcached.ops.StoreType;
@@ -273,7 +274,22 @@ public void complete() {
   @Test
   public void MutatorOperationImplTest() {
     try {
-      opFact.mutate(Mutator.incr, MULTIBYTE_KEY, 1, 1L, 0, genericCallback).initialize();
+      opFact.mutate(Mutator.incr, MULTIBYTE_KEY, 1, 1L, 0, new MutatorOperation.Callback() {
+        @Override
+        public void gotMutatedValue(Long result) {
+
+        }
+
+        @Override
+        public void receivedStatus(OperationStatus status) {
+
+        }
+
+        @Override
+        public void complete() {
+
+        }
+      }).initialize();
     } catch (java.nio.BufferOverflowException e) {
       Assert.fail();
     }