FixedBasicAction

abstract def getDumpInfo: DumpInfo

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

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

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

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.

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 collect[R2](pf: PartialFunction[R, R2])(implicit executor: ExecutionContext): DBIOAction[R2, NoStream, E]

Transform the result of a successful execution of this action, if the given partial function is defined at that value, otherwise, the result DBIOAction will fail with a NoSuchElementException.

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

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

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

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

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): 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 flatten[R2, S2 <: NoStream, E2 <: Effect](implicit ev: <:<[R, DBIOAction[R2, S2, E2]]): DBIOAction[R2, S2, E with E2]

Creates a new DBIOAction with one level of nesting flattened, this method is equivalent to flatMap(identity).

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def hashCode(): Int

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

def toString(): String

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 zipWith[R2, E2 <: Effect, R3](a: DBIOAction[R2, NoStream, E2])(f: (R, R2) ⇒ R3)(implicit executor: ExecutionContext): DBIOAction[R3, NoStream, E with E2]

Run another action after this action, if it completed successfully, and zip the result of both actions with a function f, then create a new DBIOAction holding this result, If either of the two actions fails, the resulting action also fails.

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