txmap 1.0.0

A concurrent transactional hash map with fine-grained locking and internal mutability
Documentation 
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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

#[cfg(test)]
mod tests {
    use crate::{
        prelude::*,
        tests::{
            creators::creators::empty_typed_map,
            types::types::{Funds, Transfer, User},
        },
    };

    #[test]
    fn transfer() {
        let db: TxMap<User, Funds> = empty_typed_map();
        let bob = User {
            first_name: "Bob".into(),
            last_name: "Bobson".into(),
        };
        let tim = User {
            first_name: "Tim".into(),
            last_name: "Timson".into(),
        };
        let pam = User {
            first_name: "Pam".into(),
            last_name: "Pamson".into(),
        };
        let _ = db
            .transaction()
            .update(tim.clone(), |_t, _f| {
                Some(Funds {
                    usd_and_cents: 150,
                    sterling_and_pence: 0,
                })
            })
            .into_transaction()
            .execute();
        let send_1_usd_from_bob_to_tim = db
            .transaction()
            .require("Has available funds", [tim.clone()], |[tim_funds]| {
                tim_funds.is_some_and(|f| f.usd_and_cents > 100)
            })
            .update(tim.clone(), |_t, tim_funds| {
                Some(Funds {
                    sterling_and_pence: tim_funds.unwrap().sterling_and_pence,
                    usd_and_cents: tim_funds.unwrap().usd_and_cents - 100,
                })
            })
            .update(bob.clone(), |_b, bob_funds| {
                Some(bob_funds.map_or(
                    Funds {
                        usd_and_cents: 100,
                        sterling_and_pence: 0,
                    },
                    |f| Funds {
                        usd_and_cents: f.usd_and_cents + 100,
                        sterling_and_pence: f.sterling_and_pence,
                    },
                ))
            })
            .into_transaction();
        assert_eq!(
            send_1_usd_from_bob_to_tim.execute(),
            TxResult::Completed(())
        );
        assert_ne!(
            send_1_usd_from_bob_to_tim.execute(),
            TxResult::Completed(())
        );

        let send_x_usd_from_bob_to_tim = db
            .transaction()
            .with_param::<Transfer>()
            .require(
                "Has available funds",
                [tim.clone()],
                |[tim_funds], params| {
                    tim_funds.is_some_and(|f| f.usd_and_cents >= params.usd_and_cents)
                },
            )
            .insert_default_if_absent(bob.clone())
            .modify(bob.clone(), |_bob, funds, params| {
                funds.usd_and_cents -= params.usd_and_cents
            })
            .modify(tim.clone(), |_tim, funds, params| {
                funds.usd_and_cents += params.usd_and_cents
            })
            .get_all([bob.clone(), tim.clone()], |_user, funds| {
                funds.usd_and_cents
            })
            .into_transaction();
        assert_eq!(
            send_x_usd_from_bob_to_tim.execute(&Transfer { usd_and_cents: 40 }),
            TxResult::Completed(vec![Some(60), Some(90)])
        );
        assert_ne!(
            send_x_usd_from_bob_to_tim.execute(&Transfer { usd_and_cents: 20 }),
            TxResult::Completed(vec![Some(40), Some(60)])
        );

        let add_100_usd_to_bob_if_exists = db
            .transaction()
            .modify(bob.clone(), |_b, bob_funds| {
                bob_funds.usd_and_cents += 100;
            })
            .into_transaction();
        assert_eq!(
            add_100_usd_to_bob_if_exists.execute(),
            TxResult::Completed(())
        );
        assert_eq!(
            add_100_usd_to_bob_if_exists.execute(),
            TxResult::Completed(())
        );

        let add_123_to_pam = db
            .transaction()
            .insert_default_if_absent(pam.clone())
            .modify(pam.clone(), |_p, pam_funds| {
                pam_funds.usd_and_cents += 123;
            })
            .get(pam.clone(), |_user, funds| funds.usd_and_cents)
            .into_transaction();
        assert_eq!(add_123_to_pam.execute(), TxResult::Completed(Some(123)));
        assert_eq!(add_123_to_pam.execute(), TxResult::Completed(Some(246)));
    }
}