atomr-core 0.3.1

Actors, supervision, dispatch, mailboxes, scheduler, FSM, event stream, and coordinated shutdown — the core of the atomr actor runtime.
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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

//! `ActorPath` — immutable, hierarchical, string-backed path.

use std::fmt;

use serde::{Deserialize, Serialize};

use super::address::Address;

#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct PathElement(String);

impl PathElement {
    pub fn new(s: impl Into<String>) -> Self {
        Self(s.into())
    }

    pub fn as_str(&self) -> &str {
        &self.0
    }
}

impl fmt::Display for PathElement {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(&self.0)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct ActorPath {
    pub address: Address,
    pub elements: Vec<PathElement>,
    pub uid: u64,
}

impl ActorPath {
    pub fn root(address: Address) -> Self {
        Self { address, elements: vec![], uid: 0 }
    }

    pub fn child(&self, name: impl Into<String>) -> Self {
        let mut e = self.elements.clone();
        e.push(PathElement::new(name));
        Self { address: self.address.clone(), elements: e, uid: 0 }
    }

    pub fn with_uid(mut self, uid: u64) -> Self {
        self.uid = uid;
        self
    }

    pub fn name(&self) -> &str {
        self.elements.last().map(|e| e.as_str()).unwrap_or("/")
    }

    pub fn parent(&self) -> Option<Self> {
        if self.elements.is_empty() {
            return None;
        }
        let mut e = self.elements.clone();
        e.pop();
        Some(Self { address: self.address.clone(), elements: e, uid: 0 })
    }

    pub fn depth(&self) -> usize {
        self.elements.len()
    }

    pub fn to_string_without_address(&self) -> String {
        let mut s = String::from("/");
        for (i, el) in self.elements.iter().enumerate() {
            if i > 0 {
                s.push('/');
            }
            s.push_str(el.as_str());
        }
        s
    }
}

impl fmt::Display for ActorPath {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}{}", self.address, self.to_string_without_address())
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn builds_child_path() {
        let root = ActorPath::root(Address::local("S"));
        let user = root.child("user");
        let foo = user.child("foo");
        assert_eq!(foo.name(), "foo");
        assert_eq!(foo.depth(), 2);
        assert_eq!(foo.to_string(), "akka://S/user/foo");
    }

    #[test]
    fn parent_pops_element() {
        let root = ActorPath::root(Address::local("S")).child("user").child("a");
        assert_eq!(root.parent().unwrap().name(), "user");
    }
}