Input

Type Members

type <~ = A
type read = A

Abstract Value Members

abstract def api: GopherAPI

instance of gopher API
abstract def cbread[B](f: (ContRead[A, B]) ⇒ Option[(In[A]) ⇒ Future[Continuated[B]]], ft: FlowTermination[B]): Unit

apply f, when input will be ready and send result to API processor

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
macro def ?: A

synonym for read.
macro def aforeach(f: (A) ⇒ Unit): Future[Unit]
def aread: Future[A]

async version of read.
async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException in case of stream is closed.
final def asInstanceOf[T0]: T0

Definition Classes
Any
def async: AnyRef { ... /* 3 definitions in type refinement */ }
def atake(n: Int): Future[IndexedSeq[A]]

return feature which contains sequence from first n elements.
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def dup(): (Input[A], Input[A])

duplicate input
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def filter(p: (A) ⇒ Boolean): Input[A]
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
macro def foreach(f: (A) ⇒ Unit): Unit

run f each time when new object is arrived.
run f each time when new object is arrived. Ended when input closes.
must be inside go/async/action block.
def foreachAsync(f: (A) ⇒ Future[Unit])(implicit ec: ExecutionContext): Future[Unit]
def foreachSync(f: (A) ⇒ Unit): Future[Unit]
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def map[B](g: (A) ⇒ B): Input[B]
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
macro def read: A

read object from channel.
read object from channel. Must be situated inside async/go/action block.
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( ... )
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 withFilter(p: (A) ⇒ Boolean): Input[A]
def withInputTimeouts(timeout: FiniteDuration): (Input[A], Input[FiniteDuration])

return pair of inputs (ready, timeouts), such that when you read from ready you receive element from this and if during reading you wait more than specified timeout, than timeout message is appear in timeouts
return pair of inputs (ready, timeouts), such that when you read from ready you receive element from this and if during reading you wait more than specified timeout, than timeout message is appear in timeouts
val (inReady, inTimeouts) = in withInputTimeouts (10 seconds) select.forever { case x: inReady.read => Console.println(s"received value ${value}") case x: inTimeouts.read => Console.println(s"timeout occured") }
def zip[B](x: Input[B]): Input[(A, B)]
def zip[B](x: Iterable[B]): Input[(A, B)]
def |(other: Input[A]): Input[A]

return input merged with 'other'.
return input merged with 'other'. (i.e. non-determenistics choice)

Related Docs: object Input | package channels

trait Input[A] extends AnyRef

Type Members

type <~ = A

type read = A

Abstract Value Members

abstract def api: GopherAPI

abstract def cbread[B](f: (ContRead[A, B]) ⇒ Option[(In[A]) ⇒ Future[Continuated[B]]], ft: FlowTermination[B]): Unit

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

macro def ?: A

macro def aforeach(f: (A) ⇒ Unit): Future[Unit]

def aread: Future[A]

final def asInstanceOf[T0]: T0

def async: AnyRef { ... /* 3 definitions in type refinement */ }

def atake(n: Int): Future[IndexedSeq[A]]

def clone(): AnyRef

def dup(): (Input[A], Input[A])

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def filter(p: (A) ⇒ Boolean): Input[A]

def finalize(): Unit

macro def foreach(f: (A) ⇒ Unit): Unit

def foreachAsync(f: (A) ⇒ Future[Unit])(implicit ec: ExecutionContext): Future[Unit]

def foreachSync(f: (A) ⇒ Unit): Future[Unit]

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def map[B](g: (A) ⇒ B): Input[B]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

macro def read: A

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withFilter(p: (A) ⇒ Boolean): Input[A]

def withInputTimeouts(timeout: FiniteDuration): (Input[A], Input[FiniteDuration])

def zip[B](x: Input[B]): Input[(A, B)]

def zip[B](x: Iterable[B]): Input[(A, B)]

def |(other: Input[A]): Input[A]

Inherited from AnyRef

Inherited from Any

Ungrouped