Execution

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def after(executions: List[Execution]): Execution

run this execution after the previous executions are finished

def afterSequential(executions: List[Execution]): Execution

run this execution after the other executions have been sequentially executed

def afterSuccessful(executions: List[Execution]): Execution

run this execution after the executions and only if they are successful

def afterSuccessfulSequential(executions: List[Execution]): Execution

run this execution after the other executions have been sequentially executed and only if they are successful

final def asInstanceOf[T0]: T0

def clone(): AnyRef

val continuation: Option[FragmentsContinuation]

final def eq(arg0: AnyRef): Boolean

def equals(a: Any): Boolean

lazy val executedResult: TimedFuture[ExecutedResult]

val executing: Executing

lazy val executionResult: TimedFuture[Result]

final def getClass(): Class[_]

def hashCode(): Int

def isExecutable: Boolean

final def isInstanceOf[T0]: Boolean

val isolable: Boolean

def join: Execution

methods to set the execution

def makeGlobal(when: Boolean): Execution

def makeGlobal: Execution

def mapMessage(f: (String) ⇒ String): Execution

force a message

def mapResult(f: (Result) ⇒ Result): Execution

force a result

val mustJoin: Boolean

final def ne(arg0: AnyRef): Boolean

val nextMustStopIf: (Result) ⇒ Boolean

final def notify(): Unit

final def notifyAll(): Unit

val previousResult: Option[Result]

val run: Option[(Env) ⇒ Future[() ⇒ Result]]

def setErrorAsFatal: Execution

def setExecuting(r: Future[(Result, SimpleTimer)]): Execution

def setFatal(f: Throwable): Execution

def setPreviousResult(r: Option[Result]): Execution

def setResult(r: ⇒ Result): Execution

def setTimeout(timeout: FiniteDuration): Execution

def skip: Execution

def startAfter(others: List[Execution])(env: Env): Execution

start this execution when the other ones are finished

def startAfter(other: Execution)(env: Env): Execution

start this execution when the other one is finished

def startExecution(env: Env): Execution

run the execution

def stopNextIf(f: (Result) ⇒ Boolean): Execution

def stopNextIf(r: Result): Execution

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

val timeout: Option[FiniteDuration]

def toString(): String

def updateResult(newResult: (⇒ Result) ⇒ Result): Execution

def updateRun(newRun: ((Env) ⇒ Future[() ⇒ Result]) ⇒ (Env) ⇒ Future[() ⇒ Result]): Execution

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

final def wait(arg0: Long): Unit

final def wait(): Unit

def was(statusCheck: (String) ⇒ Boolean): Boolean

def finalize(): Unit