1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

//! Run the `stm` transaction
//!
//! # Examples
//! ```rust
//! extern crate stm;
//! extern crate transaction;
//! extern crate transaction_stm;
//!
//! use transaction::{Transaction, with_ctx};
//! use transaction_stm::run;
//!
//! fn main() {
//!     let x = stm::TVar::new(0);
//!     let y = stm::TVar::new(0);
//!
//!     let inc_xy =
//!         with_ctx(|ctx: &mut stm::Transaction| {
//!                      let xv = ctx.read(&x)?;
//!                      ctx.write(&x, xv + 1)?;
//!                      Ok(xv)
//!                  })
//!                 .and_then(|_| {
//!                               with_ctx(|ctx: &mut stm::Transaction| {
//!                                            let yv = ctx.read(&y)?;
//!                                            ctx.write(&y, yv + 1)?;
//!                                            Ok(yv)
//!                                        })
//!                           })
//!                 .and_then(|_| {
//!                               with_ctx(|ctx: &mut stm::Transaction| {
//!                                            Ok(ctx.read(&x)? + ctx.read(&y)?)
//!                                        })
//!                           });
//!     let ret = run(&inc_xy);
//!     assert_eq!(ret, 2);
//!
//! }
//! ```



extern crate stm;
extern crate transaction;

use transaction::Transaction;
use stm::Transaction as Stm;


/// Run the `stm` transaction
pub fn run<T, Tx>(tx: &Tx) -> T
where
    Tx: Transaction<Ctx = Stm, Item = T, Err = stm::StmError>,
{
    Stm::with(|stm| tx.run(stm))
}

pub fn with_tx<F, T, E>(f: F) -> WithTx<F>
where
    F: Fn(&mut Stm) -> Result<T, E>,
{
    WithTx { f: f }
}

pub struct WithTx<F> {
    f: F,
}

impl<F, T, E> Transaction for WithTx<F>
where
    F: Fn(&mut Stm) -> Result<T, E>,
{
    type Ctx = Stm;
    type Item = T;
    type Err = E;
    fn run(&self, ctx: &mut Self::Ctx) -> Result<Self::Item, Self::Err> {
        let WithTx { ref f } = *self;
        f(ctx)
    }
}