package com.twitter.util

import com.twitter.concurrent.Offer

import com.twitter.concurrent.Tx

import java.util.concurrent.atomic.AtomicInteger

import java.util.concurrent.atomic.AtomicReference

import java.util.concurrent.CancellationException

import java.util.concurrent.CompletableFuture

import java.util.concurrent.{Future => JavaFuture}

import java.util.function.BiConsumer

import java.util.{List => JList}

import scala.collection.compat.immutable.ArraySeq

import scala.collection.{Seq => AnySeq}

import scala.runtime.NonLocalReturnControl

import scala.util.control.NoStackTrace

/**

* @see [[Futures]] for Java-friendly APIs.

* @see The [[https://twitter.github.io/finagle/guide/Futures.html user guide]]

* on concurrent programming with Futures.

*

* @define FutureJoinScaladocLink

* [[[com.twitter.util.Future.join[A](fs:Seq[com\.twitter\.util\.Future[A]]):com\.twitter\.util\.Future[Unit]* join(Seq[A])]]]

*

* @define FuturesJoinScaladocLink

* [[com.twitter.util.Futures.join[A,B](a:com\.twitter\.util\.Future[A],b:com\.twitter\.util\.Future[B]):com\.twitter\.util\.Future[(A,B)]* Futures.join(Future[A],Future[B])]]

*

* @define FutureCollectScaladocLink

* [[[com.twitter.util.Future.collect[A](fs:Seq[com\.twitter\.util\.Future[A]]):com\.twitter\.util\.Future[Seq[A]]* collect(Seq[Future[A]])]]]

*

* @define FutureCollectToTryScaladocLink

* [[[[com.twitter.util.Future.collectToTry[A](fs:Seq[com\.twitter\.util\.Future[A]]):com\.twitter\.util\.Future[Seq[com\.twitter\.util\.Try[A]]]* collectToTry(Seq[Future[A]])]]]]

*

* @define FutureSelectScaladocLink

* [[[com.twitter.util.Future.select[A](fs:Seq[com\.twitter\.util\.Future[A]]):com\.twitter\.util\.Future[(com\.twitter\.util\.Try[A],Seq[com\.twitter\.util\.Future[A]])]* select(Seq.MethodPerEndpoint)]]]

*/

