AndThenAction

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (AndThenAction[R, S, E], B)

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

final def >>[R2, S2 <: NoStream, E2 <: Effect](a: DBIOAction[R2, S2, E2]): DBIOAction[R2, S2, E with E2]

A shortcut for andThen.

val a1: DBIOAction[_, NoStream, E]

val a2: DBIOAction[R, S, E]

def andFinally[E2 <: Effect](a: DBIOAction[_, NoStream, E2]): DBIOAction[R, S, E with E2]

Run another action after this action, whether it succeeds or fails, and then return the result of the first action.

def andThen[R2, S2 <: NoStream, E2 <: Effect](a: DBIOAction[R2, S2, E2]): DBIOAction[R2, S2, E with E2]

Run another action after this action, if it completed successfully, and return the result of the second action.

final def asInstanceOf[T0]: T0

def asTry: DBIOAction[Try[R], NoStream, E]

Convert a successful result v of this action into a successful result Success(v) and a failure t into a successful result Failure(t).

def cleanUp[E2 <: Effect](f: (Option[Throwable]) ⇒ DBIOAction[_, NoStream, E2], keepFailure: Boolean = true)(implicit executor: ExecutionContext): DBIOAction[R, S, E with E2]

Run another action after this action, whether it succeeds or fails, in order to clean up or transform an error produced by this action.

def clone(): AnyRef

def ensuring(cond: (AndThenAction[R, S, E]) ⇒ Boolean, msg: ⇒ Any): AndThenAction[R, S, E]

def ensuring(cond: (AndThenAction[R, S, E]) ⇒ Boolean): AndThenAction[R, S, E]

def ensuring(cond: Boolean, msg: ⇒ Any): AndThenAction[R, S, E]

def ensuring(cond: Boolean): AndThenAction[R, S, E]

final def eq(arg0: AnyRef): Boolean

def failed: DBIOAction[Throwable, NoStream, E]

Return an action which contains the Throwable with which this action failed as its result.

final def filter(p: (R) ⇒ Boolean)(implicit executor: ExecutionContext): DBIOAction[R, NoStream, E]

Filter the result of this action with the given predicate.

def finalize(): Unit

def flatMap[R2, S2 <: NoStream, E2 <: Effect](f: (R) ⇒ DBIOAction[R2, S2, E2])(implicit executor: ExecutionContext): DBIOAction[R2, S2, E with E2]

Use the result produced by the successful execution of this action to compute and then run the next action in sequence.

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def getDumpInfo: DumpInfo

Return the name, main info, attribute info and named children

final def isInstanceOf[T0]: Boolean

def isLogged: Boolean

Whether or not this action should be included in log output by default.

def map[R2](f: (R) ⇒ R2)(implicit executor: ExecutionContext): DBIOAction[R2, NoStream, E]

Transform the result of a successful execution of this action.

def named(name: String): DBIOAction[R, S, E]

Get a wrapping action which has a name that will be included in log output.

final def ne(arg0: AnyRef): Boolean

def nonFusedEquivalentAction: DBIOAction[R, S, E]

Get the equivalent non-fused action if this action has been fused, otherwise this action is returned.

final def notify(): Unit

final def notifyAll(): Unit

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

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withFilter(p: (R) ⇒ Boolean)(implicit executor: ExecutionContext): DBIOAction[R, NoStream, E]

def withPinnedSession: DBIOAction[R, S, E]

Use a pinned database session when running this action.

def zip[R2, E2 <: Effect](a: DBIOAction[R2, NoStream, E2]): DBIOAction[(R, R2), NoStream, E with E2]

Run another action after this action, if it completed successfully, and return the result of both actions.

def →[B](y: B): (AndThenAction[R, S, E], B)

val self: Any

val self: Any

def x: AndThenAction[R, S, E]

def x: AndThenAction[R, S, E]