sim-lib-journal 0.3.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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

use sim_kernel::{ContentId, Datum, NumberLiteral, Symbol};

use crate::JournalError;

/// One immutable journal fact whose identity is the canonical semantic Datum.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct JournalEntry {
    pub id: ContentId,
    pub sequence: u64,
    pub previous: Option<ContentId>,
    pub kind: Symbol,
    pub payloads: Vec<ContentId>,
}

impl JournalEntry {
    /// Constructs a canonical `journal/entry-v2` value.
    pub fn new(
        sequence: u64,
        previous: Option<ContentId>,
        kind: Symbol,
        payloads: Vec<ContentId>,
    ) -> Self {
        let mut value = Self {
            id: ContentId::from_bytes(Symbol::new("unset"), [0; 32]),
            sequence,
            previous,
            kind,
            payloads,
        };
        value.id = value
            .canonical_datum()
            .content_id()
            .expect("journal entry construction is canonical");
        value
    }

    /// Returns the exact semantic value whose content id is this entry's id.
    pub fn canonical_datum(&self) -> Datum {
        Datum::Node {
            tag: Symbol::qualified("journal", "entry-v2"),
            fields: vec![
                (
                    Symbol::new("sequence"),
                    Datum::Number(NumberLiteral {
                        domain: Symbol::qualified("numbers", "u64"),
                        canonical: self.sequence.to_string(),
                    }),
                ),
                (
                    Symbol::new("previous"),
                    self.previous.as_ref().map_or(Datum::Nil, id_datum),
                ),
                (Symbol::new("kind"), Datum::Symbol(self.kind.clone())),
                (
                    Symbol::new("payloads"),
                    Datum::Vector(self.payloads.iter().map(id_datum).collect()),
                ),
            ],
        }
    }

    pub(crate) fn canonical_id(&self) -> Result<ContentId, JournalError> {
        self.canonical_datum()
            .content_id()
            .map_err(|_| JournalError::CorruptEntry)
    }
}

pub(crate) fn id_datum(id: &ContentId) -> Datum {
    Datum::Node {
        tag: Symbol::qualified("journal", "content-id-v1"),
        fields: vec![
            (
                Symbol::new("algorithm"),
                Datum::Symbol(id.algorithm.clone()),
            ),
            (Symbol::new("digest"), Datum::Bytes(id.bytes.to_vec())),
        ],
    }
}