object Future {

val DEFAULT_TIMEOUT: Duration = Duration.Top

/** A successfully satisfied constant `Unit`-typed `Future` of `()` */

val Unit: Future[Unit] = const(Return.Unit)

/** A successfully satisfied constant `Unit`-typed `Future` of `()` */

val Done: Future[Unit] = Unit

/**

* A successfully satisfied constant `Future` of `Void`-type.

* Can be useful for Java programmers.

*/

val Void: Future[Void] = value[Void](null: Void)

/** A successfully satisfied constant `Future` of `None` */

val None: Future[Option[Nothing]] = new ConstFuture(Return.None)

/** A successfully satisfied constant `Future` of `Nil` */

val Nil: Future[Seq[Nothing]] = new ConstFuture(Return.Nil)

/** A successfully satisfied constant `Future` of `true` */

val True: Future[Boolean] = new ConstFuture(Return.True)

/** A successfully satisfied constant `Future` of `false` */

val False: Future[Boolean] = new ConstFuture(Return.False)

private val NotApplied: Future[Nothing] = new NoFuture

private val AlwaysNotApplied: Any => Future[Nothing] = scala.Function.const(NotApplied)

private val tryToUnit: Try[Any] => Try[Unit] = {

case t: Return[_] => Try.Unit

case t => t.asInstanceOf[Try[Unit]]

}

private val tryToVoid: Try[Any] => Try[Void] = {

case t: Return[_] => Try.Void

case t => t.asInstanceOf[Try[Void]]

}

private val AlwaysMasked: PartialFunction[Throwable, Boolean] = { case _ => true }

private val toTuple2Instance: (Any, Any) => (Any, Any) = Tuple2.apply

private def toTuple2[A, B]: (A, B) => (A, B) = toTuple2Instance.asInstanceOf[(A, B) => (A, B)]

private val liftToTryInstance: Any => Try[Any] = Return(_)

private def liftToTry[T]: T => Try[T] = liftToTryInstance.asInstanceOf[T => Try[T]]

private val flattenTryInstance: Try[Try[Any]] => Try[Any] = _.flatten

private def flattenTry[A, T](implicit ev: A => Try[T]): Try[A] => Try[T] =

flattenTryInstance.asInstanceOf[Try[A] => Try[T]]

private val toTxInstance: Try[Any] => Try[Tx[Try[Any]]] =

res => {

val tx = new Tx[Try[Any]] {

def ack(): Future[Tx.Result[Try[Any]]] = Future.value(Tx.Commit(res))

def nack(): Unit = ()

}

Return(tx)

}

private def toTx[A]: Try[A] => Try[Tx[Try[A]]] =

toTxInstance.asInstanceOf[Try[A] => Try[Tx[Try[A]]]]

private val emptySeqInstance: Future[Seq[Any]] = Future.value(Seq.empty)

private def emptySeq[A]: Future[Seq[A]] = emptySeqInstance.asInstanceOf[Future[Seq[A]]]

private val emptyMapInstance: Future[Map[Any, Any]] = Future.value(Map.empty[Any, Any])

private def emptyMap[A, B]: Future[Map[A, B]] = emptyMapInstance.asInstanceOf[Future[Map[A, B]]]

// Exception used to raise on Futures.

private[this] val RaiseException = new Exception with NoStackTrace

@inline private final def raiseException = RaiseException

/**

* A failed `Future` analogous to `Predef.???`.

*/

def ??? : Future[Nothing] =

Future.exception(new NotImplementedError("an implementation is missing"))

/**

* Creates a satisfied `Future` from a [[Try]].

*

* @see [[value]] for creation from a constant value.

* @see [[apply]] for creation from a `Function`.

* @see [[exception]] for creation from a `Throwable`.

*/

def const[A](result: Try[A]): Future[A] = new ConstFuture[A](result)

/**

* Creates a successful satisfied `Future` from the value `a`.

*

* @see [[const]] for creation from a [[Try]]

* @see [[apply]] for creation from a `Function`.

* @see [[exception]] for creation from a `Throwable`.

*/

def value[A](a: A): Future[A] = const[A](Return(a))

/**

* Creates a failed satisfied `Future`.

*

* For example, {{{Future.exception(new Exception("boo"))}}}.

*

* @see [[apply]] for creation from a `Function`.

*/

def exception[A](e: Throwable): Future[A] = const[A](Throw(e))

/**

* A `Future` that can never be satisfied.

*/

val never: Future[Nothing] = new NoFuture

/**

* A `Unit`-typed `Future` that is satisfied after `howlong`.

*/

def sleep(howlong: Duration)(implicit timer: Timer): Future[Unit] =

if (howlong <= Duration.Zero) Future.Done

else if (howlong == Duration.Top) Future.never

else

new Promise[Unit] with Promise.InterruptHandler with (() => Unit) {

private[this] val task: TimerTask = timer.schedule(howlong.fromNow)(this())

// Timer task.

def apply(): Unit = setDone()

protected def onInterrupt(t: Throwable): Unit =

if (updateIfEmpty(Throw(t))) task.cancel()

}

/**

* Creates a satisfied `Future` from the result of running `a`.

*

* If the result of `a` is a non-fatal exception,

* this will result in a failed `Future`. Otherwise, the result

* is a successfully satisfied `Future`.

*

* @note that `a` is executed in the calling thread and as such

* some care must be taken with blocking code.

*/

def apply[A](a: => A): Future[A] =

try {

const(Try(a))

} catch {

case nlrc: NonLocalReturnControl[_] => Future.exception(new FutureNonLocalReturnControl(nlrc))

}

// The thread-safety for `outer` is guaranteed by synchronizing on `this`.

private[this] final class MonitoredPromise[A](private[this] var outer: Promise[A])

extends Monitor

with (Try[A] => Unit) {

// We're serializing access to the underlying promise such that whatever (failure, success)

// runs it first also nulls it out. We have to stop referencing `outer` from this monitor

// given it might be captured by one of the pending promises.

private[this] def run(): Promise[A] = synchronized {

val p = outer

outer = null

p

}

// Function1.apply

def apply(ta: Try[A]): Unit = {

val p = run()

if (p != null) p.update(ta)

}

// Monitor.handle

def handle(t: Throwable): Boolean = {

val p = run()

if (p == null) false

else {

p.raise(t)

p.setException(t)

true

}

}

}

/**

* Run the computation `mkFuture` while installing a [[Monitor]] that

* translates any exception thrown into an encoded one. If an

* exception is thrown anywhere, the underlying computation is

* interrupted with that exception.

*

* This function is usually called to wrap a computation that

* returns a Future (f0) whose value is satisfied by the invocation

* of an onSuccess/onFailure/ensure callbacks of another future

* (f1). If an exception happens in the callbacks on f1, f0 is

* never satisfied. In this example, `Future.monitored { f1

* onSuccess g; f0 }` will cancel f0 so that f0 never hangs.

*/

def monitored[A](mkFuture: => Future[A]): Future[A] = {

val p = new Promise[A]

val monitored = new MonitoredPromise(p)

// This essentially simulates MonitoredPromise.apply { ... } but w/o closure allocations.

val saved = Monitor.getOption

try {

Monitor.set(monitored)

val f = mkFuture

p.forwardInterruptsTo(f)

f.respond(monitored)

} catch {

case t: Throwable => if (!monitored.handle(t)) throw t

} finally { Monitor.setOption(saved) }

p

}

// Used by `Future.join`.

// We would like to be able to mix in both PartialFunction[Throwable, Unit]

// for the interrupt and handler and Function1[Try[A], Unit] for the respond handler,

// but because these are both Function1 of different types, this cannot be done. Because

// the respond handler is invoked for each Future in the sequence, and the interrupt handler is

// only set once, we prefer to mix in Function1.

private[this] class JoinPromise[A](fs: Iterable[Future[A]], size: Int)

extends Promise[Unit]

with (Try[A] => Unit) {

private[this] val count = new AtomicInteger(size)

// Handler for `Future.respond`, invoked in `Future.join`

def apply(value: Try[A]): Unit = value match {

case Return(_) =>

if (count.decrementAndGet() == 0)

update(Return.Unit)

case t @ Throw(_) =>

updateIfEmpty(t.cast[Unit])

}

setInterruptHandler {

case t: Throwable =>

val it = fs.iterator

while (it.hasNext) {

it.next().raise(t)

}

}

}

/**

* Creates a `Future` that is satisfied when all futures in `fs`

* are successfully satisfied. If any of the futures in `fs` fail,

* the returned `Future` is immediately satisfied by that failure.

*

* @param fs a sequence of Futures

*

* @see $FuturesJoinScaladocLink for a Java friendly API.

* @see $FutureCollectScaladocLink if you want to be able to see the results of each `Future`.

* @see $FutureCollectToTryScaladocLink if you want to be able to see the results of each

* `Future` regardless of if they succeed or fail.

*/

def join[A](fs: AnySeq[Future[A]]): Future[Unit] = {

if (fs.isEmpty) Future.Unit

else {

val size = fs.size

if (size == 1) fs.head.unit

else {

val result = new JoinPromise[A](fs, size)

val iterator = fs.iterator

while (iterator.hasNext && !result.isDefined) iterator.next().respond(result)

result

}

}

}

/* The following joins are generated with this code:

scala -e '

val meths = for (end <- ''b'' to ''v''; ps = ''a'' to end) yield

"""/**

* Join %d futures. The returned future is complete when all

* underlying futures complete. It fails immediately if any of them

* do.

*/

def join[%s](%s): Future[(%s)] = join(Seq(%s)).map { _ => (%s) }""".format(

ps.size,

ps map (_.toUpper) mkString ",",

ps map(p => "%c: Future[%c]".format(p, p.toUpper)) mkString ",",

ps map (_.toUpper) mkString ",",

ps mkString ",",

ps map(p => "Await.result("+p+")") mkString ","

)

meths foreach println

'

"""*/

/**

* Join 2 futures. The returned future is complete when all

* underlying futures complete. It fails immediately if any of them

* do.

*/

def join[A, B](a: Future[A], b: Future[B]): Future[(A, B)] = join(Seq(a, b)).map { _ =>

(Await.result(a), Await.result(b))

}

/**

* Join 3 futures. The returned future is complete when all

* underlying futures complete. It fails immediately if any of them

* do.

*/

def join[A, B, C](a: Future[A], b: Future[B], c: Future[C]): Future[(A, B, C)] =

join(Seq(a, b, c)).map { _ => (Await.result(a), Await.result(b), Await.result(c)) }

/**

* Join 4 futures. The returned future is complete when all

* underlying futures complete. It fails immediately if any of them

* do.

*/

def join[A, B, C, D](

a: Future[A],

b: Future[B],

c: Future[C],

d: Future[D]

): Future[(A, B, C, D)] = join(Seq(a, b, c, d)).map { _ =>

(Await.result(a), Await.result(b), Await.result(c), Await.result(d))

}

/**

* Join 5 futures. The returned future is complete when all

* underlying futures complete. It fails immediately if any of them

* do.

*/

def join[A, B, C, D, E](

a: Future[A],

b: Future[B],

c: Future[C],

d: Future[D],

e: Future[E]

): Future[(A, B, C, D, E)] = join(Seq(a, b, c, d, e)).map { _ =>

(Await.result(a), Await.result(b), Await.result(c), Await.result(d), Await.result(e))

}

/**

* Join 6 futures. The returned future is complete when all

* underlying futures complete. It fails immediately if any of them

* do.

*/

def join[A, B, C, D, E, F](

a: Future[A],

b: Future[B],

c: Future[C],

d: Future[D],

e: Future[E],

f: Future[F]

): Future[(A, B, C, D, E, F)] = join(Seq(a, b, c, d, e, f)).map { _ =>

(

Await.result(a),

Await.result(b),

Await.result(c),

Await.result(d),

Await.result(e),

Await.result(f)

)

}

/**

* Join 7 futures. The returned future is complete when all

* underlying futures complete. It fails immediately if any of them

* do.

*/

def join[A, B, C, D, E, F, G](

a: Future[A],

b: Future[B],

c: Future[C],

d: Future[D],

e: Future[E],

f: Future[F],

g: Future[G]

): Future[(A, B, C, D, E, F, G)] = join(Seq(a, b, c, d, e, f, g)).map { _ =>

(

Await.result(a),

Await.result(b),

Await.result(c),

Await.result(d),

Await.result(e),

Await.result(f),

Await.result(g)

)

}

/**

* Join 8 futures. The returned future is complete when all

* underlying futures complete. It fails immediately if any of them

* do.

*/

def join[A, B, C, D, E, F, G, H](

a: Future[A],

b: Future[B],

c: Future[C],

d: Future[D],

e: Future[E],

f: Future[F],

g: Future[G],

h: Future[H]

): Future[(A, B, C, D, E, F, G, H)] = join(Seq(a, b, c, d, e, f, g, h)).map { _ =>

(

Await.result(a),

Await.result(b),

Await.result(c),

Await.result(d),

Await.result(e),

Await.result(f),

Await.result(g),

Await.result(h)

)

}

/**

* Join 9 futures. The returned future is complete when all

* underlying futures complete. It fails immediately if any of them

* do.

*/

def join[A, B, C, D, E, F, G, H, I](

a: Future[A],

b: Future[B],

c: Future[C],

d: Future[D],

e: Future[E],

f: Future[F],

g: Future[G],

h: Future[H],

i: Future[I]

): Future[(A, B, C, D, E, F, G, H, I)] = join(Seq(a, b, c, d, e, f, g, h, i)).map { _ =>

(

Await.result(a),

Await.result(b),

Await.result(c),

Await.result(d),

Await.result(e),

Await.result(f),

Await.result(g),

Await.result(h),

Await.result(i)

)

}

/**

* Join 10 futures. The returned future is complete when all

* underlying futures complete. It fails immediately if any of them

* do.

*/

def join[A, B, C, D, E, F, G, H, I, J](

a: Future[A],

b: Future[B],

c: Future[C],

d: Future[D],

e: Future[E],

f: Future[F],

g: Future[G],

h: Future[H],

i: Future[I],

j: Future[J]

): Future[(A, B, C, D, E, F, G, H, I, J)] = join(Seq(a, b, c, d, e, f, g, h, i, j)).map { _ =>

(

Await.result(a),

Await.result(b),

Await.result(c),

Await.result(d),

Await.result(e),

Await.result(f),

Await.result(g),

Await.result(h),

Await.result(i),

Await.result(j)

)

}

/**

* Join 11 futures. The returned future is complete when all

* underlying futures complete. It fails immediately if any of them

* do.

*/

def join[A, B, C, D, E, F, G, H, I, J, K](

a: Future[A],

b: Future[B],

c: Future[C],

d: Future[D],

e: Future[E],

f: Future[F],

g: Future[G],

h: Future[H],

i: Future[I],

j: Future[J],

k: Future[K]

): Future[(A, B, C, D, E, F, G, H, I, J, K)] = join(Seq(a, b, c, d, e, f, g, h, i, j, k)).map {

_ =>

(

Await.result(a),

Await.result(b),

Await.result(c),

Await.result(d),

Await.result(e),

Await.result(f),

Await.result(g),

Await.result(h),

Await.result(i),

Await.result(j),

Await.result(k)

)

}

/**

* Join 12 futures. The returned future is complete when all

* underlying futures complete. It fails immediately if any of them

* do.

*/

def join[A, B, C, D, E, F, G, H, I, J, K, L](

a: Future[A],

b: Future[B],

c: Future[C],

d: Future[D],

e: Future[E],

f: Future[F],

g: Future[G],

h: Future[H],

i: Future[I],

j: Future[J],

k: Future[K],

l: Future[L]

): Future[(A, B, C, D, E, F, G, H, I, J, K, L)] =

join(Seq(a, b, c, d, e, f, g, h, i, j, k, l)).map { _ =>

(

Await.result(a),

Await.result(b),

Await.result(c),

Await.result(d),

Await.result(e),

Await.result(f),

Await.result(g),

Await.result(h),

Await.result(i),

Await.result(j),

Await.result(k),

Await.result(l)

)

}

/**

* Join 13 futures. The returned future is complete when all

* underlying futures complete. It fails immediately if any of them

* do.

*/

def join[A, B, C, D, E, F, G, H, I, J, K, L, M](

a: Future[A],

b: Future[B],

c: Future[C],

d: Future[D],

e: Future[E],

f: Future[F],

g: Future[G],

h: Future[H],

i: Future[I],

j: Future[J],

k: Future[K],

l: Future[L],

m: Future[M]

): Future[(A, B, C, D, E, F, G, H, I, J, K, L, M)] =

join(Seq(a, b, c, d, e, f, g, h, i, j, k, l, m)).map { _ =>

(

Await.result(a),

Await.result(b),

Await.result(c),

Await.result(d),

Await.result(e),

Await.result(f),

Await.result(g),

Await.result(h),

Await.result(i),

Await.result(j),

Await.result(k),

Await.result(l),

Await.result(m)

)

}

/**

* Join 14 futures. The returned future is complete when all

* underlying futures complete. It fails immediately if any of them

* do.

*/

def join[A, B, C, D, E, F, G, H, I, J, K, L, M, N](

a: Future[A],

b: Future[B],

c: Future[C],

d: Future[D],

e: Future[E],

f: Future[F],

g: Future[G],

h: Future[H],

i: Future[I],

j: Future[J],

k: Future[K],

l: Future[L],

m: Future[M],

n: Future[N]

): Future[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)] =

