airomem 0.3.0

Simple persistence library inspired by Prevayler and @jarekratajski
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

pub trait Tx<D, R = ()> {
    fn execute(self, data: &mut D) -> R;
}

/// Check tests or readme for example usage.
#[macro_export]
macro_rules! NestedTx {
    ($name:tt<$data:tt> {
        $(
            $variant:tt (
                $(
                    $(#[$m:meta])* 
                    $field_name:ident : $field_type:ty
                ),* $(,)?
            ) -> $return_type:ty = $tx_fn:expr
        ),* $(,)?
    }) => {
        #[derive(serde::Serialize, serde::Deserialize)]
        pub enum $name {
            $(
                $variant($variant),
            )*
        }

        impl $crate::Tx<$data> for $name {
            fn execute(self, data: &mut $data) {
                match self {
                    $(
                        $name::$variant(it) => {
                            it.execute(data);
                        }
                    )*
                }
            }
        }

        $(
            $crate::Subtx! {
                #[tx($name)]
                struct $variant {
                    $(
                        $field_name: $field_type,
                    )*
                }

                impl $crate::Tx<$data, $return_type> for $variant {
                    fn execute(self, data: &mut $data) -> $return_type {
                        $tx_fn(data, self)
                    }
                }
            }
        )*
    };
}

#[macro_export]
macro_rules! Subtx {
    (
        #[tx($wrapper:tt)]
        struct $tx_struct:tt {
        }
        $tx_impl:item
    ) => {
        #[derive(serde::Serialize, serde::Deserialize)]
        pub struct $tx_struct;

        $crate::EnumBorrowOwned!($wrapper, $tx_struct);

        $tx_impl
    };
    (
        #[tx($wrapper:tt)]
        struct $tx_struct:tt {
            $($field_name:ident : $field_type:ty),* $(,)?
        }
        $tx_impl:item
    ) => {
        #[derive(serde::Serialize, serde::Deserialize)]
        pub struct $tx_struct {
            $($field_name : $field_type),*
        }

        $crate::EnumBorrowOwned!($wrapper, $tx_struct);

        $tx_impl
    };
}

/// Implements [Into<TargetEnum>] and [From<TargetEnum>] for given struct.
/// [crate::Tx] needs to implement this, because we need to wrap nested tx temporarily into
/// its parent to serialize it, but then we need it back to execute it on data.
///
/// We can't just simply change order (serialization -> execution to execution -> serialization),
/// because serialization can throw I/O error and we don't want to get different data state than
/// its representation in file.
#[macro_export]
macro_rules! EnumBorrowOwned {
    ($wrapper:tt, $sub:tt) => {
        $crate::EnumBorrowOwned!($wrapper::$sub, $sub);
    };
    ($wrapper:tt :: $wrapper_variant:tt, $sub:tt) => {
        impl Into<$wrapper> for $sub {
            fn into(self) -> $wrapper {
                $wrapper::$wrapper_variant(self)
            }
        }

        impl From<$wrapper> for $sub {
            fn from(value: $wrapper) -> Self {
                match value {
                    $wrapper::$wrapper_variant(q) => q,
                    #[allow(unreachable_patterns)]
                    _ => unreachable!(),
                }
            }
        }
    };
}