libocc 0.5.0

A library for occasionally connected computing
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

use crate::typings::{self, CRUD};
use std::time;

/// The `Projector` struct uses a list of [`Event`s] to generate a projection of entities.
///
/// The projection is simply a `Vector` containing all entities of the type `T` at a specified moment in time.
///
/// You can also use the [`Repository`] struct to abstract the [`Event`s] away.
///
/// [`Event`s]: ../typings/event/struct.Event.html
/// [`Repository`]: repository/struct.Repository.html
pub struct Projector<T: Clone + PartialEq> {
    /// The ordered list of events used to generate the projection
    pub event_log: Vec<typings::Event<T>>,

    /// The resulting projection from the event log
    pub projection: Vec<T>,
}

impl<T: Clone + PartialEq> Projector<T> {
    /// Constructs a new `Projector` given an event log (may be `vec![]`)
    pub fn new(event_log: Vec<typings::Event<T>>) -> Projector<T> {
        Projector {
            projection: Self::project_all(&event_log),
            event_log,
        }
    }

    /// Applies an event to the projection and adds
    /// it to the event log of this instance.
    pub fn add_event(&mut self, event: typings::Event<T>) {
        Self::project_one(&mut self.projection, &event);
        self.event_log.push(event);
    }

    /// Projects an event log onto a returned list of entities
    pub fn project_at(&self, at: &time::Instant) -> Vec<T> {
        // Create a new list
        let mut list: Vec<T> = Vec::new();

        // Iterate over all events in teh event log until the target date
        // & project the event onto the list
        self.event_log
            .iter()
            .take_while(|event| &event.date <= at)
            .for_each(|event| Self::project_one(&mut list, &event));

        // Return the entity-list from the projected events
        list
    }

    fn project_all(event_log: &Vec<typings::Event<T>>) -> Vec<T> {
        // Create a new list
        let mut list: Vec<T> = Vec::new();

        // Iterate over all events in teh event log until the target date
        event_log
            .iter()
            .for_each(|event| Self::project_one(&mut list, &event));

        // Return the entity-list from the projected events
        list
    }

    fn project_one(list: &mut Vec<T>, event: &typings::Event<T>) {
        let maybe_i = list.iter().position(|el| el == &event.data);

        match event.operation {
            CRUD::Create => {
                if let Some(_) = maybe_i {
                    // TODO return an error
                } else {
                    list.push(event.data.clone());
                }
            }
            CRUD::Update => {
                if let Some(i) = maybe_i {
                    list.splice(i..i, vec![event.data.clone()]);
                } else {
                    // TODO return an error
                }
            }
            CRUD::Delete => {
                if let Some(i) = maybe_i {
                    list.splice(i..i, vec![]);
                } else {
                    // TODO return an error
                }
            }
        };
    }
}