rabble 0.4.1

A library for creating location transparent actor based systems
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

use std::fmt::{Debug, Display, Error, Formatter};
use std::str::FromStr;
use node_id::NodeId;

/// A globally unique process id
///
/// Pids can be grouped together for various reasons. This grouping acts like a namespace. If
/// a Process is not a member of a group, the `group` member of the Pid will be `None`.
#[derive(Clone, Hash, Eq, PartialEq, Ord, PartialOrd, Serialize, Deserialize)]
pub struct Pid {
    pub group: Option<String>,
    pub name: String,
    pub node: NodeId,
}

/// Explicitly format Pid in the display format since it is huge when pretty printing and they are
/// used all over the place.
impl Debug for Pid {
    fn fmt(&self, f: &mut Formatter) -> Result<(), Error> {
        Display::fmt(&self, f)
    }
}

impl Display for Pid {
    fn fmt(&self, f: &mut Formatter) -> Result<(), Error> {
        match self.group {
            None => write!(f, "{}::{}", self.name, self.node),
            Some(ref g) => write!(f, "{}::{}::{}", g, self.name, self.node)
        }
    }
}

impl FromStr for Pid {
    type Err = String;

    fn from_str(s: &str) -> Result<Pid, String> {
        let v: Vec<&str> = s.split("::").collect();
        match v.len() {
            2 => Ok(Pid {
                group: None,
                name: v[0].to_string(),
                node: try!(NodeId::from_str(v[1]))
            }),
            3 => Ok(Pid {
                group: Some(v[0].to_string()),
                name: v[1].to_string(),
                node: try!(NodeId::from_str(v[2]))
            }),
            _ => return Err(
                "Invalid Pid format - Must be of form 'name::node' or \
                'group::name::node'".to_string()
            )
        }
    }
}