RenderingImpl

abstract def body(): B

abstract def cursor: Cursor[S]

abstract def fillResult(out: B)(implicit tx: S.Tx): A

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def abort(): Unit

final def aborted: Boolean

def addListener(pf: Listener[Update[B, Processor[B]]]): pf.type

def andThen[U](pf: PartialFunction[Try[B], U])(implicit executor: ExecutionContext): Future[B]

final def asInstanceOf[T0]: T0

final def await[B](that: ProcessorLike[B, Any], offset: Double, weight: Double): B

def cancel()(implicit tx: S.Tx): Unit

Cancels the process and does not keep results.

final def checkAborted(): Unit

def cleanUp(): Unit

def clone(): AnyRef

def collect[S](pf: PartialFunction[B, S])(implicit executor: ExecutionContext): Future[S]

def completeWith(t: Try[B]): Unit

final def dispatch(update: Update[B, Processor[B]]): Unit

def dispose()(implicit tx: S.Tx): Unit

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

implicit final def executionContext: ExecutionContext

def failed: Future[Throwable]

def fallbackTo[U >: B](that: Future[U]): Future[U]

def filter(p: (B) ⇒ Boolean)(implicit executor: ExecutionContext): Future[B]

def finalize(): Unit

final def fire(update: State[A])(implicit tx: S.Tx): Unit

def flatMap[S](f: (B) ⇒ Future[S])(implicit executor: ExecutionContext): Future[S]

def foreach[U](f: (B) ⇒ U)(implicit executor: ExecutionContext): Unit

final def getClass(): Class[_]

def hashCode(): Int

def isCompleted: Boolean

final def isInstanceOf[T0]: Boolean

def map[S](f: (B) ⇒ S)(implicit executor: ExecutionContext): Future[S]

def mapTo[S](implicit tag: ClassTag[S]): Future[S]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

def notifyAborted(): Unit

final def notifyAll(): Unit

def onComplete[U](func: (Try[B]) ⇒ U)(implicit executor: ExecutionContext): Unit

def onFailure[U](pf: PartialFunction[Throwable, U])(implicit executor: ExecutionContext): Unit

def onSuccess[U](pf: PartialFunction[B, U])(implicit executor: ExecutionContext): Unit

final def peerFuture: Future[B]

final def progress: Double

val progressResolution: Int

final def progress_=(f: Double): Unit

final def react(fun: (S.Tx) ⇒ (State[A]) ⇒ Unit)(implicit tx: S.Tx): Disposable[S.Tx]

final def reactNow(fun: (S.Tx) ⇒ (State[A]) ⇒ Unit)(implicit tx: S.Tx): Disposable[S.Tx]

Like react but invokes the function immediately with the current state.

def ready(atMost: Duration)(implicit permit: CanAwait): RenderingImpl.this.type

def recover[U >: B](pf: PartialFunction[Throwable, U])(implicit executor: ExecutionContext): Future[U]

def recoverWith[U >: B](pf: PartialFunction[Throwable, Future[U]])(implicit executor: ExecutionContext): Future[U]

def releaseListeners(): Unit

def removeListener(pf: Listener[Update[B, Processor[B]]]): Unit

def result(atMost: Duration)(implicit permit: CanAwait): B

final def start()(implicit executionContext: ExecutionContext): Unit

def startListening(): Unit

def startTx()(implicit tx: S.Tx): Unit

final def state(implicit tx: S.Tx): State[A]

final def state_=(value: State[A])(implicit tx: S.Tx): Unit

def stop()(implicit tx: S.Tx): Unit

Stops process at the next possible moment, and return current results.

def stopListening(): Unit

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

def toString(): String

def transform[S](s: (B) ⇒ S, f: (Throwable) ⇒ Throwable)(implicit executor: ExecutionContext): Future[S]

def value: Option[Try[B]]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

final def withFilter(p: (B) ⇒ Boolean)(implicit executor: ExecutionContext): Future[B]

def zip[U](that: Future[U]): Future[(B, U)]