infinitree 0.11.0

Embedded, encrypted database with tiered cache
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

use super::{Key, LocalField, QueryAction, Select, Store};
use crate::{
    index::{self, FieldReader, FieldWriter},
    object,
};
use scc::HashMap;
use std::sync::Arc;

pub type Set<K> = Arc<HashMap<K, ()>>;

impl<'index, K> Store for LocalField<Set<K>>
where
    K: Key,
{
    fn execute(
        &mut self,
        mut transaction: index::writer::Transaction,
        _writer: &mut dyn object::Writer,
    ) {
        for f in self.field.iter() {
            transaction.write_next(f.key());
        }
    }
}

impl<'index, K> Select for LocalField<Set<K>>
where
    K: Key,
{
    type Key = K;

    fn execute(
        &mut self,
        mut transaction: index::reader::Transaction,
        _object: &mut dyn object::Reader,
        predicate: impl Fn(&K) -> QueryAction,
    ) {
        while let Ok(item) = transaction.read_next() {
            use QueryAction::*;

            match (predicate)(&item) {
                Take => {
                    self.field.insert(item);
                }
                Skip => (),
                Abort => break,
            }
        }
    }
}