thingvellir 0.0.2-alpha1

a concurrent, shared-nothing abstraction that manages an assembly of things
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

use std::hash::Hash;

use super::{DataGuard, DefaultCommitPolicy, InnerCommitPolicy};
use crate::error::ShardError;
use crate::ServiceData;

pub(super) enum PendingCallback<Data> {
    ExecuteMut(
        Box<
            dyn FnOnce(Result<&mut Data, ShardError>, DefaultCommitPolicy) -> InnerCommitPolicy
                + Send,
        >,
    ),
    Execute(Box<dyn FnOnce(Result<&Data, ShardError>) + Send>),
}

impl<Data: ServiceData> PendingCallback<Data> {
    pub(super) fn reject(
        self,
        error: ShardError,
        default_commit_policy: Option<DefaultCommitPolicy>,
    ) {
        match self {
            PendingCallback::ExecuteMut(callback) => {
                (callback)(
                    Err(error),
                    default_commit_policy
                        .expect("invariant: mut operation with no default commit policy"),
                );
            }
            PendingCallback::Execute(callback) => {
                (callback)(Err(error));
            }
        }
    }

    pub(super) fn resolve<Key: Hash + Clone + Eq>(
        self,
        guard: &mut DataGuard<Key, Data>,
        default_commit_policy: Option<DefaultCommitPolicy>,
    ) -> InnerCommitPolicy {
        match self {
            PendingCallback::ExecuteMut(callback) => (callback)(
                Ok(guard.as_mut()),
                default_commit_policy
                    .expect("invariant: mut operation with no default commit policy"),
            ),
            PendingCallback::Execute(callback) => {
                (callback)(Ok(guard.as_ref()));
                InnerCommitPolicy::Noop
            }
        }
    }
}