Add AsyncCallback.countDownLatch

Author: japgolly

core/src/main/scala/japgolly/scalajs/react/AsyncCallback.scala

@@ -53,6 +53,37 @@ object AsyncCallback {
       (promise, complete) <- promise[Unit]
     } yield new Barrier(promise, complete(tryUnit))
 
+  final class CountDownLatch(count: Int, barrier: Barrier) {
+    private var _pending = count.max(0)
+
+    /** Decrements the count of the latch, releasing all waiting computations if the count reaches zero. */
+    val countDown: Callback =
+      Callback {
+        if (_pending > 0) {
+          _pending -= 1
+          if (_pending == 0) {
+            barrier.complete.runNow()
+          }
+        }
+      }
+
+    def await: AsyncCallback[Unit] =
+      barrier.await
+
+    def isComplete: CallbackTo[Boolean] =
+      barrier.isComplete
+
+    def pending: CallbackTo[Int] =
+      CallbackTo(_pending)
+  }
+
+  /** A synchronization aid that allows you to wait until a set of async processes completes. */
+  def countDownLatch(count: Int): CallbackTo[CountDownLatch] =
+    for {
+      b <- barrier
+      _ <- b.complete.when_(count <= 0)
+    } yield new CountDownLatch(count, b)
+
   def first[A](f: (Try[A] => Callback) => Callback): AsyncCallback[A] =
     new AsyncCallback(g => CallbackTo {
       var first = true

doc/changelog/1.7.7.md

@@ -2,7 +2,7 @@
 
 This entire release is focused on `AsyncCallback`.
 
-* `AsyncCallback` instances
+* `AsyncCallback` instances:
 
   * Added `fork` and `fork_` which run the async computation in the background.
 
@@ -11,6 +11,20 @@ This entire release is focused on `AsyncCallback`.
 
     `fork_` on the other hand, returns nothing and is effectively fire-and-forget.
 
+* `AsyncCallback` object:
+
+  * Added `countDownLatch(count: Int)` which returns an `AsyncCallback.CountDownLatch`.
+    It has the same purpose and semantics as Java's `CountDownLatch`.
+
+    ```scala
+    AsyncCallback.CountDownLatch {
+      countDown : Callback
+      await     : AsyncCallback[Unit]
+      isComplete: CallbackTo[Boolean]
+      pending   : CallbackTo[Int]
+    }
+    ```
+
 * `AsyncCallback.Barrier`:
 
   * Added `isComplete: CallbackTo[Boolean]` to synchronously query whether the barrier is complete or not.

test/src/test/scala/japgolly/scalajs/react/core/AsyncCallbackTest.scala

@@ -164,5 +164,44 @@ object AsyncCallbackTest extends TestSuite {
       } yield ()
     }
 
+    "countDownLatch" - {
+      "3" - asyncTest {
+        var t = 0
+        var completedAt = -1
+        for {
+          b <- AsyncCallback.barrier.asAsyncCallback
+          l <- AsyncCallback.countDownLatch(3).asAsyncCallback
+          _ <- l.await.flatMapSync(_ => {completedAt = t; b.complete}).fork_.asAsyncCallback
+          _ <- l.pending.asAsyncCallback.tap(assertEq(_, 3))
+          _ <- l.isComplete.asAsyncCallback.tap(assertEq(_, false))
+
+          _ <- l.countDown.asAsyncCallback
+          _ <- l.pending.asAsyncCallback.tap(assertEq(_, 2))
+          _ <- l.isComplete.asAsyncCallback.tap(assertEq(_, false))
+
+          _ <- l.countDown.asAsyncCallback
+          _ <- l.pending.asAsyncCallback.tap(assertEq(_, 1))
+          _ <- l.isComplete.asAsyncCallback.tap(assertEq(_, false))
+
+          _ <- AsyncCallback.delay { t = 5 }
+          _ <- l.countDown.asAsyncCallback
+          _ <- l.pending.asAsyncCallback.tap(assertEq(_, 0))
+          _ <- l.isComplete.asAsyncCallback.tap(assertEq(_, true))
+          _ <- l.await.map(_ => completedAt = t).fork_.asAsyncCallback
+          _ <- b.await
+
+        } yield assertEq(completedAt, 5)
+      }
+
+      "0" - asyncTest {
+        for {
+          l <- AsyncCallback.countDownLatch(0).asAsyncCallback
+          _ <- l.pending.asAsyncCallback.tap(assertEq(_, 0))
+          _ <- l.isComplete.asAsyncCallback.tap(assertEq(_, true))
+          _ <- l.await
+        } yield ()
+      }
+    }
+
   }
 }