composable-indexes 0.9.0

In-memory collections with composable indexes
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

use crate::ShallowClone;
use crate::core::{Index, Insert, Key, Remove, Seal};
use crate::index::generic::{DefaultKeySet, KeySet};

/// An index that maintains the keys of all received items.
#[derive(Clone)]
pub struct Keys<KeySet = DefaultKeySet> {
    pub keys: KeySet,
}

impl<KeySet_: KeySet + Default> Default for Keys<KeySet_> {
    fn default() -> Self {
        Keys {
            keys: KeySet_::default(),
        }
    }
}

impl<KeySet: ShallowClone> ShallowClone for Keys<KeySet> {}

impl Keys<DefaultKeySet> {
    pub fn new() -> Self {
        Self::default()
    }
}

impl<KeySet_: KeySet> Keys<KeySet_> {
    pub fn with_keyset() -> Self {
        Self::default()
    }
}

impl<In, KeySet_: KeySet> Index<In> for Keys<KeySet_> {
    #[inline]
    fn insert(&mut self, _seal: Seal, op: &Insert<In>) {
        self.keys.insert(op.key);
    }
    #[inline]
    fn remove(&mut self, _seal: Seal, op: &Remove<In>) {
        self.keys.remove(&op.key);
    }
}
impl<KeySet_: KeySet> Keys<KeySet_> {
    pub fn all(&self) -> impl Iterator<Item = Key> {
        self.keys.iter()
    }

    pub fn contains(&self, key: &Key) -> bool {
        self.keys.contains(key)
    }

    pub fn count(&self) -> usize {
        self.keys.count()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{
        core::Collection,
        testutils::{SortedVec, prop_assert_reference},
    };

    #[test]
    fn test_basic() {
        let mut coll = Collection::<u8, _>::new(Keys::new());

        let key1 = coll.insert(1);
        let key2 = coll.insert(2);

        assert!(coll.query(|ix| ix.contains(&key1)));
        assert!(coll.query(|ix| ix.contains(&key2)));
        assert_eq!(coll.query(|ix| ix.count()), 2);
    }

    #[test]
    fn test_all() {
        prop_assert_reference(
            Keys::new,
            |db| {
                db.query(|ix| ix.all().collect::<Vec<_>>())
                    .into_iter()
                    .copied()
                    .collect::<SortedVec<_>>()
            },
            |xs: Vec<u8>| xs.into_iter().collect::<SortedVec<_>>(),
            None,
        );
    }
}