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
126
127

use ahash::AHashMap;
use faststr::FastStr;
use paste::paste;

const DEFAULT_CAPACITY: usize = 10; // maybe enough for most cases?

macro_rules! set_impl {
    ($name:ident) => {
        paste! {
            pub fn [<set_ $name>]<K: Into<FastStr>, V: Into<FastStr>>(
                &mut self,
                key: K,
                value: V,
            ) {
                if self.$name.is_none() {
                    self.$name = Some(AHashMap::with_capacity(DEFAULT_CAPACITY));
                }
                self.$name.as_mut().unwrap().insert(key.into(), value.into());
            }
        }
    };
}

macro_rules! del_impl {
    ($name:ident) => {
        paste! {
            pub fn [<del_ $name>]<K: AsRef<str>>(&mut self, key: K) -> Option<FastStr> {
                let key = key.as_ref();
                if let Some(v) = self.$name.as_mut() {
                    v.remove(key)
                } else {
                    None
                }
            }
        }
    };
}

macro_rules! get_impl {
    ($name:ident) => {
        paste! {
            pub fn [<get_ $name>]<K: AsRef<str>>(&self, key: K) -> Option<FastStr> {
                let key = key.as_ref();
                match self.$name.as_ref() {
                    Some(v) => {
                        v.get(key).cloned()
                    }
                    None => None,
                }
            }
        }
    };
}

macro_rules! get_all_impl {
    ($name:ident) => {
        paste! {
            pub fn [<get_all_ $name s>](&self) -> Option<&AHashMap<FastStr, FastStr>> {
                self.$name.as_ref()
            }
        }
    };
}

#[derive(Debug, Default, Clone)]
pub struct Node {
    persistent: Option<AHashMap<FastStr, FastStr>>,
    transient: Option<AHashMap<FastStr, FastStr>>,
    // this is called stale because upstream and downstream all use this.
    stale: Option<AHashMap<FastStr, FastStr>>,
}

impl Node {
    set_impl!(persistent);
    set_impl!(transient);
    set_impl!(stale);

    del_impl!(persistent);
    del_impl!(transient);
    del_impl!(stale);

    get_impl!(persistent);
    get_impl!(transient);
    get_impl!(stale);

    get_all_impl!(persistent);
    get_all_impl!(transient);
    get_all_impl!(stale);

    pub fn extend(&mut self, other: Self) {
        if let Some(v) = other.persistent {
            if self.persistent.is_none() {
                self.persistent = Some(v);
            } else {
                self.persistent.as_mut().unwrap().extend(v);
            }
        }

        if let Some(v) = other.transient {
            if self.transient.is_none() {
                self.transient = Some(v);
            } else {
                self.transient.as_mut().unwrap().extend(v);
            }
        }

        if let Some(v) = other.stale {
            if self.stale.is_none() {
                self.stale = Some(v);
            } else {
                self.stale.as_mut().unwrap().extend(v);
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_add_stale() {
        let mut node = Node::default();
        node.set_stale("key", "value");
        println!("{node:?}");
    }
}