haematite 0.6.0

Content-addressed, branchable, actor-native storage engine
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

use super::node::BrowserNodeError;
use super::{BrowserLocalError, BrowserSourceError};
use crate::branch::{BranchGetError, FenceOperationError};
use crate::tree::TreeOperationError;

pub(super) const fn node_failure(
    operation: &'static str,
    source: BrowserSourceError,
) -> BrowserLocalError {
    BrowserLocalError::NodeFailure { operation, source }
}

pub(super) const fn fence_failure(
    operation: &'static str,
    source: BrowserSourceError,
) -> BrowserLocalError {
    BrowserLocalError::FenceFailure { operation, source }
}

pub(super) fn node_backend_failure(
    operation: &'static str,
    error: BrowserNodeError,
) -> BrowserLocalError {
    node_failure(operation, error.0)
}

pub(super) fn tree_failure(
    operation: &'static str,
    error: TreeOperationError<BrowserNodeError>,
) -> BrowserLocalError {
    let source = match error {
        TreeOperationError::Tree(error) => BrowserSourceError::Tree { error },
        TreeOperationError::NodeGet { source, .. } | TreeOperationError::NodePut { source } => {
            source.0
        }
    };
    node_failure(operation, source)
}

pub(super) fn branch_get_failure(
    operation: &'static str,
    error: BranchGetError<BrowserNodeError>,
) -> BrowserLocalError {
    match error {
        BranchGetError::Branch(error) => {
            node_failure(operation, BrowserSourceError::Branch { error })
        }
        BranchGetError::Tree(error) => tree_failure(operation, error),
    }
}

pub(super) fn node_publication_failure(
    operation: &'static str,
    error: FenceOperationError<BrowserSourceError>,
) -> BrowserLocalError {
    match error {
        FenceOperationError::NodePublication(source) => node_failure(operation, source),
        FenceOperationError::RecordEntry(_) => {
            unreachable!("record fence passed to node publication mapper")
        }
    }
}

pub(super) fn record_entry_failure(
    operation: &'static str,
    error: FenceOperationError<BrowserSourceError>,
) -> BrowserLocalError {
    match error {
        FenceOperationError::RecordEntry(source) => fence_failure(operation, source),
        FenceOperationError::NodePublication(_) => {
            unreachable!("node fence passed to record entry mapper")
        }
    }
}