join(Seq(a, b, c, d, e, f, g, h, i, j, k, l, m, n)).map { _ =>

(

Await.result(a),

Await.result(b),

Await.result(c),

Await.result(d),

Await.result(e),

Await.result(f),

Await.result(g),

Await.result(h),

Await.result(i),

Await.result(j),

Await.result(k),

Await.result(l),

Await.result(m),

Await.result(n)

)

}

/**

* Join 15 futures. The returned future is complete when all

* underlying futures complete. It fails immediately if any of them

* do.

*/

def join[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](

a: Future[A],

b: Future[B],

c: Future[C],

d: Future[D],

e: Future[E],

f: Future[F],

g: Future[G],

h: Future[H],

i: Future[I],

j: Future[J],

k: Future[K],

l: Future[L],

m: Future[M],

n: Future[N],

o: Future[O]

): Future[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)] =

join(Seq(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)).map { _ =>

(

Await.result(a),

Await.result(b),

Await.result(c),

Await.result(d),

Await.result(e),

Await.result(f),

Await.result(g),

Await.result(h),

Await.result(i),

Await.result(j),

Await.result(k),

Await.result(l),

Await.result(m),

Await.result(n),

Await.result(o)

)

}

/**

* Join 16 futures. The returned future is complete when all

* underlying futures complete. It fails immediately if any of them

* do.

*/

