Packages

object AwsBijections extends NumericInjections

Linear Supertypes
NumericInjections, GeneratedTupleInjections, GeneratedTupleCollectionInjections, LowPriorityInjections, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. AwsBijections
  2. NumericInjections
  3. GeneratedTupleInjections
  4. GeneratedTupleCollectionInjections
  5. LowPriorityInjections
  6. AnyRef
  7. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  5. implicit val byte2Short: Injection[Byte, Short]
    Definition Classes
    NumericInjections
  6. implicit val byte2String: Injection[Byte, String]
    Definition Classes
    NumericInjections
  7. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  8. implicit lazy val double2BigEndian: Injection[Double, Array[Byte]]
    Definition Classes
    NumericInjections
  9. implicit val double2String: Injection[Double, String]
    Definition Classes
    NumericInjections
  10. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  11. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  12. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  13. implicit lazy val float2BigEndian: Injection[Float, Array[Byte]]
    Definition Classes
    NumericInjections
  14. implicit val float2Double: Injection[Float, Double]
    Definition Classes
    NumericInjections
  15. implicit val float2String: Injection[Float, String]
    Definition Classes
    NumericInjections
  16. implicit def fromImplicitBijection[A, B](implicit bij: ImplicitBijection[A, B]): Injection[A, B]
    Definition Classes
    LowPriorityInjections
  17. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
  18. def hashCode(): Int
    Definition Classes
    AnyRef → Any
  19. implicit val int2BigEndian: Injection[Int, Array[Byte]]
    Definition Classes
    NumericInjections
  20. implicit val int2Double: Injection[Int, Double]
    Definition Classes
    NumericInjections
  21. implicit val int2Long: Injection[Int, Long]
    Definition Classes
    NumericInjections
  22. implicit val int2String: Injection[Int, String]
    Definition Classes
    NumericInjections
  23. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  24. implicit val jbyte2String: Injection[Byte, String]
    Definition Classes
    NumericInjections
  25. implicit val jdouble2String: Injection[Double, String]
    Definition Classes
    NumericInjections
  26. implicit val jfloat2String: Injection[Float, String]
    Definition Classes
    NumericInjections
  27. implicit val jint2String: Injection[Integer, String]
    Definition Classes
    NumericInjections
  28. implicit val jlong2String: Injection[Long, String]
    Definition Classes
    NumericInjections
  29. implicit val jshort2String: Injection[Short, String]
    Definition Classes
    NumericInjections
  30. implicit val long2BigEndian: Injection[Long, Array[Byte]]
    Definition Classes
    NumericInjections
  31. implicit val long2BigInt: Injection[Long, BigInt]
    Definition Classes
    NumericInjections
  32. implicit val long2String: Injection[Long, String]
    Definition Classes
    NumericInjections
  33. implicit val longToAttributeValue: Injection[Long, AttributeValue]
  34. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  35. final def notify(): Unit
    Definition Classes
    AnyRef
  36. final def notifyAll(): Unit
    Definition Classes
    AnyRef
  37. implicit val short2BigEndian: Injection[Short, Array[Byte]]
    Definition Classes
    NumericInjections
  38. implicit val short2Int: Injection[Short, Int]
    Definition Classes
    NumericInjections
  39. implicit val short2String: Injection[Short, String]
    Definition Classes
    NumericInjections
  40. implicit val stringToAttributeValue: Bijection[String, AttributeValue]
  41. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  42. def toString(): String
    Definition Classes
    AnyRef → Any
  43. implicit def tuple10[A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, A2, B2, C2, D2, E2, F2, G2, H2, I2, J2](implicit ba: Injection[A1, A2], bb: Injection[B1, B2], bc: Injection[C1, C2], bd: Injection[D1, D2], be: Injection[E1, E2], bf: Injection[F1, F2], bg: Injection[G1, G2], bh: Injection[H1, H2], bi: Injection[I1, I2], bj: Injection[J1, J2]): Injection[(A1, B1, C1, D1, E1, F1, G1, H1, I1, J1), (A2, B2, C2, D2, E2, F2, G2, H2, I2, J2)]
    Definition Classes
    GeneratedTupleInjections
  44. implicit def tuple10ToList[A, B, C, D, E, F, G, H, I, J, K](implicit ba: Injection[A, K], bb: Injection[B, K], bc: Injection[C, K], bd: Injection[D, K], be: Injection[E, K], bf: Injection[F, K], bg: Injection[G, K], bh: Injection[H, K], bi: Injection[I, K], bj: Injection[J, K]): Injection[(A, B, C, D, E, F, G, H, I, J), List[K]]
    Definition Classes
    GeneratedTupleCollectionInjections
  45. implicit def tuple11[A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, A2, B2, C2, D2, E2, F2, G2, H2, I2, J2, K2](implicit ba: Injection[A1, A2], bb: Injection[B1, B2], bc: Injection[C1, C2], bd: Injection[D1, D2], be: Injection[E1, E2], bf: Injection[F1, F2], bg: Injection[G1, G2], bh: Injection[H1, H2], bi: Injection[I1, I2], bj: Injection[J1, J2], bk: Injection[K1, K2]): Injection[(A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1), (A2, B2, C2, D2, E2, F2, G2, H2, I2, J2, K2)]
    Definition Classes
    GeneratedTupleInjections
  46. implicit def tuple11ToList[A, B, C, D, E, F, G, H, I, J, K, L](implicit ba: Injection[A, L], bb: Injection[B, L], bc: Injection[C, L], bd: Injection[D, L], be: Injection[E, L], bf: Injection[F, L], bg: Injection[G, L], bh: Injection[H, L], bi: Injection[I, L], bj: Injection[J, L], bk: Injection[K, L]): Injection[(A, B, C, D, E, F, G, H, I, J, K), List[L]]
    Definition Classes
    GeneratedTupleCollectionInjections
  47. implicit def tuple12[A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, A2, B2, C2, D2, E2, F2, G2, H2, I2, J2, K2, L2](implicit ba: Injection[A1, A2], bb: Injection[B1, B2], bc: Injection[C1, C2], bd: Injection[D1, D2], be: Injection[E1, E2], bf: Injection[F1, F2], bg: Injection[G1, G2], bh: Injection[H1, H2], bi: Injection[I1, I2], bj: Injection[J1, J2], bk: Injection[K1, K2], bl: Injection[L1, L2]): Injection[(A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1), (A2, B2, C2, D2, E2, F2, G2, H2, I2, J2, K2, L2)]
    Definition Classes
    GeneratedTupleInjections
  48. implicit def tuple12ToList[A, B, C, D, E, F, G, H, I, J, K, L, M](implicit ba: Injection[A, M], bb: Injection[B, M], bc: Injection[C, M], bd: Injection[D, M], be: Injection[E, M], bf: Injection[F, M], bg: Injection[G, M], bh: Injection[H, M], bi: Injection[I, M], bj: Injection[J, M], bk: Injection[K, M], bl: Injection[L, M]): Injection[(A, B, C, D, E, F, G, H, I, J, K, L), List[M]]
    Definition Classes
    GeneratedTupleCollectionInjections
  49. implicit def tuple13[A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, A2, B2, C2, D2, E2, F2, G2, H2, I2, J2, K2, L2, M2](implicit ba: Injection[A1, A2], bb: Injection[B1, B2], bc: Injection[C1, C2], bd: Injection[D1, D2], be: Injection[E1, E2], bf: Injection[F1, F2], bg: Injection[G1, G2], bh: Injection[H1, H2], bi: Injection[I1, I2], bj: Injection[J1, J2], bk: Injection[K1, K2], bl: Injection[L1, L2], bm: Injection[M1, M2]): Injection[(A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1), (A2, B2, C2, D2, E2, F2, G2, H2, I2, J2, K2, L2, M2)]
    Definition Classes
    GeneratedTupleInjections
  50. implicit def tuple13ToList[A, B, C, D, E, F, G, H, I, J, K, L, M, N](implicit ba: Injection[A, N], bb: Injection[B, N], bc: Injection[C, N], bd: Injection[D, N], be: Injection[E, N], bf: Injection[F, N], bg: Injection[G, N], bh: Injection[H, N], bi: Injection[I, N], bj: Injection[J, N], bk: Injection[K, N], bl: Injection[L, N], bm: Injection[M, N]): Injection[(A, B, C, D, E, F, G, H, I, J, K, L, M), List[N]]
    Definition Classes
    GeneratedTupleCollectionInjections
  51. implicit def tuple14[A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, A2, B2, C2, D2, E2, F2, G2, H2, I2, J2, K2, L2, M2, N2](implicit ba: Injection[A1, A2], bb: Injection[B1, B2], bc: Injection[C1, C2], bd: Injection[D1, D2], be: Injection[E1, E2], bf: Injection[F1, F2], bg: Injection[G1, G2], bh: Injection[H1, H2], bi: Injection[I1, I2], bj: Injection[J1, J2], bk: Injection[K1, K2], bl: Injection[L1, L2], bm: Injection[M1, M2], bn: Injection[N1, N2]): Injection[(A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1), (A2, B2, C2, D2, E2, F2, G2, H2, I2, J2, K2, L2, M2, N2)]
    Definition Classes
    GeneratedTupleInjections
  52. implicit def tuple14ToList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](implicit ba: Injection[A, O], bb: Injection[B, O], bc: Injection[C, O], bd: Injection[D, O], be: Injection[E, O], bf: Injection[F, O], bg: Injection[G, O], bh: Injection[H, O], bi: Injection[I, O], bj: Injection[J, O], bk: Injection[K, O], bl: Injection[L, O], bm: Injection[M, O], bn: Injection[N, O]): Injection[(A, B, C, D, E, F, G, H, I, J, K, L, M, N), List[O]]
    Definition Classes
    GeneratedTupleCollectionInjections
  53. implicit def tuple15[A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, A2, B2, C2, D2, E2, F2, G2, H2, I2, J2, K2, L2, M2, N2, O2](implicit ba: Injection[A1, A2], bb: Injection[B1, B2], bc: Injection[C1, C2], bd: Injection[D1, D2], be: Injection[E1, E2], bf: Injection[F1, F2], bg: Injection[G1, G2], bh: Injection[H1, H2], bi: Injection[I1, I2], bj: Injection[J1, J2], bk: Injection[K1, K2], bl: Injection[L1, L2], bm: Injection[M1, M2], bn: Injection[N1, N2], bo: Injection[O1, O2]): Injection[(A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1), (A2, B2, C2, D2, E2, F2, G2, H2, I2, J2, K2, L2, M2, N2, O2)]
    Definition Classes
    GeneratedTupleInjections
  54. implicit def tuple15ToList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](implicit ba: Injection[A, P], bb: Injection[B, P], bc: Injection[C, P], bd: Injection[D, P], be: Injection[E, P], bf: Injection[F, P], bg: Injection[G, P], bh: Injection[H, P], bi: Injection[I, P], bj: Injection[J, P], bk: Injection[K, P], bl: Injection[L, P], bm: Injection[M, P], bn: Injection[N, P], bo: Injection[O, P]): Injection[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), List[P]]
    Definition Classes
    GeneratedTupleCollectionInjections
  55. implicit def tuple16[A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, A2, B2, C2, D2, E2, F2, G2, H2, I2, J2, K2, L2, M2, N2, O2, P2](implicit ba: Injection[A1, A2], bb: Injection[B1, B2], bc: Injection[C1, C2], bd: Injection[D1, D2], be: Injection[E1, E2], bf: Injection[F1, F2], bg: Injection[G1, G2], bh: Injection[H1, H2], bi: Injection[I1, I2], bj: Injection[J1, J2], bk: Injection[K1, K2], bl: Injection[L1, L2], bm: Injection[M1, M2], bn: Injection[N1, N2], bo: Injection[O1, O2], bp: Injection[P1, P2]): Injection[(A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1), (A2, B2, C2, D2, E2, F2, G2, H2, I2, J2, K2, L2, M2, N2, O2, P2)]
    Definition Classes
    GeneratedTupleInjections
  56. implicit def tuple16ToList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](implicit ba: Injection[A, Q], bb: Injection[B, Q], bc: Injection[C, Q], bd: Injection[D, Q], be: Injection[E, Q], bf: Injection[F, Q], bg: Injection[G, Q], bh: Injection[H, Q], bi: Injection[I, Q], bj: Injection[J, Q], bk: Injection[K, Q], bl: Injection[L, Q], bm: Injection[M, Q], bn: Injection[N, Q], bo: Injection[O, Q], bp: Injection[P, Q]): Injection[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), List[Q]]
    Definition Classes
    GeneratedTupleCollectionInjections
  57. implicit def tuple17[A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, A2, B2, C2, D2, E2, F2, G2, H2, I2, J2, K2, L2, M2, N2, O2, P2, Q2](implicit ba: Injection[A1, A2], bb: Injection[B1, B2], bc: Injection[C1, C2], bd: Injection[D1, D2], be: Injection[E1, E2], bf: Injection[F1, F2], bg: Injection[G1, G2], bh: Injection[H1, H2], bi: Injection[I1, I2], bj: Injection[J1, J2], bk: Injection[K1, K2], bl: Injection[L1, L2], bm: Injection[M1, M2], bn: Injection[N1, N2], bo: Injection[O1, O2], bp: Injection[P1, P2], bq: Injection[Q1, Q2]): Injection[(A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1), (A2, B2, C2, D2, E2, F2, G2, H2, I2, J2, K2, L2, M2, N2, O2, P2, Q2)]
    Definition Classes
    GeneratedTupleInjections
  58. implicit def tuple17ToList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](implicit ba: Injection[A, R], bb: Injection[B, R], bc: Injection[C, R], bd: Injection[D, R], be: Injection[E, R], bf: Injection[F, R], bg: Injection[G, R], bh: Injection[H, R], bi: Injection[I, R], bj: Injection[J, R], bk: Injection[K, R], bl: Injection[L, R], bm: Injection[M, R], bn: Injection[N, R], bo: Injection[O, R], bp: Injection[P, R], bq: Injection[Q, R]): Injection[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q), List[R]]
    Definition Classes
    GeneratedTupleCollectionInjections
  59. implicit def tuple18[A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, A2, B2, C2, D2, E2, F2, G2, H2, I2, J2, K2, L2, M2, N2, O2, P2, Q2, R2](implicit ba: Injection[A1, A2], bb: Injection[B1, B2], bc: Injection[C1, C2], bd: Injection[D1, D2], be: Injection[E1, E2], bf: Injection[F1, F2], bg: Injection[G1, G2], bh: Injection[H1, H2], bi: Injection[I1, I2], bj: Injection[J1, J2], bk: Injection[K1, K2], bl: Injection[L1, L2], bm: Injection[M1, M2], bn: Injection[N1, N2], bo: Injection[O1, O2], bp: Injection[P1, P2], bq: Injection[Q1, Q2], br: Injection[R1, R2]): Injection[(A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1), (A2, B2, C2, D2, E2, F2, G2, H2, I2, J2, K2, L2, M2, N2, O2, P2, Q2, R2)]
    Definition Classes
    GeneratedTupleInjections
  60. implicit def tuple18ToList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](implicit ba: Injection[A, S], bb: Injection[B, S], bc: Injection[C, S], bd: Injection[D, S], be: Injection[E, S], bf: Injection[F, S], bg: Injection[G, S], bh: Injection[H, S], bi: Injection[I, S], bj: Injection[J, S], bk: Injection[K, S], bl: Injection[L, S], bm: Injection[M, S], bn: Injection[N, S], bo: Injection[O, S], bp: Injection[P, S], bq: Injection[Q, S], br: Injection[R, S]): Injection[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R), List[S]]
    Definition Classes
    GeneratedTupleCollectionInjections
  61. implicit def tuple19[A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, A2, B2, C2, D2, E2, F2, G2, H2, I2, J2, K2, L2, M2, N2, O2, P2, Q2, R2, S2](implicit ba: Injection[A1, A2], bb: Injection[B1, B2], bc: Injection[C1, C2], bd: Injection[D1, D2], be: Injection[E1, E2], bf: Injection[F1, F2], bg: Injection[G1, G2], bh: Injection[H1, H2], bi: Injection[I1, I2], bj: Injection[J1, J2], bk: Injection[K1, K2], bl: Injection[L1, L2], bm: Injection[M1, M2], bn: Injection[N1, N2], bo: Injection[O1, O2], bp: Injection[P1, P2], bq: Injection[Q1, Q2], br: Injection[R1, R2], bs: Injection[S1, S2]): Injection[(A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1), (A2, B2, C2, D2, E2, F2, G2, H2, I2, J2, K2, L2, M2, N2, O2, P2, Q2, R2, S2)]
    Definition Classes
    GeneratedTupleInjections
  62. implicit def tuple19ToList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](implicit ba: Injection[A, T], bb: Injection[B, T], bc: Injection[C, T], bd: Injection[D, T], be: Injection[E, T], bf: Injection[F, T], bg: Injection[G, T], bh: Injection[H, T], bi: Injection[I, T], bj: Injection[J, T], bk: Injection[K, T], bl: Injection[L, T], bm: Injection[M, T], bn: Injection[N, T], bo: Injection[O, T], bp: Injection[P, T], bq: Injection[Q, T], br: Injection[R, T], bs: Injection[S, T]): Injection[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), List[T]]
    Definition Classes
    GeneratedTupleCollectionInjections
  63. implicit def tuple2[A1, B1, A2, B2](implicit ba: Injection[A1, A2], bb: Injection[B1, B2]): Injection[(A1, B1), (A2, B2)]
    Definition Classes
    GeneratedTupleInjections
  64. implicit def tuple20[A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, A2, B2, C2, D2, E2, F2, G2, H2, I2, J2, K2, L2, M2, N2, O2, P2, Q2, R2, S2, T2](implicit ba: Injection[A1, A2], bb: Injection[B1, B2], bc: Injection[C1, C2], bd: Injection[D1, D2], be: Injection[E1, E2], bf: Injection[F1, F2], bg: Injection[G1, G2], bh: Injection[H1, H2], bi: Injection[I1, I2], bj: Injection[J1, J2], bk: Injection[K1, K2], bl: Injection[L1, L2], bm: Injection[M1, M2], bn: Injection[N1, N2], bo: Injection[O1, O2], bp: Injection[P1, P2], bq: Injection[Q1, Q2], br: Injection[R1, R2], bs: Injection[S1, S2], bt: Injection[T1, T2]): Injection[(A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1), (A2, B2, C2, D2, E2, F2, G2, H2, I2, J2, K2, L2, M2, N2, O2, P2, Q2, R2, S2, T2)]
    Definition Classes
    GeneratedTupleInjections
  65. implicit def tuple20ToList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](implicit ba: Injection[A, U], bb: Injection[B, U], bc: Injection[C, U], bd: Injection[D, U], be: Injection[E, U], bf: Injection[F, U], bg: Injection[G, U], bh: Injection[H, U], bi: Injection[I, U], bj: Injection[J, U], bk: Injection[K, U], bl: Injection[L, U], bm: Injection[M, U], bn: Injection[N, U], bo: Injection[O, U], bp: Injection[P, U], bq: Injection[Q, U], br: Injection[R, U], bs: Injection[S, U], bt: Injection[T, U]): Injection[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T), List[U]]
    Definition Classes
    GeneratedTupleCollectionInjections
  66. implicit def tuple21[A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, A2, B2, C2, D2, E2, F2, G2, H2, I2, J2, K2, L2, M2, N2, O2, P2, Q2, R2, S2, T2, U2](implicit ba: Injection[A1, A2], bb: Injection[B1, B2], bc: Injection[C1, C2], bd: Injection[D1, D2], be: Injection[E1, E2], bf: Injection[F1, F2], bg: Injection[G1, G2], bh: Injection[H1, H2], bi: Injection[I1, I2], bj: Injection[J1, J2], bk: Injection[K1, K2], bl: Injection[L1, L2], bm: Injection[M1, M2], bn: Injection[N1, N2], bo: Injection[O1, O2], bp: Injection[P1, P2], bq: Injection[Q1, Q2], br: Injection[R1, R2], bs: Injection[S1, S2], bt: Injection[T1, T2], bu: Injection[U1, U2]): Injection[(A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1), (A2, B2, C2, D2, E2, F2, G2, H2, I2, J2, K2, L2, M2, N2, O2, P2, Q2, R2, S2, T2, U2)]
    Definition Classes
    GeneratedTupleInjections
  67. implicit def tuple21ToList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](implicit ba: Injection[A, V], bb: Injection[B, V], bc: Injection[C, V], bd: Injection[D, V], be: Injection[E, V], bf: Injection[F, V], bg: Injection[G, V], bh: Injection[H, V], bi: Injection[I, V], bj: Injection[J, V], bk: Injection[K, V], bl: Injection[L, V], bm: Injection[M, V], bn: Injection[N, V], bo: Injection[O, V], bp: Injection[P, V], bq: Injection[Q, V], br: Injection[R, V], bs: Injection[S, V], bt: Injection[T, V], bu: Injection[U, V]): Injection[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U), List[V]]
    Definition Classes
    GeneratedTupleCollectionInjections
  68. implicit def tuple22[A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, A2, B2, C2, D2, E2, F2, G2, H2, I2, J2, K2, L2, M2, N2, O2, P2, Q2, R2, S2, T2, U2, V2](implicit ba: Injection[A1, A2], bb: Injection[B1, B2], bc: Injection[C1, C2], bd: Injection[D1, D2], be: Injection[E1, E2], bf: Injection[F1, F2], bg: Injection[G1, G2], bh: Injection[H1, H2], bi: Injection[I1, I2], bj: Injection[J1, J2], bk: Injection[K1, K2], bl: Injection[L1, L2], bm: Injection[M1, M2], bn: Injection[N1, N2], bo: Injection[O1, O2], bp: Injection[P1, P2], bq: Injection[Q1, Q2], br: Injection[R1, R2], bs: Injection[S1, S2], bt: Injection[T1, T2], bu: Injection[U1, U2], bv: Injection[V1, V2]): Injection[(A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1), (A2, B2, C2, D2, E2, F2, G2, H2, I2, J2, K2, L2, M2, N2, O2, P2, Q2, R2, S2, T2, U2, V2)]
    Definition Classes
    GeneratedTupleInjections
  69. implicit def tuple22ToList[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W](implicit ba: Injection[A, W], bb: Injection[B, W], bc: Injection[C, W], bd: Injection[D, W], be: Injection[E, W], bf: Injection[F, W], bg: Injection[G, W], bh: Injection[H, W], bi: Injection[I, W], bj: Injection[J, W], bk: Injection[K, W], bl: Injection[L, W], bm: Injection[M, W], bn: Injection[N, W], bo: Injection[O, W], bp: Injection[P, W], bq: Injection[Q, W], br: Injection[R, W], bs: Injection[S, W], bt: Injection[T, W], bu: Injection[U, W], bv: Injection[V, W]): Injection[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V), List[W]]
    Definition Classes
    GeneratedTupleCollectionInjections
  70. implicit def tuple2ToList[A, B, C](implicit ba: Injection[A, C], bb: Injection[B, C]): Injection[(A, B), List[C]]
    Definition Classes
    GeneratedTupleCollectionInjections
  71. implicit def tuple3[A1, B1, C1, A2, B2, C2](implicit ba: Injection[A1, A2], bb: Injection[B1, B2], bc: Injection[C1, C2]): Injection[(A1, B1, C1), (A2, B2, C2)]
    Definition Classes
    GeneratedTupleInjections
  72. implicit def tuple3ToList[A, B, C, D](implicit ba: Injection[A, D], bb: Injection[B, D], bc: Injection[C, D]): Injection[(A, B, C), List[D]]
    Definition Classes
    GeneratedTupleCollectionInjections
  73. implicit def tuple4[A1, B1, C1, D1, A2, B2, C2, D2](implicit ba: Injection[A1, A2], bb: Injection[B1, B2], bc: Injection[C1, C2], bd: Injection[D1, D2]): Injection[(A1, B1, C1, D1), (A2, B2, C2, D2)]
    Definition Classes
    GeneratedTupleInjections
  74. implicit def tuple4ToList[A, B, C, D, E](implicit ba: Injection[A, E], bb: Injection[B, E], bc: Injection[C, E], bd: Injection[D, E]): Injection[(A, B, C, D), List[E]]
    Definition Classes
    GeneratedTupleCollectionInjections
  75. implicit def tuple5[A1, B1, C1, D1, E1, A2, B2, C2, D2, E2](implicit ba: Injection[A1, A2], bb: Injection[B1, B2], bc: Injection[C1, C2], bd: Injection[D1, D2], be: Injection[E1, E2]): Injection[(A1, B1, C1, D1, E1), (A2, B2, C2, D2, E2)]
    Definition Classes
    GeneratedTupleInjections
  76. implicit def tuple5ToList[A, B, C, D, E, F](implicit ba: Injection[A, F], bb: Injection[B, F], bc: Injection[C, F], bd: Injection[D, F], be: Injection[E, F]): Injection[(A, B, C, D, E), List[F]]
    Definition Classes
    GeneratedTupleCollectionInjections
  77. implicit def tuple6[A1, B1, C1, D1, E1, F1, A2, B2, C2, D2, E2, F2](implicit ba: Injection[A1, A2], bb: Injection[B1, B2], bc: Injection[C1, C2], bd: Injection[D1, D2], be: Injection[E1, E2], bf: Injection[F1, F2]): Injection[(A1, B1, C1, D1, E1, F1), (A2, B2, C2, D2, E2, F2)]
    Definition Classes
    GeneratedTupleInjections
  78. implicit def tuple6ToList[A, B, C, D, E, F, G](implicit ba: Injection[A, G], bb: Injection[B, G], bc: Injection[C, G], bd: Injection[D, G], be: Injection[E, G], bf: Injection[F, G]): Injection[(A, B, C, D, E, F), List[G]]
    Definition Classes
    GeneratedTupleCollectionInjections
  79. implicit def tuple7[A1, B1, C1, D1, E1, F1, G1, A2, B2, C2, D2, E2, F2, G2](implicit ba: Injection[A1, A2], bb: Injection[B1, B2], bc: Injection[C1, C2], bd: Injection[D1, D2], be: Injection[E1, E2], bf: Injection[F1, F2], bg: Injection[G1, G2]): Injection[(A1, B1, C1, D1, E1, F1, G1), (A2, B2, C2, D2, E2, F2, G2)]
    Definition Classes
    GeneratedTupleInjections
  80. implicit def tuple7ToList[A, B, C, D, E, F, G, H](implicit ba: Injection[A, H], bb: Injection[B, H], bc: Injection[C, H], bd: Injection[D, H], be: Injection[E, H], bf: Injection[F, H], bg: Injection[G, H]): Injection[(A, B, C, D, E, F, G), List[H]]
    Definition Classes
    GeneratedTupleCollectionInjections
  81. implicit def tuple8[A1, B1, C1, D1, E1, F1, G1, H1, A2, B2, C2, D2, E2, F2, G2, H2](implicit ba: Injection[A1, A2], bb: Injection[B1, B2], bc: Injection[C1, C2], bd: Injection[D1, D2], be: Injection[E1, E2], bf: Injection[F1, F2], bg: Injection[G1, G2], bh: Injection[H1, H2]): Injection[(A1, B1, C1, D1, E1, F1, G1, H1), (A2, B2, C2, D2, E2, F2, G2, H2)]
    Definition Classes
    GeneratedTupleInjections
  82. implicit def tuple8ToList[A, B, C, D, E, F, G, H, I](implicit ba: Injection[A, I], bb: Injection[B, I], bc: Injection[C, I], bd: Injection[D, I], be: Injection[E, I], bf: Injection[F, I], bg: Injection[G, I], bh: Injection[H, I]): Injection[(A, B, C, D, E, F, G, H), List[I]]
    Definition Classes
    GeneratedTupleCollectionInjections
  83. implicit def tuple9[A1, B1, C1, D1, E1, F1, G1, H1, I1, A2, B2, C2, D2, E2, F2, G2, H2, I2](implicit ba: Injection[A1, A2], bb: Injection[B1, B2], bc: Injection[C1, C2], bd: Injection[D1, D2], be: Injection[E1, E2], bf: Injection[F1, F2], bg: Injection[G1, G2], bh: Injection[H1, H2], bi: Injection[I1, I2]): Injection[(A1, B1, C1, D1, E1, F1, G1, H1, I1), (A2, B2, C2, D2, E2, F2, G2, H2, I2)]
    Definition Classes
    GeneratedTupleInjections
  84. implicit def tuple9ToList[A, B, C, D, E, F, G, H, I, J](implicit ba: Injection[A, J], bb: Injection[B, J], bc: Injection[C, J], bd: Injection[D, J], be: Injection[E, J], bf: Injection[F, J], bg: Injection[G, J], bh: Injection[H, J], bi: Injection[I, J]): Injection[(A, B, C, D, E, F, G, H, I), List[J]]
    Definition Classes
    GeneratedTupleCollectionInjections
  85. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  86. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  87. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

Inherited from NumericInjections

Inherited from GeneratedTupleInjections

Inherited from GeneratedTupleCollectionInjections

Inherited from LowPriorityInjections

Inherited from AnyRef

Inherited from Any

Ungrouped