archimedes-kernel 2.0.0

Minimal lawful movement kernel for disciplined digital reality construction
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
92
93
94
95
96

use serde::{Deserialize, Serialize};

use crate::movement::{Event, MovementMemory};

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Identity(pub String);

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Boundary {
    pub allowed_values: Vec<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Law {
    pub allowed_transitions: Vec<(String, String)>,
}

impl Law {
    pub fn check(&self, current_state: &State, event: &Event) -> bool {
        self.allowed_transitions
            .iter()
            .any(|(from, to)| from == &current_state.field && to == &event.proposed_field)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct State {
    pub field: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Reality {
    pub(crate) identity: Identity,
    pub(crate) boundary: Boundary,
    pub(crate) law: Law,
    pub(crate) state: State,
    pub(crate) initial_state: State,
    pub(crate) memory: MovementMemory,
    pub(crate) birth_boundary: Boundary,
    pub(crate) birth_law: Law,
    #[cfg(test)]
    #[serde(skip)]
    pub(crate) test_hook: Option<fn(&mut Reality)>,
}

impl Reality {
    pub fn new(identity: Identity, boundary: Boundary, law: Law, state: State) -> Self {
        Self {
            identity,
            boundary: boundary.clone(),
            law: law.clone(),
            initial_state: state.clone(),
            state,
            memory: MovementMemory::default(),
            birth_boundary: boundary,
            birth_law: law,
            #[cfg(test)]
            test_hook: None,
        }
    }

    pub fn identity(&self) -> &Identity {
        &self.identity
    }
    pub fn boundary(&self) -> &Boundary {
        &self.boundary
    }
    pub fn law(&self) -> &Law {
        &self.law
    }
    pub fn state(&self) -> &State {
        &self.state
    }
    pub fn initial_state(&self) -> &State {
        &self.initial_state
    }
    pub fn memory(&self) -> &MovementMemory {
        &self.memory
    }
}

impl PartialEq for Reality {
    fn eq(&self, other: &Self) -> bool {
        self.identity == other.identity
            && self.boundary == other.boundary
            && self.law == other.law
            && self.state == other.state
            && self.initial_state == other.initial_state
            && self.memory == other.memory
            && self.birth_boundary == other.birth_boundary
            && self.birth_law == other.birth_law
        // test_hook intentionally ignored
    }
}

impl Eq for Reality {}