emulate AtomicReference

Author: ruslansennov

src/main/resources/super/java/util/concurrent/atomic/AtomicReference.java

@@ -0,0 +1,100 @@
+/*  __    __  __  __    __  ___
+ * \  \  /  /    \  \  /  /  __/
+ *  \  \/  /  /\  \  \/  /  /
+ *   \____/__/  \__\____/__/
+ *
+ * Copyright 2014-2017 Vavr, http://vavr.io
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package java.util.concurrent.atomic;
+
+import java.util.function.UnaryOperator;
+import java.util.function.BinaryOperator;
+
+/**
+ * GWT emulated version of {@link AtomicReference} wrapping reference.
+ */
+public class AtomicReference<V> implements java.io.Serializable {
+    private static final long serialVersionUID = -1848883965231344442L;
+
+    private V value;
+
+    public AtomicReference(V initialValue) {
+        value = initialValue;
+    }
+
+    public AtomicReference() {
+    }
+
+    public final V get() {
+        return value;
+    }
+
+    public final void set(V newValue) {
+        value = newValue;
+    }
+
+    public final void lazySet(V newValue) {
+        set(newValue);
+    }
+
+    public final boolean compareAndSet(V expect, V update) {
+        if (value == expect) {
+            value = update;
+            return true;
+        }
+        return false;
+    }
+
+    public final boolean weakCompareAndSet(V expect, V update) {
+        return compareAndSet(expect, update);
+    }
+
+    public final V getAndSet(V newValue) {
+        V prev = get();
+        set(newValue);
+        return prev;
+    }
+
+    public final V getAndUpdate(UnaryOperator<V> updateFunction) {
+        V prev = get();
+        set(updateFunction.apply(prev));
+        return prev;
+    }
+
+    public final V updateAndGet(UnaryOperator<V> updateFunction) {
+        V prev = get();
+        V next = updateFunction.apply(prev);
+        set(next);
+        return next;
+    }
+
+    public final V getAndAccumulate(V x, BinaryOperator<V> accumulatorFunction) {
+        V prev = get();
+        set(accumulatorFunction.apply(prev, x));
+        return prev;
+    }
+
+    public final V accumulateAndGet(V x, BinaryOperator<V> accumulatorFunction) {
+        V prev = get();
+        V next = accumulatorFunction.apply(prev, x);
+        set(next);
+        return next;
+    }
+
+    public String toString() {
+        return String.valueOf(get());
+    }
+
+}

src/test/java/client/ConcurrentTest1.java

@@ -12,6 +12,7 @@
 
 import java.util.concurrent.Executors;
 import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Predicate;
 
 import static io.vavr.API.Future;
@@ -46,13 +47,13 @@ public void testCreateSuccessFuture() {
 
     public void testFutureSuccess() {
         final AtomicBoolean ok = new AtomicBoolean(false);
-        final Ref<Predicate<Try<? extends String>>> comp = new Ref<>();
-        final Future<String> future = Future.join(comp::setV);
+        final AtomicReference<Predicate<Try<? extends String>>> comp = new AtomicReference<>();
+        final Future<String> future = Future.join(comp::set);
         future.onComplete(value -> {
             ok.set(true);
             assertEquals("value", value.get());
         });
-        comp.getV().test(Try.success("value"));
+        comp.get().test(Try.success("value"));
         assertTrue("onComplete handler should have been called", ok.get());
     }
 }

src/test/java/client/ConcurrentTest2.java

@@ -12,6 +12,7 @@
 import io.vavr.control.Try;
 
 import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Predicate;
 
 /**
@@ -28,29 +29,29 @@ public class ConcurrentTest2 extends GWTTestCase {
 
     public void testFutureFailure() {
         final AtomicBoolean onFailureCalled = new AtomicBoolean(false);
-        final Ref<Predicate<Try<? extends String>>> comp = new Ref<>();
-        final Future<String> future = Future.join(comp::setV);
+        final AtomicReference<Predicate<Try<? extends String>>> comp = new AtomicReference<>();
+        final Future<String> future = Future.join(comp::set);
         future.onFailure(e -> {
             onFailureCalled.set(true);
             assertEquals("message", e.getMessage());
         });
-        comp.getV().test(Try.failure(new Exception("message")));
+        comp.get().test(Try.failure(new Exception("message")));
         assertTrue("onFailure handler should have been called", onFailureCalled.get());
     }
 
     public void testFutureSequence() {
         final AtomicBoolean onCompleteCalled = new AtomicBoolean(false);
-        final Ref<Predicate<Try<? extends String>>> comp1 = new Ref<>();
-        final Future<String> future1 = Future.join(comp1::setV);
-        final Ref<Predicate<Try<? extends String>>> comp2 = new Ref<>();
-        final Future<String> future2 = Future.join(comp2::setV);
+        final AtomicReference<Predicate<Try<? extends String>>> comp1 = new AtomicReference<>();
+        final Future<String> future1 = Future.join(comp1::set);
+        final AtomicReference<Predicate<Try<? extends String>>> comp2 = new AtomicReference<>();
+        final Future<String> future2 = Future.join(comp2::set);
         Future.sequence(List.of(future1, future2))
               .onComplete(results -> {
                   onCompleteCalled.set(true);
                   assertEquals(2, results.get().size());
               });
-        comp1.getV().test(Try.success("success1"));
-        comp2.getV().test(Try.success("success2"));
+        comp1.get().test(Try.success("success1"));
+        comp2.get().test(Try.success("success2"));
         assertTrue("onComplete handler should have been called", onCompleteCalled.get());
     }
 }