anathema-store 0.2.4

Various storage types for Anathema
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

use crate::slab::{Slab, SlabIndex, Ticket};

pub mod strings;

pub struct Storage<I, K, V>(Slab<I, (K, V)>);

/// Simple storage backed by a slab, prevents duplicate values
/// and associate values with keys
impl<I, K, V> Storage<I, K, V>
where
    I: SlabIndex,
{
    /// Create an empty store
    pub const fn empty() -> Self {
        Self(Slab::empty())
    }

    /// De-duplicate values.
    /// If the key already exist, just return the index.
    ///
    /// # Note
    ///
    /// This will not overwrite the existing value.
    #[must_use]
    pub fn push(&mut self, key: impl Into<K>, value: impl Into<V>) -> I
    where
        K: PartialEq,
    {
        let value = value.into();
        let key = key.into();
        let index = self.0.iter().find(|(_, (k, _))| key.eq(k)).map(|(i, (_, _))| i);
        index.unwrap_or_else(|| self.0.insert((key, value)))
    }

    /// Insert a key and a value.
    /// If the key already exists the value will be overwritten
    #[must_use]
    pub fn insert(&mut self, key: impl Into<K>, value: impl Into<V>) -> I
    where
        K: PartialEq,
    {
        let value = value.into();
        let key = key.into();
        let index = self.0.iter().find(|(_, (k, _))| key.eq(k)).map(|(i, (_, _))| i);

        match index {
            Some(i) => {
                self.0.get_mut_unchecked(i).1 = value;
                i
            }
            None => self.0.insert((key, value)),
        }
    }

    pub fn checkout(&mut self, index: I) -> Ticket<I, (K, V)> {
        self.0.checkout(index)
    }

    pub fn restore(&mut self, ticket: Ticket<I, (K, V)>) {
        self.0.restore(ticket)
    }

    /// Get a reference by index
    pub fn get(&self, index: I) -> Option<&(K, V)> {
        self.0.get(index)
    }

    /// Get a mutable reference by index
    pub fn get_mut(&mut self, index: I) -> Option<&mut (K, V)> {
        self.0.get_mut(index)
    }

    pub fn index_by_key(&self, key: K) -> Option<I>
    where
        K: PartialEq,
    {
        self.0.iter().filter(|(_, (k, _))| key.eq(k)).map(|(i, _)| i).next()
    }

    /// Get a value by index assuming the value exists.
    ///
    /// # Panics
    ///
    /// If the value doesn't exist
    pub fn get_unchecked(&self, index: I) -> &(K, V) {
        self.0.get(index).expect("missing value")
    }

    pub fn remove(&mut self, index: I) -> Option<(K, V)> {
        self.0.try_remove(index)
    }

    pub fn iter(&self) -> impl Iterator<Item = (I, &(K, V))> {
        self.0.iter()
    }

    pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut (K, V)> {
        self.0.iter_values_mut()
    }
}