Input

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

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

macro def ?: A

synonym for read.

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

def aread: Future[A]

async version of read.

final def asInstanceOf[T0]: T0

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

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

run f each time when new object is arrived.

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

read object from channel.

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]