abstract class Proxy extends AnyRef
A Proxy
provides the machinery to map mocked invocations to predefined results
and check some constraints on the way.
Linear Supertypes
Ordering
- Alphabetic
- By Inheritance
Inherited
- Proxy
- AnyRef
- Any
- Hide All
- Show All
Visibility
- Public
- Protected
Instance Constructors
- new Proxy()
Abstract Value Members
- abstract def invoke[RIn <: Has[_], ROut, Input, Error, Value](capability: Capability[RIn, Input, Error, Value], input: Input): ZIO[ROut, Error, Value]
Concrete Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def apply[RIn <: Has[_], ROut, Error, Value, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](capability: Capability[RIn, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V), Error, Value], a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J, k: K, l: L, m: M, n: N, o: O, p: P, q: Q, r: R, s: S, t: T, u: U, v: V): ZIO[ROut, Error, Value]
- final def apply[RIn <: Has[_], ROut, Error, Value, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](capability: Capability[RIn, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U), Error, Value], a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J, k: K, l: L, m: M, n: N, o: O, p: P, q: Q, r: R, s: S, t: T, u: U): ZIO[ROut, Error, Value]
- final def apply[RIn <: Has[_], ROut, Error, Value, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](capability: Capability[RIn, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T), Error, Value], a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J, k: K, l: L, m: M, n: N, o: O, p: P, q: Q, r: R, s: S, t: T): ZIO[ROut, Error, Value]
- final def apply[RIn <: Has[_], ROut, Error, Value, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](capability: Capability[RIn, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), Error, Value], a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J, k: K, l: L, m: M, n: N, o: O, p: P, q: Q, r: R, s: S): ZIO[ROut, Error, Value]
- final def apply[RIn <: Has[_], ROut, Error, Value, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](capability: Capability[RIn, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R), Error, Value], a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J, k: K, l: L, m: M, n: N, o: O, p: P, q: Q, r: R): ZIO[ROut, Error, Value]
- final def apply[RIn <: Has[_], ROut, Error, Value, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](capability: Capability[RIn, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q), Error, Value], a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J, k: K, l: L, m: M, n: N, o: O, p: P, q: Q): ZIO[ROut, Error, Value]
- final def apply[RIn <: Has[_], ROut, Error, Value, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](capability: Capability[RIn, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), Error, Value], a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J, k: K, l: L, m: M, n: N, o: O, p: P): ZIO[ROut, Error, Value]
- final def apply[RIn <: Has[_], ROut, Error, Value, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](capability: Capability[RIn, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), Error, Value], a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J, k: K, l: L, m: M, n: N, o: O): ZIO[ROut, Error, Value]
- final def apply[RIn <: Has[_], ROut, Error, Value, A, B, C, D, E, F, G, H, I, J, K, L, M, N](capability: Capability[RIn, (A, B, C, D, E, F, G, H, I, J, K, L, M, N), Error, Value], a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J, k: K, l: L, m: M, n: N): ZIO[ROut, Error, Value]
- final def apply[RIn <: Has[_], ROut, Error, Value, A, B, C, D, E, F, G, H, I, J, K, L, M](capability: Capability[RIn, (A, B, C, D, E, F, G, H, I, J, K, L, M), Error, Value], a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J, k: K, l: L, m: M): ZIO[ROut, Error, Value]
- final def apply[RIn <: Has[_], ROut, Error, Value, A, B, C, D, E, F, G, H, I, J, K, L](capability: Capability[RIn, (A, B, C, D, E, F, G, H, I, J, K, L), Error, Value], a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J, k: K, l: L): ZIO[ROut, Error, Value]
- final def apply[RIn <: Has[_], ROut, Error, Value, A, B, C, D, E, F, G, H, I, J, K](capability: Capability[RIn, (A, B, C, D, E, F, G, H, I, J, K), Error, Value], a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J, k: K): ZIO[ROut, Error, Value]
- final def apply[RIn <: Has[_], ROut, Error, Value, A, B, C, D, E, F, G, H, I, J](capability: Capability[RIn, (A, B, C, D, E, F, G, H, I, J), Error, Value], a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J): ZIO[ROut, Error, Value]
- final def apply[RIn <: Has[_], ROut, Error, Value, A, B, C, D, E, F, G, H, I](capability: Capability[RIn, (A, B, C, D, E, F, G, H, I), Error, Value], a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I): ZIO[ROut, Error, Value]
- final def apply[RIn <: Has[_], ROut, Error, Value, A, B, C, D, E, F, G, H](capability: Capability[RIn, (A, B, C, D, E, F, G, H), Error, Value], a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H): ZIO[ROut, Error, Value]
- final def apply[RIn <: Has[_], ROut, Error, Value, A, B, C, D, E, F, G](capability: Capability[RIn, (A, B, C, D, E, F, G), Error, Value], a: A, b: B, c: C, d: D, e: E, f: F, g: G): ZIO[ROut, Error, Value]
- final def apply[RIn <: Has[_], ROut, Error, Value, A, B, C, D, E, F](capability: Capability[RIn, (A, B, C, D, E, F), Error, Value], a: A, b: B, c: C, d: D, e: E, f: F): ZIO[ROut, Error, Value]
- final def apply[RIn <: Has[_], ROut, Error, Value, A, B, C, D, E](capability: Capability[RIn, (A, B, C, D, E), Error, Value], a: A, b: B, c: C, d: D, e: E): ZIO[ROut, Error, Value]
- final def apply[RIn <: Has[_], ROut, Error, Value, A, B, C, D](capability: Capability[RIn, (A, B, C, D), Error, Value], a: A, b: B, c: C, d: D): ZIO[ROut, Error, Value]
- final def apply[RIn <: Has[_], ROut, Error, Value, A, B, C](capability: Capability[RIn, (A, B, C), Error, Value], a: A, b: B, c: C): ZIO[ROut, Error, Value]
- final def apply[RIn <: Has[_], ROut, Error, Value, A, B](capability: Capability[RIn, (A, B), Error, Value], a: A, b: B): ZIO[ROut, Error, Value]
- final def apply[RIn <: Has[_], ROut, Error, Value, A](capability: Capability[RIn, A, Error, Value], a: A): ZIO[ROut, Error, Value]
- final def apply[RIn <: Has[_], ROut, Error, Value](capability: Capability[RIn, Unit, Error, Value]): ZIO[ROut, Error, Value]
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toString(): String
- Definition Classes
- AnyRef → Any
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()