Merge pull request #50 from retronym/ticket/44

More efficient round trip conversions for Futures

Author: retronym

.travis.yml

@@ -13,7 +13,7 @@ script:
   - admin/build.sh
 scala:
   - 2.11.7
-  - 2.12.0-M2
+  # - 2.12.0-M3
 jdk:
   - oraclejdk8
 notifications:

build.sbt

@@ -10,7 +10,7 @@ def jwrite(dir: java.io.File)(name: String, content: String) = {
 
 lazy val commonSettings = Seq(
   scalaVersion := "2.11.7",
-  crossScalaVersions := List("2.11.7", "2.12.0-M2"),
+  crossScalaVersions := List("2.11.7" /* TODO, "2.12.0-M3"*/),
   organization := "org.scala-lang.modules",
   version := "0.6.0-SNAPSHOT",
   libraryDependencies += "org.scala-lang" % "scala-reflect" % scalaVersion.value,

src/main/scala/scala/compat/java8/FutureConverters.scala

@@ -54,10 +54,14 @@ object FutureConverters {
    * not support the CompletableFuture interface
    */
   def toJava[T](f: Future[T]): CompletionStage[T] = {
-    val cf = new CF[T]
-    implicit val ec = InternalCallbackExecutor
-    f onComplete cf
-    cf
+    f match {
+      case p: P[T] => p.wrapped
+      case _ =>
+        val cf = new CF[T](f)
+        implicit val ec = InternalCallbackExecutor
+        f onComplete cf
+        cf
+    }
   }
 
   /**
@@ -71,15 +75,13 @@ object FutureConverters {
    * @return a Scala Future that represents the CompletionStage's completion
    */
   def toScala[T](cs: CompletionStage[T]): Future[T] = {
-    val p = Promise[T]()
-    val bc = new BiConsumer[T, Throwable] {
-      override def accept(v: T, e: Throwable): Unit = {
-        if (e == null) p.complete(Success(v))
-        else p.complete(Failure(e))
-      }
+    cs match {
+      case cf: CF[T] => cf.wrapped
+      case _ =>
+        val p = new P[T](cs)
+        cs whenComplete p
+        p.future
     }
-    cs whenComplete bc
-    p.future
   }
 
   /**

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

@@ -5,16 +5,17 @@ package scala.concurrent.java8
 
 // Located in this package to access private[concurrent] members
 
-import scala.concurrent.{ Future, Promise, ExecutionContext, ExecutionContextExecutorService, ExecutionContextExecutor, impl }
+import scala.concurrent.{ Future, ExecutionContext }
 import java.util.concurrent._
+import scala.concurrent.impl.Promise.DefaultPromise
 import scala.util.{ Try, Success, Failure }
 import java.util.function.{ BiConsumer, Function ⇒ JF, Consumer, BiFunction }
 
 // TODO: make thie private[scala] when genjavadoc allows for that.
 object FuturesConvertersImpl {
   def InternalCallbackExecutor = Future.InternalCallbackExecutor
 
-  class CF[T] extends CompletableFuture[T] with (Try[T] => Unit) {
+  class CF[T](val wrapped: Future[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)
@@ -84,4 +85,13 @@ object FuturesConvertersImpl {
 
     override def toString: String = super[CompletableFuture].toString
   }
+
+  class P[T](val wrapped: CompletionStage[T]) extends DefaultPromise[T] with BiConsumer[T, Throwable] {
+    override def onSuccess[U](pf: PartialFunction[T, U])(implicit executor: ExecutionContext): Unit = super.onSuccess(pf)
+
+    override def accept(v: T, e: Throwable): Unit = {
+      if (e == null) complete(Success(v))
+      else complete(Failure(e))
+    }
+  }
 }

src/test/java/scala/compat/java8/FutureConvertersTest.java

@@ -12,6 +12,7 @@
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
 import static java.util.concurrent.TimeUnit.SECONDS;
 import static org.junit.Assert.*;
+import static org.junit.Assert.assertSame;
 import static scala.compat.java8.FutureConverters.*;
 
 public class FutureConvertersTest {
@@ -398,4 +399,22 @@ public void testToJavaToCompletableFutureJavaObtrudeCalledBeforeScalaComplete()
             // okay
         }
     }
+
+    @Test
+    public void testToJavaAndBackAvoidsWrappers() {
+        final Promise<String> p = promise();
+        final Future<String> sf = p.future();
+        final CompletionStage<String> cs = toJava(sf);
+        Future<String> sf1 = toScala(cs);
+        assertSame(sf, sf1);
+    }
+
+    @Test
+    public void testToScalaAndBackAvoidsWrappers() {
+        final CompletableFuture<String> cf = new CompletableFuture<>();
+        final Future<String> f = toScala(cf);
+        CompletionStage<String> cs1 = toJava(f);
+        assertSame(cf, cs1);
+
+    }
 }