coerce 0.8.6

Async actor runtime and distributed systems framework
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

//! Coerce Actor Persistence

pub mod actor;
pub mod batch;
pub mod context;
pub mod failure;
pub mod inspect;
pub mod journal;
pub mod recovery;

pub use actor::*;
pub use failure::*;
pub use journal::*;
pub use recovery::*;

use std::any::TypeId;
use std::collections::HashMap;

use crate::persistent::journal::provider::{StorageProvider, StorageProviderRef};
use std::sync::Arc;

#[derive(Clone)]
pub struct Persistence {
    default_provider: StorageProviderRef,
    actor_type_specific_providers: HashMap<TypeId, StorageProviderRef>,
}

impl<S: StorageProvider> From<S> for Persistence {
    fn from(value: S) -> Self {
        Persistence::from(value)
    }
}

impl Persistence {
    pub fn from<S: StorageProvider>(provider: S) -> Persistence {
        let default_provider = Arc::new(provider);
        Persistence {
            default_provider,
            actor_type_specific_providers: HashMap::new(),
        }
    }

    pub fn actor_provider<A: PersistentActor, S: StorageProvider>(mut self, provider: S) -> Self {
        let actor_type = TypeId::of::<A>();
        self.actor_type_specific_providers
            .insert(actor_type, Arc::new(provider));
        self
    }

    pub fn provider(&self, actor_type_id: TypeId) -> StorageProviderRef {
        self.actor_type_specific_providers
            .get(&actor_type_id)
            .map_or_else(|| self.default_provider.clone(), |s| s.clone())
    }
}