FutureInput

Future[A], represented as input which produce a value when completed, after this closes. If evaluation of feature is unsuccessful (i.e. failure), than appropriative exception is thrown during reading.

Can be obtained from gopherApi.

import gopherApi._

val myInput = futureInput(future)
select.forever{
   case x: myInput.read => Console.println(s"we receive value from future: ${x}")
                         implicitly[FlowTermination[Unit]].doExit(())
   case x: myChannel.read => Console.println(s"value from channel: ${x}")
}

Also it is possiblt to direclty read from future in case guard:

select.forever{
case x: T if (x==future.read) => Console.println(s"we receive value from future: ${x}")
case x: T if (x==channel.read) => Console.println(s"value from channel: ${x}")
}

Linear Supertypes

Input[A], AnyRef, Any

Instance Constructors

new FutureInput(future: Future[A], api: GopherAPI)

Type Members

type <~ = A

Definition Classes
Input
type read = A

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

synonym for read.
synonym for read.

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

Definition Classes
Input
val api: GopherAPI

instance of gopher API
instance of gopher API

Definition Classes
FutureInput → Input
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.

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]]

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

Definition Classes
Input
def cbread[B](f: (ContRead[A, B]) ⇒ Option[(In[A]) ⇒ Future[Continuated[B]]], flwt: FlowTermination[B]): 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
FutureInput → Input
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
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]

Definition Classes
Input
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.

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

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

Definition Classes
Input
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

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

Definition Classes
Any
def map[B](g: (A) ⇒ 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
macro def read: A

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

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

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

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

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

Definition Classes
Input

class FutureInput[A] extends Input[A]

Instance Constructors

new FutureInput(future: Future[A], api: GopherAPI)

Type Members

type <~ = A

type read = A

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]

val api: GopherAPI

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 cbread[B](f: (ContRead[A, B]) ⇒ Option[(In[A]) ⇒ Future[Continuated[B]]], flwt: FlowTermination[B]): Unit

def clone(): AnyRef

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

def input: Input[A]

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 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 Input[A]

Inherited from AnyRef

Inherited from Any

Ungrouped