more value coders and better result of merge register

Author: mweberUKL

src/main/java/eu/antidotedb/client/MaxValueMerger.java

@@ -0,0 +1,21 @@
+package eu.antidotedb.client;
+
+import java.util.Collections;
+import java.util.List;
+
+public class MaxValueMerger<V extends Comparable<V>> implements MergeRegisterKey.ValueMerger<V> {
+    private V onEmpty;
+
+    public MaxValueMerger(V onEmpty) {
+        this.onEmpty = onEmpty;
+    }
+
+    @Override
+    public V merge(List<V> concValues) {
+        if (concValues.isEmpty()) {
+            return onEmpty;
+        } else {
+            return Collections.max(concValues);
+        }
+    }
+}

src/main/java/eu/antidotedb/client/MergeRegisterKey.java

@@ -6,8 +6,31 @@
 import javax.annotation.CheckReturnValue;
 import java.util.List;
 
-public class MergeRegisterKey<V> extends Key<V> {
+public class MergeRegisterKey<V> extends Key<MergeRegisterKey.MergeResult<V>> {
+    public static class MergeResult<V> {
+        private boolean merged;
+        private V value;
+
+        public MergeResult(boolean merged, V value) {
+            this.merged = merged;
+            this.value = value;
+        }
+
+        public boolean isMerged() {
+            return merged;
+        }
+
+        public V getValue() {
+            return value;
+        }
+    }
+
     public interface ValueMerger<V> {
+        /**
+         * Merges the concurrent values of the (possibly empty) list concValues into a single value
+         * @param concValues the values concurrently written to the register by different replicas
+         * @return the merged result
+         */
         V merge(List<V> concValues);
     }
 
@@ -21,8 +44,9 @@ public interface ValueMerger<V> {
     }
 
     @Override
-    V readResponseToValue(AntidotePB.ApbReadObjectResp resp) {
-        return merger.merge(ResponseDecoder.multiValueRegister(format).readResponseToValue(resp));
+    MergeResult<V> readResponseToValue(AntidotePB.ApbReadObjectResp resp) {
+        List<V> concValues = ResponseDecoder.multiValueRegister(format).readResponseToValue(resp);
+        return new MergeResult<>(concValues.size()>1, merger.merge(concValues));
     }
 
     /**

src/main/java/eu/antidotedb/client/MinValueMerger.java

@@ -0,0 +1,21 @@
+package eu.antidotedb.client;
+
+import java.util.Collections;
+import java.util.List;
+
+public class MinValueMerger<V extends Comparable<V>> implements MergeRegisterKey.ValueMerger<V> {
+    private V onEmpty;
+
+    public MinValueMerger(V onEmpty) {
+        this.onEmpty = onEmpty;
+    }
+
+    @Override
+    public V merge(List<V> concValues) {
+        if (concValues.isEmpty()) {
+            return onEmpty;
+        } else {
+            return Collections.min(concValues);
+        }
+    }
+}

src/main/java/eu/antidotedb/client/ValueCoder.java

@@ -2,6 +2,7 @@
 
 import com.google.protobuf.ByteString;
 
+import java.nio.ByteBuffer;
 import java.util.List;
 import java.util.function.Function;
 import java.util.stream.Collectors;
@@ -111,6 +112,78 @@ public List<ByteString> decodeList(List<ByteString> byteStringList) {
         }
     };
 
+    /**
+     * Stores integers
+     */
+    ValueCoder<Integer> integerCoder = new ValueCoder<Integer>() {
+        @Override
+        public ByteString encode(Integer value) {
+            ByteBuffer buffer = ByteBuffer.allocate(Integer.BYTES);
+            buffer.putInt(value);
+            buffer.flip();
+            return ByteString.copyFrom(buffer);
+        }
+
+        @Override
+        public Integer decode(ByteString bytes) {
+            return bytes.asReadOnlyByteBuffer().getInt();
+        }
+    };
+
+    /**
+     * Stores longs
+     */
+    ValueCoder<Long> longCoder = new ValueCoder<Long>() {
+        @Override
+        public ByteString encode(Long value) {
+            ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES);
+            buffer.putLong(value);
+            buffer.flip();
+            return ByteString.copyFrom(buffer);
+        }
+
+        @Override
+        public Long decode(ByteString bytes) {
+            return bytes.asReadOnlyByteBuffer().getLong();
+        }
+    };
+
+    /**
+     * Stores floats
+     */
+    ValueCoder<Float> floatCoder = new ValueCoder<Float>() {
+        @Override
+        public ByteString encode(Float value) {
+            ByteBuffer buffer = ByteBuffer.allocate(Float.BYTES);
+            buffer.putFloat(value);
+            buffer.flip();
+            return ByteString.copyFrom(buffer);
+        }
+
+        @Override
+        public Float decode(ByteString bytes) {
+            return bytes.asReadOnlyByteBuffer().getFloat();
+        }
+    };
+
+    /**
+     * Stores doubles
+     */
+    ValueCoder<Double> doubleCoder = new ValueCoder<Double>() {
+        @Override
+        public ByteString encode(Double value) {
+            ByteBuffer buffer = ByteBuffer.allocate(Double.BYTES);
+            buffer.putDouble(value);
+            buffer.flip();
+            return ByteString.copyFrom(buffer);
+        }
+
+        @Override
+        public Double decode(ByteString bytes) {
+            return bytes.asReadOnlyByteBuffer().getDouble();
+        }
+    };
+
 
     /**
      * A helper method to create a custom ValueCoder.

src/test/java/eu/antidotedb/client/test/SimpleValueCoderTests.java

@@ -0,0 +1,55 @@
+package eu.antidotedb.client.test;
+
+import com.google.protobuf.ByteString;
+import eu.antidotedb.client.ValueCoder;
+import org.junit.Test;
+
+import java.util.Random;
+
+import static org.junit.Assert.assertEquals;
+
+public class SimpleValueCoderTests {
+    @Test
+    public void integerCoder() {
+        Random random = new Random();
+        for (int i = 0; i<1000; i++) {
+            int orig = random.nextInt();
+            ByteString encoded = ValueCoder.integerCoder.encode(orig);
+            int decoded = ValueCoder.integerCoder.decode(encoded);
+            assertEquals(orig, decoded);
+        }
+    }
+
+    @Test
+    public void longCoder() {
+        Random random = new Random();
+        for (int i = 0; i<1000; i++) {
+            long orig = random.nextLong();
+            ByteString encoded = ValueCoder.longCoder.encode(orig);
+            long decoded = ValueCoder.longCoder.decode(encoded);
+            assertEquals(orig, decoded);
+        }
+    }
+
+    @Test
+    public void floatCoder() {
+        Random random = new Random();
+        for (int i = 0; i<1000; i++) {
+            float orig = random.nextFloat();
+            ByteString encoded = ValueCoder.floatCoder.encode(orig);
+            float decoded = ValueCoder.floatCoder.decode(encoded);
+            assertEquals(orig, decoded, 0.0001);
+        }
+    }
+
+    @Test
+    public void doubleCoder() {
+        Random random = new Random();
+        for (int i = 0; i<1000; i++) {
+            double orig = random.nextDouble();
+            ByteString encoded = ValueCoder.doubleCoder.encode(orig);
+            double decoded = ValueCoder.doubleCoder.decode(encoded);
+            assertEquals(orig, decoded, 0.0001);
+        }
+    }
+}