FoldSelectorBuilder

Instance Constructors

new FoldSelectorBuilder(nCases: Int)

Type Members

type HandleFunction[A] = (ExecutionContext, FlowTermination[T], A) ⇒ Future[T]
type R = T
type timeout = FiniteDuration

Definition Classes
SelectorBuilder

Abstract Value Members

abstract def api: GopherAPI

Definition Classes
SelectorBuilder

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 asInstanceOf[T0]: T0

Definition Classes
Any
def beforeRefresh(): Unit
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
implicit def ec: ExecutionContext

Definition Classes
SelectorBuilder
val effectedInputs: Array[FoldSelectorEffectedInput[_, T]]
val effectedOutputs: Array[FoldSelectorEffectedOutput[_, T]]
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def futureInput[A](f: Future[A]): FutureInput[A]

Definition Classes
SelectorBuilder
Annotations
@inline()
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
final def go: Future[T]

Definition Classes
SelectorBuilder
val handleFunctions: Array[HandleFunction[_]]
val handleOutputVars: Array[Function0[_]]
def hashCode(): Int

Definition Classes
AnyRef → Any
macro def idle(body: T): FoldSelectorBuilder[T]
val inputIndices: IntIndexedCounterReverse[Input[_]]
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def normalizedDispatchReader[A]: AuxF[A, T]
def normalizedDispatchWriter[A]: AuxF[A, T]
def normalizedPlainReader[A](f: HandleFunction[A], ch: Input[A]): AuxF[A, T]
def normalizedWriter[A](f: HandleFunction[A], x: ⇒ A, ch: Output[A]): AuxF[A, T]
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def onIdle(arg: SkipSelectorArgument[T]): FoldSelectorBuilder.this.type

Definition Classes
SelectorBuilder
def onRead[E](ch: Input[E])(arg: ReadSelectorArgument[E, T]): FoldSelectorBuilder.this.type

Definition Classes
SelectorBuilder
def onTimeout(t: FiniteDuration)(arg: SkipSelectorArgument[T]): FoldSelectorBuilder.this.type

Definition Classes
SelectorBuilder
def onWrite[E](ch: Output[E])(arg: WriteSelectorArgument[E, T]): FoldSelectorBuilder.this.type

Definition Classes
SelectorBuilder
val outputIndices: IntIndexedCounterReverse[Output[_]]
macro def reading[A](ch: Input[A])(f: (A) ⇒ T): FoldSelectorBuilder[T]
def readingWithFlowTerminationAsync[A](ch: Input[A], f: (ExecutionContext, FlowTermination[T], A) ⇒ Future[T]): FoldSelectorBuilder.this.type
def reregisterIndices(): Unit
def reregisterInputIndices(): Unit
def reregisterOutputIndices(): Unit
def selectorRun: Future[T]

Definition Classes
SelectorBuilder
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
macro def timeout(t: FiniteDuration)(f: (FiniteDuration) ⇒ T): FoldSelectorBuilder[T]
def timeoutWithFlowTerminationAsync(t: FiniteDuration, f: (ExecutionContext, FlowTermination[T], FiniteDuration) ⇒ Future[T]): FoldSelectorBuilder.this.type

Annotations
@inline()
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def withIdle(f: (Skip[T]) ⇒ Option[Future[Continuated[T]]]): FoldSelectorBuilder.this.type

Definition Classes
SelectorBuilder
Annotations
@inline()
def withReader[B](ch: Input[B], f: (ContRead[B, T]) ⇒ Option[(In[B]) ⇒ Future[Continuated[T]]]): FoldSelectorBuilder.this.type

Definition Classes
SelectorBuilder
Annotations
@inline()
def withTimeout(t: FiniteDuration)(f: (Skip[T]) ⇒ Option[Future[Continuated[T]]]): FoldSelectorBuilder.this.type

Definition Classes
SelectorBuilder
Annotations
@inline()
def withWriter[B](ch: Output[B], f: (ContWrite[B, T]) ⇒ Option[(B, Future[Continuated[T]])]): FoldSelectorBuilder.this.type

