s_mach.concurrent.impl

SMach_Concurrent_AbstractPimpMyAsyncConfig

trait SMach_Concurrent_AbstractPimpMyAsyncConfig extends Any

Linear Supertypes
Any
Known Subclasses
SMach_Concurrent_PimpMyAsyncConfigBuilder
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. SMach_Concurrent_AbstractPimpMyAsyncConfig
  2. Any
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Abstract Value Members

  1. abstract def getClass(): Class[_]

    Definition Classes
    Any

  2. abstract def self: AsyncConfig

Concrete Value Members

  1. final def !=(arg0: Any): Boolean

    Definition Classes
    Any

  2. final def ##(): Int

    Definition Classes
    Any

  3. final def ==(arg0: Any): Boolean

    Definition Classes
    Any

  4. final def asInstanceOf[T0]: T0

    Definition Classes
    Any

  5. def equals(arg0: Any): Boolean

    Definition Classes
    Any

  6. def hashCode(): Int

    Definition Classes
    Any

  7. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any

  8. def run[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](fa: ⇒ Future[A], fb: ⇒ Future[B], fc: ⇒ Future[C], fd: ⇒ Future[D], fe: ⇒ Future[E], ff: ⇒ Future[F], fg: ⇒ Future[G], fh: ⇒ Future[H], fi: ⇒ Future[I], fj: ⇒ Future[J], fk: ⇒ Future[K], fl: ⇒ Future[L], fm: ⇒ Future[M], fn: ⇒ Future[N], fo: ⇒ Future[O], fp: ⇒ Future[P], fq: ⇒ Future[Q], fr: ⇒ Future[R], fs: ⇒ Future[S], ft: ⇒ Future[T], fu: ⇒ Future[U], fv: ⇒ Future[V])(implicit ec: ExecutionContext): Future[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)]

    returns

    a future of a tuple that completes successfully once all futures successfullly complete OR that fails immediately once any future fails.

  9. def run[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](fa: ⇒ Future[A], fb: ⇒ Future[B], fc: ⇒ Future[C], fd: ⇒ Future[D], fe: ⇒ Future[E], ff: ⇒ Future[F], fg: ⇒ Future[G], fh: ⇒ Future[H], fi: ⇒ Future[I], fj: ⇒ Future[J], fk: ⇒ Future[K], fl: ⇒ Future[L], fm: ⇒ Future[M], fn: ⇒ Future[N], fo: ⇒ Future[O], fp: ⇒ Future[P], fq: ⇒ Future[Q], fr: ⇒ Future[R], fs: ⇒ Future[S], ft: ⇒ Future[T], fu: ⇒ Future[U])(implicit ec: ExecutionContext): Future[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)]

    returns

    a future of a tuple that completes successfully once all futures successfullly complete OR that fails immediately once any future fails.

  10. def run[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](fa: ⇒ Future[A], fb: ⇒ Future[B], fc: ⇒ Future[C], fd: ⇒ Future[D], fe: ⇒ Future[E], ff: ⇒ Future[F], fg: ⇒ Future[G], fh: ⇒ Future[H], fi: ⇒ Future[I], fj: ⇒ Future[J], fk: ⇒ Future[K], fl: ⇒ Future[L], fm: ⇒ Future[M], fn: ⇒ Future[N], fo: ⇒ Future[O], fp: ⇒ Future[P], fq: ⇒ Future[Q], fr: ⇒ Future[R], fs: ⇒ Future[S], ft: ⇒ Future[T])(implicit ec: ExecutionContext): Future[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)]

    returns

    a future of a tuple that completes successfully once all futures successfullly complete OR that fails immediately once any future fails.

  11. def run[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](fa: ⇒ Future[A], fb: ⇒ Future[B], fc: ⇒ Future[C], fd: ⇒ Future[D], fe: ⇒ Future[E], ff: ⇒ Future[F], fg: ⇒ Future[G], fh: ⇒ Future[H], fi: ⇒ Future[I], fj: ⇒ Future[J], fk: ⇒ Future[K], fl: ⇒ Future[L], fm: ⇒ Future[M], fn: ⇒ Future[N], fo: ⇒ Future[O], fp: ⇒ Future[P], fq: ⇒ Future[Q], fr: ⇒ Future[R], fs: ⇒ Future[S])(implicit ec: ExecutionContext): Future[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

    returns

    a future of a tuple that completes successfully once all futures successfullly complete OR that fails immediately once any future fails.

  12. def run[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](fa: ⇒ Future[A], fb: ⇒ Future[B], fc: ⇒ Future[C], fd: ⇒ Future[D], fe: ⇒ Future[E], ff: ⇒ Future[F], fg: ⇒ Future[G], fh: ⇒ Future[H], fi: ⇒ Future[I], fj: ⇒ Future[J], fk: ⇒ Future[K], fl: ⇒ Future[L], fm: ⇒ Future[M], fn: ⇒ Future[N], fo: ⇒ Future[O], fp: ⇒ Future[P], fq: ⇒ Future[Q], fr: ⇒ Future[R])(implicit ec: ExecutionContext): Future[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)]

    returns

    a future of a tuple that completes successfully once all futures successfullly complete OR that fails immediately once any future fails.

  13. def run[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](fa: ⇒ Future[A], fb: ⇒ Future[B], fc: ⇒ Future[C], fd: ⇒ Future[D], fe: ⇒ Future[E], ff: ⇒ Future[F], fg: ⇒ Future[G], fh: ⇒ Future[H], fi: ⇒ Future[I], fj: ⇒ Future[J], fk: ⇒ Future[K], fl: ⇒ Future[L], fm: ⇒ Future[M], fn: ⇒ Future[N], fo: ⇒ Future[O], fp: ⇒ Future[P], fq: ⇒ Future[Q])(implicit ec: ExecutionContext): Future[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)]

    returns

    a future of a tuple that completes successfully once all futures successfullly complete OR that fails immediately once any future fails.

  14. def run[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](fa: ⇒ Future[A], fb: ⇒ Future[B], fc: ⇒ Future[C], fd: ⇒ Future[D], fe: ⇒ Future[E], ff: ⇒ Future[F], fg: ⇒ Future[G], fh: ⇒ Future[H], fi: ⇒ Future[I], fj: ⇒ Future[J], fk: ⇒ Future[K], fl: ⇒ Future[L], fm: ⇒ Future[M], fn: ⇒ Future[N], fo: ⇒ Future[O], fp: ⇒ Future[P])(implicit ec: ExecutionContext): Future[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]

    returns

    a future of a tuple that completes successfully once all futures successfullly complete OR that fails immediately once any future fails.

  15. def run[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](fa: ⇒ Future[A], fb: ⇒ Future[B], fc: ⇒ Future[C], fd: ⇒ Future[D], fe: ⇒ Future[E], ff: ⇒ Future[F], fg: ⇒ Future[G], fh: ⇒ Future[H], fi: ⇒ Future[I], fj: ⇒ Future[J], fk: ⇒ Future[K], fl: ⇒ Future[L], fm: ⇒ Future[M], fn: ⇒ Future[N], fo: ⇒ Future[O])(implicit ec: ExecutionContext): Future[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)]

    returns

    a future of a tuple that completes successfully once all futures successfullly complete OR that fails immediately once any future fails.

  16. def run[A, B, C, D, E, F, G, H, I, J, K, L, M, N](fa: ⇒ Future[A], fb: ⇒ Future[B], fc: ⇒ Future[C], fd: ⇒ Future[D], fe: ⇒ Future[E], ff: ⇒ Future[F], fg: ⇒ Future[G], fh: ⇒ Future[H], fi: ⇒ Future[I], fj: ⇒ Future[J], fk: ⇒ Future[K], fl: ⇒ Future[L], fm: ⇒ Future[M], fn: ⇒ Future[N])(implicit ec: ExecutionContext): Future[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)]

    returns

    a future of a tuple that completes successfully once all futures successfullly complete OR that fails immediately once any future fails.

  17. def run[A, B, C, D, E, F, G, H, I, J, K, L, M](fa: ⇒ Future[A], fb: ⇒ Future[B], fc: ⇒ Future[C], fd: ⇒ Future[D], fe: ⇒ Future[E], ff: ⇒ Future[F], fg: ⇒ Future[G], fh: ⇒ Future[H], fi: ⇒ Future[I], fj: ⇒ Future[J], fk: ⇒ Future[K], fl: ⇒ Future[L], fm: ⇒ Future[M])(implicit ec: ExecutionContext): Future[(A, B, C, D, E, F, G, H, I, J, K, L, M)]

    returns

    a future of a tuple that completes successfully once all futures successfullly complete OR that fails immediately once any future fails.

  18. def run[A, B, C, D, E, F, G, H, I, J, K, L](fa: ⇒ Future[A], fb: ⇒ Future[B], fc: ⇒ Future[C], fd: ⇒ Future[D], fe: ⇒ Future[E], ff: ⇒ Future[F], fg: ⇒ Future[G], fh: ⇒ Future[H], fi: ⇒ Future[I], fj: ⇒ Future[J], fk: ⇒ Future[K], fl: ⇒ Future[L])(implicit ec: ExecutionContext): Future[(A, B, C, D, E, F, G, H, I, J, K, L)]

    returns

    a future of a tuple that completes successfully once all futures successfullly complete OR that fails immediately once any future fails.

  19. def run[A, B, C, D, E, F, G, H, I, J, K](fa: ⇒ Future[A], fb: ⇒ Future[B], fc: ⇒ Future[C], fd: ⇒ Future[D], fe: ⇒ Future[E], ff: ⇒ Future[F], fg: ⇒ Future[G], fh: ⇒ Future[H], fi: ⇒ Future[I], fj: ⇒ Future[J], fk: ⇒ Future[K])(implicit ec: ExecutionContext): Future[(A, B, C, D, E, F, G, H, I, J, K)]

    returns

    a future of a tuple that completes successfully once all futures successfullly complete OR that fails immediately once any future fails.

  20. def run[A, B, C, D, E, F, G, H, I, J](fa: ⇒ Future[A], fb: ⇒ Future[B], fc: ⇒ Future[C], fd: ⇒ Future[D], fe: ⇒ Future[E], ff: ⇒ Future[F], fg: ⇒ Future[G], fh: ⇒ Future[H], fi: ⇒ Future[I], fj: ⇒ Future[J])(implicit ec: ExecutionContext): Future[(A, B, C, D, E, F, G, H, I, J)]

    returns

    a future of a tuple that completes successfully once all futures successfullly complete OR that fails immediately once any future fails.

  21. def run[A, B, C, D, E, F, G, H, I](fa: ⇒ Future[A], fb: ⇒ Future[B], fc: ⇒ Future[C], fd: ⇒ Future[D], fe: ⇒ Future[E], ff: ⇒ Future[F], fg: ⇒ Future[G], fh: ⇒ Future[H], fi: ⇒ Future[I])(implicit ec: ExecutionContext): Future[(A, B, C, D, E, F, G, H, I)]

    returns

    a future of a tuple that completes successfully once all futures successfullly complete OR that fails immediately once any future fails.

  22. def run[A, B, C, D, E, F, G, H](fa: ⇒ Future[A], fb: ⇒ Future[B], fc: ⇒ Future[C], fd: ⇒ Future[D], fe: ⇒ Future[E], ff: ⇒ Future[F], fg: ⇒ Future[G], fh: ⇒ Future[H])(implicit ec: ExecutionContext): Future[(A, B, C, D, E, F, G, H)]

    returns

    a future of a tuple that completes successfully once all futures successfullly complete OR that fails immediately once any future fails.

  23. def run[A, B, C, D, E, F, G](fa: ⇒ Future[A], fb: ⇒ Future[B], fc: ⇒ Future[C], fd: ⇒ Future[D], fe: ⇒ Future[E], ff: ⇒ Future[F], fg: ⇒ Future[G])(implicit ec: ExecutionContext): Future[(A, B, C, D, E, F, G)]

    returns

    a future of a tuple that completes successfully once all futures successfullly complete OR that fails immediately once any future fails.

  24. def run[A, B, C, D, E, F](fa: ⇒ Future[A], fb: ⇒ Future[B], fc: ⇒ Future[C], fd: ⇒ Future[D], fe: ⇒ Future[E], ff: ⇒ Future[F])(implicit ec: ExecutionContext): Future[(A, B, C, D, E, F)]

    returns

    a future of a tuple that completes successfully once all futures successfullly complete OR that fails immediately once any future fails.

  25. def run[A, B, C, D, E](fa: ⇒ Future[A], fb: ⇒ Future[B], fc: ⇒ Future[C], fd: ⇒ Future[D], fe: ⇒ Future[E])(implicit ec: ExecutionContext): Future[(A, B, C, D, E)]

    returns

    a future of a tuple that completes successfully once all futures successfullly complete OR that fails immediately once any future fails.

  26. def run[A, B, C, D](fa: ⇒ Future[A], fb: ⇒ Future[B], fc: ⇒ Future[C], fd: ⇒ Future[D])(implicit ec: ExecutionContext): Future[(A, B, C, D)]

    returns

    a future of a tuple that completes successfully once all futures successfullly complete OR that fails immediately once any future fails.

  27. def run[A, B, C](fa: ⇒ Future[A], fb: ⇒ Future[B], fc: ⇒ Future[C])(implicit ec: ExecutionContext): Future[(A, B, C)]

    returns

    a future of a tuple that completes successfully once all futures successfullly complete OR that fails immediately once any future fails.

  28. def run[A, B](fa: ⇒ Future[A], fb: ⇒ Future[B])(implicit ec: ExecutionContext): Future[(A, B)]

    returns

    a future of a tuple that completes successfully once all futures successfullly complete OR that fails immediately once any future fails.

  29. def toString(): String

    Definition Classes
    Any

Inherited from Any

Ungrouped