def join[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](

a: Future[A],

b: Future[B],

c: Future[C],

d: Future[D],

e: Future[E],

f: Future[F],

g: Future[G],

h: Future[H],

i: Future[I],

j: Future[J],

k: Future[K],

l: Future[L],

m: Future[M],

n: Future[N],

o: Future[O],

p: Future[P]

): Future[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)] =

join(Seq(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)).map { _ =>

(

Await.result(a),

Await.result(b),

Await.result(c),

Await.result(d),

Await.result(e),

Await.result(f),

Await.result(g),

Await.result(h),

Await.result(i),

Await.result(j),

Await.result(k),

Await.result(l),

Await.result(m),

Await.result(n),

Await.result(o),

Await.result(p)

)

}

/**

* Join 17 futures. The returned future is complete when all

* underlying futures complete. It fails immediately if any of them

* do.

*/

def join[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](

a: Future[A],

b: Future[B],

c: Future[C],

d: Future[D],

e: Future[E],

f: Future[F],

g: Future[G],

h: Future[H],

i: Future[I],

j: Future[J],

k: Future[K],

l: Future[L],

m: Future[M],

n: Future[N],

o: Future[O],

p: Future[P],

q: Future[Q]

): Future[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)] =

join(Seq(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q)).map { _ =>

(

Await.result(a),

Await.result(b),

Await.result(c),

Await.result(d),

Await.result(e),

Await.result(f),

Await.result(g),

Await.result(h),

Await.result(i),

Await.result(j),

Await.result(k),

Await.result(l),

Await.result(m),

Await.result(n),

Await.result(o),

Await.result(p),

Await.result(q)

)

}

