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

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

/**
The `Repository` struct uses a [`Projector`] internally to abstract a list of [`Event`s],
offering simple CRUD methods instead of requiring the user to create and manage events themselves.
[`Event`s]: ../typings/event/struct.Event.html
[`Projector`]: projector/struct.Projector.html
*/
pub struct Repository<T: Clone + PartialEq> {
    projector: core::Projector<T>,
}

impl<T: Clone + PartialEq> Repository<T> {
    /// Constructs a new `Repository` with a given event log (may be `vec![]`)
    pub fn new(event_log: Vec<Event<T>>) -> Repository<T> {
        Repository {
            projector: core::Projector::new(event_log),
        }
    }

    /// Creates a new Entity
    pub fn create(&mut self, entity: T) {
        self.projector.add_event(Event::<T> {
            date: time::Instant::now(),
            operation: CRUD::Create,
            data: entity,
        });
    }

    /// Mutates an existing Entity
    pub fn update(&mut self, entity: T) {
        self.projector.add_event(Event::<T> {
            date: time::Instant::now(),
            operation: CRUD::Update,
            data: entity,
        });
    }

    /// Deletes an Entity
    pub fn delete(&mut self, entity: T) {
        self.projector.add_event(Event::<T> {
            date: time::Instant::now(),
            operation: CRUD::Delete,
            data: entity,
        });
    }

    /// Returns the latest projection
    pub fn get_projection(&self) -> &Vec<T> {
        &self.projector.projection
    }

    /// Generates a new projection at a specified moment in time
    pub fn project_at(&self, at: &time::Instant) -> Vec<T> {
        self.projector.project_at(&at)
    }

    /// Persists the event log using a given persistance strategy
    pub fn persist_data<R>(
        &mut self,
        persist_fn: fn(event_log: &Vec<typings::Event<T>>) -> R,
    ) -> R {
        persist_fn(&self.projector.event_log)
    }

    pub fn take_log(self) -> Vec<Event<T>> {}
}