minerva 0.2.0

Causal ordering for distributed systems
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

use super::super::super::support::dot;
use crate::metis::{Composer, Dot, DotSet, DotStore};

use super::dots;

#[derive(Clone, Debug, Default, PartialEq, Eq)]
struct LyingStore {
    hidden: Option<Dot>,
}

impl DotStore for LyingStore {
    fn dots(&self) -> impl Iterator<Item = Dot> + '_ {
        core::iter::empty()
    }

    fn is_bottom(&self) -> bool {
        self.hidden.is_none()
    }

    fn causal_merge(&self, _self_context: &DotSet, other: &Self, _other_context: &DotSet) -> Self {
        if self.hidden.is_some() {
            self.clone()
        } else {
            other.clone()
        }
    }

    fn restrict(&self, _roster: impl IntoIterator<Item = u32>) -> Self {
        self.clone()
    }

    fn novel_to(&self, _context: &DotSet) -> Self {
        self.clone()
    }
}

#[test]
fn test_compose_over_a_lying_store_rides_the_lie_through() {
    let mut composer: Composer<LyingStore> = Composer::new(1);
    let superseded = dots(&[(1, 5)]);
    let carried = superseded.clone();
    let (_, delta) = composer.compose(move |assigned| {
        (
            LyingStore {
                hidden: Some(assigned),
            },
            carried,
        )
    });
    assert!(!delta.store().is_bottom());
    assert_eq!(delta.store().hidden, Some(dot(1, 1)));
    assert_eq!(delta.context(), &superseded);
    assert!(!delta.context().contains(dot(1, 1)));
}