/**

* Join 18 futures. The returned future is complete when all

* underlying futures complete. It fails immediately if any of them

* do.

*/

def join[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](

a: Future[A],

b: Future[B],

c: Future[C],

d: Future[D],

e: Future[E],

f: Future[F],

g: Future[G],

h: Future[H],

i: Future[I],

j: Future[J],

k: Future[K],

l: Future[L],

m: Future[M],

n: Future[N],

o: Future[O],

p: Future[P],

q: Future[Q],

r: Future[R]

): Future[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)] =

join(Seq(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r)).map { _ =>

(

Await.result(a),

Await.result(b),

Await.result(c),

Await.result(d),

Await.result(e),

Await.result(f),

Await.result(g),

Await.result(h),

Await.result(i),

Await.result(j),

Await.result(k),

Await.result(l),

Await.result(m),

Await.result(n),

Await.result(o),

Await.result(p),

Await.result(q),

Await.result(r)

)

}

/**

* Join 19 futures. The returned future is complete when all

* underlying futures complete. It fails immediately if any of them

* do.

*/

def join[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](

a: Future[A],

b: Future[B],

c: Future[C],

d: Future[D],

e: Future[E],

f: Future[F],

g: Future[G],

h: Future[H],

i: Future[I],

j: Future[J],

k: Future[K],

l: Future[L],

m: Future[M],

n: Future[N],

o: Future[O],

p: Future[P],

q: Future[Q],

r: Future[R],

s: Future[S]

): Future[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] =

