Enum transaction::Branch3

#[must_use]
pub enum Branch3<Tx1, Tx2, Tx3> {
    B1(Tx1),
    B2(Tx2),
    B3(Tx3),
}

The result of branch3

Variants

B1(Tx1)B2(Tx2)B3(Tx3)

Trait Implementations

impl<Tx1: Debug, Tx2: Debug, Tx3: Debug> Debug for Branch3<Tx1, Tx2, Tx3>

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<Tx1, Tx2, Tx3> Transaction for Branch3<Tx1, Tx2, Tx3> where
    Tx1: Transaction,
    Tx2: Transaction<Ctx = Tx1::Ctx, Item = Tx1::Item, Err = Tx1::Err>,
    Tx3: Transaction<Ctx = Tx1::Ctx, Item = Tx1::Item, Err = Tx1::Err>, 

type Ctx = Tx1::Ctx

The contxt type (i.e. transaction type) of the transaction

type Item = Tx1::Item

The return type of the transaction

type Err = Tx1::Err

The error type of the transaction

fn run(&self, ctx: &mut Self::Ctx) -> Result<Self::Item, Self::Err>

Run the transaction. This will called by transaction runner rather than user by hand.

fn boxed<'a>(
    self
) -> Box<Transaction<Ctx = Self::Ctx, Item = Self::Item, Err = Self::Err> + 'a> where
    Self: Sized + 'a, 

Box the transaction

fn then<F, B, Tx2>(self, f: F) -> Then<Self, F, Tx2> where
    Tx2: IntoTransaction<Self::Ctx, Item = B, Err = Self::Err>,
    F: Fn(Result<Self::Item, Self::Err>) -> Tx2,
    Self: Sized, 

Take the previous result of computation and do another computation

fn map<F, B>(self, f: F) -> Map<Self, F> where
    F: Fn(Self::Item) -> B,
    Self: Sized, 

Transform the previous successful value

fn and_then<F, B>(self, f: F) -> AndThen<Self, F, B> where
    B: IntoTransaction<Self::Ctx, Err = Self::Err>,
    F: Fn(Self::Item) -> B,
    Self: Sized, 

Take the previous successful value of computation and do another computation

fn map_err<F, B>(self, f: F) -> MapErr<Self, F> where
    F: Fn(Self::Err) -> B,
    Self: Sized, 

Transform the previous error value

fn or_else<F, B>(self, f: F) -> OrElse<Self, F, B> where
    B: IntoTransaction<Self::Ctx, Item = Self::Item>,
    F: Fn(Self::Err) -> B,
    Self: Sized, 

Take the previous error value of computation and do another computation. This may be used falling back

fn abort<T, F>(self, f: F) -> Abort<Self, T, F> where
    F: Fn(Self::Item) -> Self::Err,
    Self: Sized, 

Take the previous successfull value of computation and abort the transaction.

fn try_abort<F, B>(self, f: F) -> TryAbort<Self, F, B> where
    F: Fn(Self::Item) -> Result<B, Self::Err>,
    Self: Sized, 

Try to abort the transaction

fn recover<T, F>(self, f: F) -> Recover<Self, T, F> where
    F: Fn(Self::Err) -> Self::Item,
    Self: Sized, 

Recover from an error

fn try_recover<F, B>(self, f: F) -> TryRecover<Self, F, B> where
    F: Fn(Self::Err) -> Result<Self::Item, B>,
    Self: Sized, 

Try to recover from an error

fn join<B>(self, b: B) -> Join<Self, B::Tx> where
    B: IntoTransaction<Self::Ctx, Err = Self::Err>,
    Self: Sized, 

join 2 indepndant transactions

fn join3<B, C>(self, b: B, c: C) -> Join3<Self, B::Tx, C::Tx> where
    B: IntoTransaction<Self::Ctx, Err = Self::Err>,
    C: IntoTransaction<Self::Ctx, Err = Self::Err>,
    Self: Sized, 

join 3 indepndant transactions

fn join4<B, C, D>(self, b: B, c: C, d: D) -> Join4<Self, B::Tx, C::Tx, D::Tx> where
    B: IntoTransaction<Self::Ctx, Err = Self::Err>,
    C: IntoTransaction<Self::Ctx, Err = Self::Err>,
    D: IntoTransaction<Self::Ctx, Err = Self::Err>,
    Self: Sized, 

join 4 indepndant transactions

fn branch(self) -> BranchBuilder<Self> where
    Self: Sized, 

branch builder

fn branch3(self) -> Branch3Builder<Self> where
    Self: Sized, 

3 branch builder

fn branch4(self) -> Branch4Builder<Self> where
    Self: Sized, 

4 branch builder