append_db 0.3.2

Simple append based state for applications over popular databases.
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

use async_trait::async_trait;
use std::error::Error;
use std::fmt::Debug;

/// Describes a storing backend that can
/// save and load given internal type of updates for
/// state.
#[async_trait]
pub trait StateBackend {
    /// Aggregated state in memory
    type State: Clone + State + 'static;
    /// Errors that can occur in the backend
    type Err: Debug + Error + 'static;

    /// Write down state update into storage
    async fn write(&self, upd: SnapshotedUpdate<Self::State>) -> Result<(), Self::Err>;

    /// Collect all updates until first snapshot in the chain
    async fn updates(&self) -> Result<Vec<SnapshotedUpdate<Self::State>>, Self::Err>;
}

/// Aggregated state that could be updated by small updates
pub trait State {
    /// Incremental single update of the state
    type Update: Clone + PartialEq + Send + 'static;
    /// Update error
    type Err: Debug + Error + 'static;

    /// Table holding updates
    const TABLE: &'static str = "updates";

    /// Update the state with incremental part
    fn update(&mut self, upd: Self::Update) -> Result<(), Self::Err>;
}

/// Update with added shapshot to capture points when
/// we want to save whole state.
#[derive(Debug, Clone, PartialEq)]
pub enum SnapshotedUpdate<St: State> {
    Incremental(St::Update),
    Snapshot(St),
}

impl<St: State> SnapshotedUpdate<St> {
    /// True if update is snapshot
    pub fn is_snapshot(&self) -> bool {
        matches!(self, SnapshotedUpdate::Snapshot(_))
    }
}