join(Seq(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s)).map { _ =>

(

Await.result(a),

Await.result(b),

Await.result(c),

Await.result(d),

Await.result(e),

Await.result(f),

Await.result(g),

Await.result(h),

Await.result(i),

Await.result(j),

Await.result(k),

Await.result(l),

Await.result(m),

Await.result(n),

Await.result(o),

Await.result(p),

Await.result(q),

Await.result(r),

Await.result(s)

)

}

/**

* Join 20 futures. The returned future is complete when all

* underlying futures complete. It fails immediately if any of them

* do.

*/

def join[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](

a: Future[A],

b: Future[B],

c: Future[C],

d: Future[D],

e: Future[E],

f: Future[F],

g: Future[G],

h: Future[H],

i: Future[I],

j: Future[J],

k: Future[K],

l: Future[L],

m: Future[M],

n: Future[N],

o: Future[O],

p: Future[P],

q: Future[Q],

r: Future[R],

s: Future[S],

t: Future[T]

): Future[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)] =

join(Seq(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)).map { _ =>

(

Await.result(a),

Await.result(b),

Await.result(c),

Await.result(d),

Await.result(e),

Await.result(f),

Await.result(g),

Await.result(h),

Await.result(i),

Await.result(j),

Await.result(k),

Await.result(l),

Await.result(m),

Await.result(n),

Await.result(o),

Await.result(p),

Await.result(q),

Await.result(r),

Await.result(s),

Await.result(t)

)

}

