linkrs-storage 0.1.0

Storage engine with CSR and memory-mapped containers
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

//! Shared macros for storage decorator implementations.

macro_rules! forward_methods {
    ($field:ident; $(fn $fn:ident(&self $(, $arg:ident : $ty:ty)* $(,)?);)+) => {
        $(
            fn $fn(&self, $($arg: $ty),*) {
                self.$field.$fn($($arg),*)
            }
        )+
    };
    ($field:ident; $(fn $fn:ident(&mut self $(, $arg:ident : $ty:ty)* $(,)?);)+) => {
        $(
            fn $fn(&mut self, $($arg: $ty),*) {
                self.$field.$fn($($arg),*)
            }
        )+
    };
    ($field:ident; $(fn $fn:ident(&self $(, $arg:ident : $ty:ty)* $(,)?) -> $ret:ty;)+) => {
        $(
            fn $fn(&self, $($arg: $ty),*) -> $ret {
                self.$field.$fn($($arg),*)
            }
        )+
    };
    ($field:ident; $(fn $fn:ident(&mut self $(, $arg:ident : $ty:ty)* $(,)?) -> $ret:ty;)+) => {
        $(
            fn $fn(&mut self, $($arg: $ty),*) -> $ret {
                self.$field.$fn($($arg),*)
            }
        )+
    };
}

/// Forward [`StorageWriter`] methods to a field, timing each call and
/// recording storage errors — the MetricsStorage decorator boilerplate.
macro_rules! forward_timed_write_methods {
    ($field:ident; $(fn $fn:ident(&mut self $(, $arg:ident : $ty:ty)* $(,)?) -> $ret:ty;)+) => {
        $(
            fn $fn(&mut self, $($arg: $ty),*) -> $ret {
                let start = std::time::Instant::now();
                let result = StorageWriter::$fn(&mut self.$field, $($arg),*);
                if result.is_err() {
                    if let Some(stats) = &self.stats {
                        stats.record_storage_error();
                    }
                }
                self.record_write(start);
                result
            }
        )+
    };
}

/// Forward [`StorageReader`] methods to a field, timing each call and
/// recording storage errors — the MetricsStorage decorator boilerplate.
macro_rules! forward_timed_read_methods {
    ($field:ident; $(fn $fn:ident(&self $(, $arg:ident : $ty:ty)* $(,)?) -> $ret:ty;)+) => {
        $(
            fn $fn(&self, $($arg: $ty),*) -> $ret {
                let start = std::time::Instant::now();
                let result = StorageReader::$fn(&self.$field, $($arg),*);
                if result.is_err() {
                    if let Some(stats) = &self.stats {
                        stats.record_storage_error();
                    }
                }
                self.record_read(start);
                result
            }
        )+
    };
}

/// Forward [`linkrs_transaction::UndoTarget`] methods to a field — the
/// MetricsStorage decorator boilerplate.
macro_rules! forward_undo_methods {
    ($field:ident; $(fn $fn:ident(&self $(, $arg:ident : $ty:ty)* $(,)?) -> $ret:ty;)+) => {
        $(
            fn $fn(&self, $($arg: $ty),*) -> $ret {
                linkrs_transaction::UndoTarget::$fn(&self.$field, $($arg),*)
            }
        )+
    };
}

pub(crate) use forward_methods;
pub(crate) use forward_timed_read_methods;
pub(crate) use forward_timed_write_methods;
pub(crate) use forward_undo_methods;