ZippedInput

Instance Constructors

new ZippedInput(api: GopherAPI, inputA: Input[A], inputB: Input[B])

Type Members

type <~ = (A, B)

Definition Classes
Input
class Filtered extends Input[A]

Definition Classes
Input
class FutureMapped[B] extends Input[B]

Definition Classes
Input
class Mapped[B] extends Input[B]

Definition Classes
Input
case class Read(value: A) extends Product with Serializable

Definition Classes
Input
type read = (A, B)

Definition Classes
Input

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, B)

synonym for read.
synonym for read.

Definition Classes
Input
macro def afold[S, B](s0: S)(f: (S, (A, B)) ⇒ S): Future[S]

async incarnation of fold.
async incarnation of fold. Fold return future, which successed when channel is closed. Operations withing fold applyed on result on each other, starting with s0. val fsum = ch.afold(0){ (s, n) => s+n } Here in fsum will be future with value: sum of all elements in channel until one has been closed.

Definition Classes
Input
def afoldAsync[S, B](s0: S)(f: (S, (A, B)) ⇒ Future[S])(implicit ec: ExecutionContext): Future[S]

Definition Classes
Input
def afoldSync[S, B](s0: S)(f: (S, (A, B)) ⇒ S): Future[S]

Definition Classes
Input
macro def aforeach(f: ((A, B)) ⇒ Unit): Future[Unit]

Definition Classes
Input
def amap[B](g: ((A, B)) ⇒ Future[B]): Input[B]

Definition Classes
Input
val api: GopherAPI

instance of gopher API
instance of gopher API

Definition Classes
ZippedInput → Input → GopherAPIProvider
def append(other: Input[(A, B)]): Input[(A, B)]

when the first channel is exhaused, read from second.
when the first channel is exhaused, read from second.

Definition Classes
Input
def aread: Future[(A, B)]

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.

Definition Classes
Input
final def asInstanceOf[T0]: T0

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

Definition Classes
Input
def atake(n: Int): Future[IndexedSeq[(A, B)]]

return feature which contains sequence from first n elements.
return feature which contains sequence from first n elements.

Definition Classes
Input
def cbread[C](f: (ContRead[(A, B), C]) ⇒ Option[(In[(A, B)]) ⇒ Future[Continuated[C]]], flwt: FlowTermination[C]): Unit

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

Definition Classes
ZippedInput → Input
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
lazy val closeless: Input[(A, B)]

returns
Input without close event: i.e. reading from closeless channel after channel close will wait forever instead throwing CloseChannelException

Definition Classes
Input
def dup(): (Input[(A, B)], Input[(A, B)])

duplicate input
duplicate input

Definition Classes
Input
final def eq(arg0: AnyRef): Boolean

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

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

Definition Classes
Input
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def flatFold(fun: (Input[(A, B)], (A, B)) ⇒ Input[(A, B)]): Input[(A, B)]

Definition Classes
Input
def flatMap[B](g: ((A, B)) ⇒ Input[B]): Input[B]

Definition Classes
Input
def flatMapOp[B](g: ((A, B)) ⇒ Input[B])(op: (Input[B], Input[B]) ⇒ Input[B]): Input[B]

Definition Classes
Input
macro def fold[S, B](s0: S)(f: (S, (A, B)) ⇒ S): S

fold opeations, available inside async bloc.
fold opeations, available inside async bloc. go { val sum = ch.fold(0){ (s,n) => s+n } }

Definition Classes
Input
macro def foreach(f: ((A, B)) ⇒ 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.

Definition Classes
Input
def foreachAsync(f: ((A, B)) ⇒ Future[Unit])(implicit ec: ExecutionContext): Future[Unit]

Definition Classes
Input
def foreachSync(f: ((A, B)) ⇒ Unit): Future[Unit]

Definition Classes
Input
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)) ⇒ B): Input[B]

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

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def or(other: Input[(A, B)]): Input[(A, B)]

synonim for non-deteremenistics choice.
synonim for non-deteremenistics choice.

Definition Classes
Input
val pairs: ConcurrentLinkedQueue[(A, B)]
def prepend(a: (A, B)): Input[(A, B)]

Definition Classes
Input
macro def read: (A, B)

read object from channel.
read object from channel. Must be situated inside async/go/action block.

Definition Classes
Input
val readers: ConcurrentLinkedQueue[ContRead[(A, B), _]]
def seq: AnyRef { def flatMap[B](g: ((A, B)) => gopher.channels.Input[B]): gopher.channels.Input[B] }

Definition Classes
Input
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, B)) ⇒ Boolean): Input[(A, B)]

Definition Classes
Input
def withInputTimeouts(timeout: FiniteDuration): (Input[(A, B)], 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") }

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

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

Definition Classes
Input
def |(other: Input[(A, B)]): Input[(A, B)]

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

Definition Classes
Input

Related Docs: object ZippedInput | package channels

class ZippedInput[A, B] extends Input[(A, B)]

Instance Constructors

new ZippedInput(api: GopherAPI, inputA: Input[A], inputB: Input[B])

Type Members

type <~ = (A, B)

class Filtered extends Input[A]

class FutureMapped[B] extends Input[B]

class Mapped[B] extends Input[B]

case class Read(value: A) extends Product with Serializable

type read = (A, B)

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

macro def ?: (A, B)

macro def afold[S, B](s0: S)(f: (S, (A, B)) ⇒ S): Future[S]

def afoldAsync[S, B](s0: S)(f: (S, (A, B)) ⇒ Future[S])(implicit ec: ExecutionContext): Future[S]

def afoldSync[S, B](s0: S)(f: (S, (A, B)) ⇒ S): Future[S]

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

def amap[B](g: ((A, B)) ⇒ Future[B]): Input[B]

val api: GopherAPI

def append(other: Input[(A, B)]): Input[(A, B)]

def aread: Future[(A, B)]

final def asInstanceOf[T0]: T0

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

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

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

def clone(): AnyRef

lazy val closeless: Input[(A, B)]

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

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

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

def finalize(): Unit

def flatFold(fun: (Input[(A, B)], (A, B)) ⇒ Input[(A, B)]): Input[(A, B)]

def flatMap[B](g: ((A, B)) ⇒ Input[B]): Input[B]

def flatMapOp[B](g: ((A, B)) ⇒ Input[B])(op: (Input[B], Input[B]) ⇒ Input[B]): Input[B]

macro def fold[S, B](s0: S)(f: (S, (A, B)) ⇒ S): S

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

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

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

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

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

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def or(other: Input[(A, B)]): Input[(A, B)]

val pairs: ConcurrentLinkedQueue[(A, B)]

def prepend(a: (A, B)): Input[(A, B)]

macro def read: (A, B)

val readers: ConcurrentLinkedQueue[ContRead[(A, B), _]]

def seq: AnyRef { def flatMap[B](g: ((A, B)) => gopher.channels.Input[B]): gopher.channels.Input[B] }

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, B)) ⇒ Boolean): Input[(A, B)]

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

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

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

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

Inherited from Input[(A, B)]

Inherited from GopherAPIProvider

Inherited from AnyRef

Inherited from Any

Ungrouped