/**

* Join 21 futures. The returned future is complete when all

* underlying futures complete. It fails immediately if any of them

* do.

*/

def join[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](

a: Future[A],

b: Future[B],

c: Future[C],

d: Future[D],

e: Future[E],

f: Future[F],

g: Future[G],

h: Future[H],

i: Future[I],

j: Future[J],

k: Future[K],

l: Future[L],

m: Future[M],

n: Future[N],

o: Future[O],

p: Future[P],

q: Future[Q],

r: Future[R],

s: Future[S],

t: Future[T],

u: Future[U]

): Future[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)] =

join(Seq(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u)).map { _ =>

(

Await.result(a),

Await.result(b),

Await.result(c),

Await.result(d),

Await.result(e),

Await.result(f),

Await.result(g),

Await.result(h),

Await.result(i),

Await.result(j),

Await.result(k),

Await.result(l),

Await.result(m),

Await.result(n),

Await.result(o),

Await.result(p),

Await.result(q),

Await.result(r),

Await.result(s),

Await.result(t),

Await.result(u)

)

}

/**

* Join 22 futures. The returned future is complete when all

* underlying futures complete. It fails immediately if any of them

* do.

*/

def join[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](

a: Future[A],

b: Future[B],

c: Future[C],

d: Future[D],

e: Future[E],

f: Future[F],

g: Future[G],

h: Future[H],

i: Future[I],

j: Future[J],