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

use super::commit::*;
use crate::{crypto::Key, fields::Serialized, index::TransactionList, ObjectId};
use serde::{de::DeserializeOwned, Serialize};

/// The root index of the tree that stores version information
#[derive(infinitree_macros::Index)]
pub(crate) struct RootIndex<CustomData>
where
    CustomData: Serialize + DeserializeOwned + Send + Sync + 'static,
{
    /// Transaction log of individual fields included in each
    /// generation.
    ///
    /// The last generation's transactions are at _the front_, so
    /// looping through this naively will yield the last commit
    /// _first_.
    pub(crate) transaction_log: Serialized<TransactionList>,

    /// Chronologically ordered list of commits
    pub(crate) commit_list: Serialized<CommitList<CustomData>>,

    /// Stores the list of objects that contain the index.  To make
    /// storage use more efficient, on commit these are going to be
    /// rewritten first, but only with index data.
    #[infinitree(skip)]
    pub(crate) objects: Serialized<Vec<ObjectId>>,

    #[infinitree(skip)]
    pub(crate) shadow_root: Serialized<ObjectId>,

    #[infinitree(skip)]
    pub(crate) key: Key,
}

impl<CustomData> RootIndex<CustomData>
where
    CustomData: Serialize + DeserializeOwned + Send + Sync + 'static,
{
    pub(crate) fn new(shadow_root: ObjectId, objects: Vec<ObjectId>, key: Key) -> Self {
        Self {
            transaction_log: Default::default(),
            commit_list: Default::default(),
            objects: objects.into(),
            shadow_root: shadow_root.into(),
            key,
        }
    }

    pub(crate) fn uninitialized(key: Key) -> Self {
        Self {
            transaction_log: Default::default(),
            commit_list: Default::default(),
            objects: Default::default(),
            shadow_root: Default::default(),
            key,
        }
    }
}

impl<CustomData> RootIndex<CustomData>
where
    CustomData: Serialize + DeserializeOwned + Send + Sync,
{
    pub(crate) fn objects(&self) -> Vec<ObjectId> {
        let root = self.objects.read();
        let transactions = self.transaction_log.read();
        let mut stream = root
            .iter()
            .cloned()
            .chain(
                transactions
                    .iter()
                    .flat_map(|(_, _, stream)| stream.objects()),
            )
            .collect::<std::collections::HashSet<_>>();
        stream.remove(&self.shadow_root.read());
        stream.into_iter().collect::<Vec<_>>()
    }
}