metainfo 0.7.14

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! {
            #[inline]
            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! {
            #[inline]
            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! {
            #[inline]
            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! {
            #[inline]
            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);

    #[inline]
    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);
            }
        }
    }

    #[inline]
    pub fn clear(&mut self) {
        if let Some(v) = self.persistent.as_mut() {
            v.clear();
        }

        if let Some(v) = self.transient.as_mut() {
            v.clear();
        }

        if let Some(v) = self.stale.as_mut() {
            v.clear();
        }
    }
}

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

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