coerce 0.8.11

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
56
57
58
59
60

use crate::actor::scheduler::ActorScheduler;
use crate::actor::system::{ActorSystem, ActorSystemCore};
use std::sync::atomic::{AtomicBool, AtomicU64};
use std::sync::Arc;
use uuid::Uuid;

#[cfg(feature = "persistence")]
use crate::persistent::{provider::StorageProvider, Persistence};

#[derive(Default)]
pub struct ActorSystemBuilder {
    system_id: Option<Uuid>,
    system_name: Option<String>,

    #[cfg(feature = "persistence")]
    persistence: Option<Arc<Persistence>>,
}

impl ActorSystemBuilder {
    pub fn system_name(mut self, name: impl ToString) -> Self {
        self.system_name = Some(name.to_string());
        self
    }

    #[cfg(feature = "persistence")]
    pub fn with_persistence<S: StorageProvider>(mut self, provider: S) -> Self {
        self.persistence = Some(Persistence::from(provider).into());
        self
    }

    pub fn build(self) -> ActorSystem {
        let system_id = self.system_id.unwrap_or_else(|| Uuid::new_v4());
        let system_name: Arc<str> = self.system_name.map_or_else(
            || {
                std::env::var("COERCE_ACTOR_SYSTEM").map_or_else(
                    |_e| format!("{}", system_id).into(),
                    |v| v.to_string().into(),
                )
            },
            |s| s.into(),
        );

        let scheduler = ActorScheduler::new(system_id, system_name.clone());
        ActorSystem {
            core: Arc::new(ActorSystemCore {
                system_id,
                system_name,
                scheduler,
                is_terminated: Arc::new(AtomicBool::new(false)),
                context_counter: Arc::new(AtomicU64::new(1)),

                #[cfg(feature = "persistence")]
                persistence: self.persistence,

                #[cfg(feature = "remote")]
                remote: None,
            }),
        }
    }
}