Move API for FutureConverter to scala.compat.java8

This delegates to implementation located in scala.concurrent.java8
when neccessary to access package private members.

Author: retronym

README.md

@@ -23,7 +23,8 @@ class Test {
 
 ### Converters between `s.u.concurrent` and `j.u.concurrent`
 
-TODO
+[API](src/test/java/scala/compat/java8/FutureConverters.java)
+[Test Cases](src/test/java/scala/compat/java8/FutureConvertersTest.java)
 
 ### Converters for `j.u.function`
 

build.sbt

@@ -71,7 +71,7 @@ inConfig(JavaDoc)(Defaults.configSettings) ++ Seq(
   ),
   javacOptions in JavaDoc := Seq(),
   artifactName in packageDoc in JavaDoc := ((sv, mod, art) => "" + mod.name + "_" + sv.binary + "-" + mod.revision + "-javadoc.jar"),
-  libraryDependencies += compilerPlugin("com.typesafe.genjavadoc" %% "genjavadoc-plugin" % "0.5" cross CrossVersion.full),
+  libraryDependencies += compilerPlugin("com.typesafe.genjavadoc" % "genjavadoc-plugin_2.10.4" % "0.5"),
   scalacOptions in Compile <+= target map (t => "-P:genjavadoc:out=" + (t / "java"))
 )
 

…a/concurrent/java8/FutureConverter.scala …cala/compat/java8/FutureConverters.scalasrc/main/scala/scala/concurrent/java8/FutureConverter.scala renamed to src/main/scala/scala/compat/java8/FutureConverters.scala src/main/scala/scala/concurrent/java8/FutureConverter.scala renamed to src/main/scala/scala/compat/java8/FutureConverters.scala

@@ -1,5 +1,6 @@
-package scala.concurrent.java8
+package scala.compat.java8
 
+import scala.concurrent.java8.FuturesConvertersImpl._
 import scala.concurrent.{ Future, Promise, ExecutionContext, ExecutionContextExecutorService, ExecutionContextExecutor, impl }
 import java.util.concurrent.{ CompletionStage, Executor, ExecutorService, CompletableFuture }
 import scala.util.{ Try, Success, Failure }
@@ -33,54 +34,7 @@ import java.util.function.{ BiConsumer, Function ⇒ JF, Consumer, BiFunction }
  * final CompletionStage<Integer> cs2 = toJava(f2);
  * }}}
  */
