InPortWithAdapter

Instance Constructors

new InPortWithAdapter(in: Input[A])

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
def *!: Output[A]

Definition Classes
InPort
def <~~<(x: OutPort[A]): Unit

Definition Classes
InPort
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
macro def ?: A

synonym for read.
synonym for read.

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

Definition Classes
Input
def api: GopherAPI

instance of gopher API
instance of gopher API

Definition Classes
InPort → 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]]], ft: 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
InPort → Input
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def connect(outPort: OutPort[A], bufferSize: Int = 1): Unit

Definition Classes
InPort
def connect(x: Input[A]): Unit

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

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) ⇒ 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
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
def outputSide: Option[Output[A]]

Definition Classes
InPort
def owner: Self
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
var v: Input[A]

Definition Classes
InPort
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 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") }

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]

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

Definition Classes
Input

class InPortWithAdapter[A] extends (ReplicatedTransputer.this)#InPort[A]

Instance Constructors

new InPortWithAdapter(in: Input[A])

Type Members

type <~ = A

type read = A

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

def *!: Output[A]

def <~~<(x: OutPort[A]): Unit

final def ==(arg0: Any): Boolean

macro def ?: A

var adapter: PortAdapter[Input, A]

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

def 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]]], ft: FlowTermination[B]): Unit

def clone(): AnyRef

def connect(outPort: OutPort[A], bufferSize: Int = 1): Unit

def connect(x: Input[A]): Unit

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

def outputSide: Option[Output[A]]

def owner: Self

macro def read: A

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

def toString(): String

var v: Input[A]

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 (ReplicatedTransputer.this)#InPort[A]

Inherited from Input[A]

Inherited from AnyRef

Inherited from Any

Ungrouped