Definition Classes
SelectorBuilder
Annotations
@inline()
macro def writing[A](ch: Output[A], x: A)(f: (A) ⇒ T): FoldSelectorBuilder[T]
def writingWithFlowTerminationAsync[A](ch: Output[A], x: ⇒ A, f: (ExecutionContext, FlowTermination[T], A) ⇒ Future[T]): FoldSelectorBuilder.this.type

Annotations
@inline()

Related Docs: object FoldSelectorBuilder | package channels

abstract class FoldSelectorBuilder[T] extends SelectorBuilder[T]

Instance Constructors

new FoldSelectorBuilder(nCases: Int)

Type Members

type HandleFunction[A] = (ExecutionContext, FlowTermination[T], A) ⇒ Future[T]

type R = T

type timeout = FiniteDuration

Abstract Value Members

abstract def api: GopherAPI

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def beforeRefresh(): Unit

def clone(): AnyRef

implicit def ec: ExecutionContext

val effectedInputs: Array[FoldSelectorEffectedInput[_, T]]

val effectedOutputs: Array[FoldSelectorEffectedOutput[_, T]]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def futureInput[A](f: Future[A]): FutureInput[A]

final def getClass(): Class[_]

final def go: Future[T]

val handleFunctions: Array[HandleFunction[_]]

val handleOutputVars: Array[Function0[_]]

def hashCode(): Int

macro def idle(body: T): FoldSelectorBuilder[T]

val inputIndices: IntIndexedCounterReverse[Input[_]]

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

def normalizedDispatchReader[A]: AuxF[A, T]

def normalizedDispatchWriter[A]: AuxF[A, T]

def normalizedPlainReader[A](f: HandleFunction[A], ch: Input[A]): AuxF[A, T]

def normalizedWriter[A](f: HandleFunction[A], x: ⇒ A, ch: Output[A]): AuxF[A, T]

final def notify(): Unit

final def notifyAll(): Unit

def onIdle(arg: SkipSelectorArgument[T]): FoldSelectorBuilder.this.type

def onRead[E](ch: Input[E])(arg: ReadSelectorArgument[E, T]): FoldSelectorBuilder.this.type

def onTimeout(t: FiniteDuration)(arg: SkipSelectorArgument[T]): FoldSelectorBuilder.this.type

def onWrite[E](ch: Output[E])(arg: WriteSelectorArgument[E, T]): FoldSelectorBuilder.this.type

val outputIndices: IntIndexedCounterReverse[Output[_]]

macro def reading[A](ch: Input[A])(f: (A) ⇒ T): FoldSelectorBuilder[T]

def readingWithFlowTerminationAsync[A](ch: Input[A], f: (ExecutionContext, FlowTermination[T], A) ⇒ Future[T]): FoldSelectorBuilder.this.type

def reregisterIndices(): Unit

def reregisterInputIndices(): Unit

def reregisterOutputIndices(): Unit

def selectorRun: Future[T]

final def synchronized[T0](arg0: ⇒ T0): T0

macro def timeout(t: FiniteDuration)(f: (FiniteDuration) ⇒ T): FoldSelectorBuilder[T]

def timeoutWithFlowTerminationAsync(t: FiniteDuration, f: (ExecutionContext, FlowTermination[T], FiniteDuration) ⇒ Future[T]): FoldSelectorBuilder.this.type

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def withIdle(f: (Skip[T]) ⇒ Option[Future[Continuated[T]]]): FoldSelectorBuilder.this.type

def withReader[B](ch: Input[B], f: (ContRead[B, T]) ⇒ Option[(In[B]) ⇒ Future[Continuated[T]]]): FoldSelectorBuilder.this.type

def withTimeout(t: FiniteDuration)(f: (Skip[T]) ⇒ Option[Future[Continuated[T]]]): FoldSelectorBuilder.this.type

def withWriter[B](ch: Output[B], f: (ContWrite[B, T]) ⇒ Option[(B, Future[Continuated[T]])]): FoldSelectorBuilder.this.type

macro def writing[A](ch: Output[A], x: A)(f: (A) ⇒ T): FoldSelectorBuilder[T]

def writingWithFlowTerminationAsync[A](ch: Output[A], x: ⇒ A, f: (ExecutionContext, FlowTermination[T], A) ⇒ Future[T]): FoldSelectorBuilder.this.type

Inherited from SelectorBuilder[T]

Inherited from AnyRef

Inherited from Any

Ungrouped