-object FutureConverter {
-
-  private class CF[T] extends CompletableFuture[T] with (Try[T] => Unit) {
-    override def apply(t: Try[T]): Unit = t match {
-      case Success(v) ⇒ complete(v)
-      case Failure(e) ⇒ completeExceptionally(e)
-    }
-
-    /*
-     * Ensure that completions of this future cannot hold the Scala Future’s completer hostage.
-     */
-    override def thenApply[U](fn: JF[_ >: T, _ <: U]): CompletableFuture[U] = thenApplyAsync(fn)
-    override def thenAccept(fn: Consumer[_ >: T]): CompletableFuture[Void] = thenAcceptAsync(fn)
-    override def thenRun(fn: Runnable): CompletableFuture[Void] = thenRunAsync(fn)
-    override def thenCombine[U, V](cs: CompletionStage[_ <: U], fn: BiFunction[_ >: T, _ >: U, _ <: V]): CompletableFuture[V] = thenCombineAsync(cs, fn)
-    override def thenAcceptBoth[U](cs: CompletionStage[_ <: U], fn: BiConsumer[_ >: T, _ >: U]): CompletableFuture[Void] = thenAcceptBothAsync(cs, fn)
-    override def runAfterBoth(cs: CompletionStage[_], fn: Runnable): CompletableFuture[Void] = runAfterBothAsync(cs, fn)
-    override def applyToEither[U](cs: CompletionStage[_ <: T], fn: JF[_ >: T, U]): CompletableFuture[U] = applyToEitherAsync(cs, fn)
-    override def acceptEither(cs: CompletionStage[_ <: T], fn: Consumer[_ >: T]): CompletableFuture[Void] = acceptEitherAsync(cs, fn)
-    override def runAfterEither(cs: CompletionStage[_], fn: Runnable): CompletableFuture[Void] = runAfterEitherAsync(cs, fn)
-    override def thenCompose[U](fn: JF[_ >: T, _ <: CompletionStage[U]]): CompletableFuture[U] = thenComposeAsync(fn)
-    override def whenComplete(fn: BiConsumer[_ >: T, _ >: Throwable]): CompletableFuture[T] = whenCompleteAsync(fn)
-    override def handle[U](fn: BiFunction[_ >: T, Throwable, _ <: U]): CompletableFuture[U] = handleAsync(fn)
-    override def exceptionally(fn: JF[Throwable, _ <: T]): CompletableFuture[T] = {
-      val cf = new CompletableFuture[T]
-      whenCompleteAsync(new BiConsumer[T, Throwable] {
-        override def accept(t: T, e: Throwable): Unit = {
-          if (e == null) cf.complete(t)
-          else {
-            val n: AnyRef =
-              try {
-                fn(e).asInstanceOf[AnyRef]
-              } catch {
-                case thr: Throwable ⇒ cf.completeExceptionally(thr); this
-              }
-            if (n ne this) cf.complete(n.asInstanceOf[T])
-          }
-        }
-      })
-      cf
-    }
-
-    override def toCompletableFuture(): CompletableFuture[T] =
-      throw new UnsupportedOperationException("this CompletionStage represents a read-only Scala Future")
-    
-    override def toString: String = super[CompletableFuture].toString
-  }
-
+object FutureConverters {
   /**
    * Returns a CompletionStage that will be completed with the same value or
    * exception as the given Scala Future when that completes. Since the Future is a read-only
@@ -98,18 +52,11 @@ object FutureConverter {
    */
   def toJava[T](f: Future[T]): CompletionStage[T] = {
     val cf = new CF[T]
-    implicit val ec = Future.InternalCallbackExecutor
+    implicit val ec = InternalCallbackExecutor
     f onComplete cf
     cf
   }
 
-  private class P[T] extends impl.Promise.DefaultPromise[T] with BiConsumer[T, Throwable] {
-    override def accept(v: T, e: Throwable): Unit = {
-      if (e == null) complete(Success(v))
-      else complete(Failure(e))
-    }
-  }
-
   /**
    * Returns a Scala Future that will be completed with the same value or
    * exception as the given CompletionStage when that completes. Transformations
@@ -208,4 +155,36 @@ object FutureConverter {
    */
   def failedPromise[T](ex: Throwable): Promise[T] = Promise.failed(ex)
 
+  implicit class futureToCompletionStage[T](val f: Future[T]) extends AnyVal {
+    /**
+     * Returns a CompletionStage that will be completed with the same value or
+     * exception as the given Scala Future when that completes. Since the Future is a read-only
+     * representation, this CompletionStage does not support the
+     * <code>toCompletableFuture</code> method. The semantics of Scala Future
+     * demand that all callbacks are invoked asynchronously by default, therefore
+     * the returned CompletionStage routes all calls to synchronous
+     * transformations to their asynchronous counterparts, i.e.
+     * <code>thenRun</code> will internally call <code>thenRunAsync</code>.
+     *
+     * @param f The Scala Future which may eventually supply the completion for
+     * the returned CompletionStage
+     * @return a CompletionStage that runs all callbacks asynchronously and does
+     * not support the CompletableFuture interface
+     */
+    def toJava: CompletionStage[T] = FutureConverters.toJava(f)
+  }
+
+  implicit class completionStageToFuture[T](val cs: CompletionStage[T]) extends AnyVal {
+    /**
+     * Returns a Scala Future that will be completed with the same value or
+     * exception as the given CompletionStage when that completes. Transformations
+     * of the returned Future are executed asynchronously as specified by the
+     * ExecutionContext that is given to the combinator methods.
+     *
+     * @param cs The CompletionStage which may eventually supply the completion
+     * for the returned Scala Future
+     * @return a Scala Future that represents the CompletionStage's completion
+     */
+    def toScala: Future[T] = FutureConverters.toScala(cs)
+  }
 }

src/main/scala/scala/concurrent/java8/FutureConvertersImpl.scala

@@ -0,0 +1,77 @@
+package scala.concurrent.java8
+
+// Located in this package to access private[concurrent] members
+
+import scala.concurrent.{ Future, Promise, ExecutionContext, ExecutionContextExecutorService, ExecutionContextExecutor, impl }
+import java.util.concurrent.{ CompletionStage, Executor, ExecutorService, CompletableFuture }
+import scala.util.{ Try, Success, Failure }
+import java.util.function.{ BiConsumer, Function ⇒ JF, Consumer, BiFunction }
+
+private[scala] object FuturesConvertersImpl {
+  def InternalCallbackExecutor = Future.InternalCallbackExecutor
+
+  class CF[T] extends CompletableFuture[T] with (Try[T] => Unit) {
+    override def apply(t: Try[T]): Unit = t match {
+      case Success(v) ⇒ complete(v)
+      case Failure(e) ⇒ completeExceptionally(e)
+    }
+
+    /*
+     * Ensure that completions of this future cannot hold the Scala Future’s completer hostage.
+     */
+    override def thenApply[U](fn: JF[_ >: T, _ <: U]): CompletableFuture[U] = thenApplyAsync(fn)
+
+    override def thenAccept(fn: Consumer[_ >: T]): CompletableFuture[Void] = thenAcceptAsync(fn)
+
+    override def thenRun(fn: Runnable): CompletableFuture[Void] = thenRunAsync(fn)
+
+    override def thenCombine[U, V](cs: CompletionStage[_ <: U], fn: BiFunction[_ >: T, _ >: U, _ <: V]): CompletableFuture[V] = thenCombineAsync(cs, fn)
+
+    override def thenAcceptBoth[U](cs: CompletionStage[_ <: U], fn: BiConsumer[_ >: T, _ >: U]): CompletableFuture[Void] = thenAcceptBothAsync(cs, fn)
+
+    override def runAfterBoth(cs: CompletionStage[_], fn: Runnable): CompletableFuture[Void] = runAfterBothAsync(cs, fn)
+
+    override def applyToEither[U](cs: CompletionStage[_ <: T], fn: JF[_ >: T, U]): CompletableFuture[U] = applyToEitherAsync(cs, fn)
+
+    override def acceptEither(cs: CompletionStage[_ <: T], fn: Consumer[_ >: T]): CompletableFuture[Void] = acceptEitherAsync(cs, fn)
+
+    override def runAfterEither(cs: CompletionStage[_], fn: Runnable): CompletableFuture[Void] = runAfterEitherAsync(cs, fn)
+
+    override def thenCompose[U](fn: JF[_ >: T, _ <: CompletionStage[U]]): CompletableFuture[U] = thenComposeAsync(fn)
+
+    override def whenComplete(fn: BiConsumer[_ >: T, _ >: Throwable]): CompletableFuture[T] = whenCompleteAsync(fn)
+
+    override def handle[U](fn: BiFunction[_ >: T, Throwable, _ <: U]): CompletableFuture[U] = handleAsync(fn)
+
+    override def exceptionally(fn: JF[Throwable, _ <: T]): CompletableFuture[T] = {
+      val cf = new CompletableFuture[T]
+      whenCompleteAsync(new BiConsumer[T, Throwable] {
+        override def accept(t: T, e: Throwable): Unit = {
+          if (e == null) cf.complete(t)
+          else {
+            val n: AnyRef =
+              try {
+                fn(e).asInstanceOf[AnyRef]
+              } catch {
+                case thr: Throwable ⇒ cf.completeExceptionally(thr); this
+              }
+            if (n ne this) cf.complete(n.asInstanceOf[T])
+          }
+        }
+      })
+      cf
+    }
+
+    override def toCompletableFuture(): CompletableFuture[T] =
+      throw new UnsupportedOperationException("this CompletionStage represents a read-only Scala Future")
+
+    override def toString: String = super[CompletableFuture].toString
+  }
+
+  class P[T] extends impl.Promise.DefaultPromise[T] with BiConsumer[T, Throwable] {
+    override def accept(v: T, e: Throwable): Unit = {
+      if (e == null) complete(Success(v))
+      else complete(Failure(e))
+    }
+  }
+}

src/main/scala/scala/concurrent/java8/package.scala

@@ -1,4 +1,4 @@
-package scala.concurrent.java8;
+package scala.compat.java8;
 
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
@@ -12,9 +12,9 @@
 
 import scala.concurrent.Future;
 import scala.concurrent.Promise;
-import static scala.concurrent.java8.FutureConverter.*;
+import static scala.compat.java8.FutureConverters.*;
 
-public class BridgeTest {
+public class FutureConvertersTest {
 
   @Test
   public void testToScalaSuccess() {