sim-lib-journal 0.1.0

Domain-free atomic content journal contract for SIM.
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

use crate::{JournalEntry, Verification};
use sim_kernel::ContentId;

/// Detached row in a read-only projection.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum ProjectionRow {
    Head { sequence: u64, entry: ContentId },
    Entry(JournalEntry),
    Object(ContentId),
}

/// Read-only flat Table-shaped snapshot. It exposes no mutation method and is
/// never consulted by journal authority.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct TableProjection {
    rows: Vec<ProjectionRow>,
}

impl TableProjection {
    pub(crate) fn from_verification(value: Verification) -> Self {
        Self { rows: rows(value) }
    }
    pub fn rows(&self) -> &[ProjectionRow] {
        &self.rows
    }
}

/// Read-only Dir-shaped snapshot grouped by journal/object namespaces.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct DirProjection {
    journal: Vec<ProjectionRow>,
    objects: Vec<ProjectionRow>,
}

impl DirProjection {
    pub(crate) fn from_verification(value: Verification) -> Self {
        let all = rows(value);
        let (objects, journal) = all
            .into_iter()
            .partition(|r| matches!(r, ProjectionRow::Object(_)));
        Self { journal, objects }
    }
    pub fn journal(&self) -> &[ProjectionRow] {
        &self.journal
    }
    pub fn objects(&self) -> &[ProjectionRow] {
        &self.objects
    }
}

fn rows(value: Verification) -> Vec<ProjectionRow> {
    let mut rows = Vec::new();
    if let Some(h) = value.head {
        rows.push(ProjectionRow::Head {
            sequence: h.sequence,
            entry: h.entry,
        });
    }
    rows.extend(value.entries.into_iter().map(ProjectionRow::Entry));
    rows.extend(value.object_ids.into_iter().map(ProjectionRow::Object));
    rows
}