acktor 1.0.14

Pure-Rust actor framework built on top of the Tokio async 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

use std::fmt::{self, Debug, Display};
#[cfg(feature = "ipc")]
use std::num::NonZeroU64;

/// Actor index.
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct ActorId {
    index: u64,
    session: u64,
}

impl Debug for ActorId {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        if self.session == 0 {
            write!(f, "{}", self.index)
        } else {
            write!(f, "{}@{}", self.index, self.session)
        }
    }
}

impl Display for ActorId {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        Debug::fmt(self, f)
    }
}

impl ActorId {
    /// Constructs a new `ActorId` from an local index.
    pub const fn new(index: u64) -> Self {
        Self { index, session: 0 }
    }

    /// Returns the local index part of this `ActorId`.
    pub const fn as_local(&self) -> u64 {
        self.index
    }

    /// Constructs a new `ActorId` from a local index and a non-zero remote session index.
    #[cfg(feature = "ipc")]
    #[cfg_attr(docsrs, doc(cfg(feature = "ipc")))]
    pub const fn new_remote(index: u64, session: NonZeroU64) -> Self {
        Self {
            index,
            session: session.get(),
        }
    }

    /// Returns true if this `ActorId` is a remote index.
    #[cfg(feature = "ipc")]
    #[cfg_attr(docsrs, doc(cfg(feature = "ipc")))]
    pub const fn is_remote(&self) -> bool {
        self.session != 0
    }
}

#[cfg(test)]
mod tests {
    use pretty_assertions::assert_eq;

    use super::*;

    #[test]
    fn test_local_id() {
        let id = ActorId::new(42);
        assert_eq!(id.as_local(), 42);
        assert_eq!(format!("{:?}", id), "42");
        assert_eq!(format!("{}", id), "42");
        assert!(ActorId::new(1) < ActorId::new(2));
        assert_eq!(ActorId::new(1), ActorId::new(1));
    }

    #[cfg(feature = "ipc")]
    #[test]
    fn test_remote_id() {
        let remote = ActorId::new_remote(3, std::num::NonZeroU64::new(5).unwrap());
        assert!(remote.is_remote());
        assert_eq!(remote.as_local(), 3);
        assert_eq!(format!("{:?}", remote), "3@5");
        assert!(!ActorId::new(3).is_remote());
    }
}