simulacra 0.1.0

A deterministic discrete-event simulation engine for message flow across large computer networks
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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

//! Network node identification.

use std::fmt;

/// A unique identifier for a node in the network.
///
/// Node IDs are simple 32-bit integers for efficiency and ease of use.
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct NodeId(pub u32);

impl NodeId {
    /// Creates a new node ID.
    #[inline]
    pub const fn new(id: u32) -> Self {
        NodeId(id)
    }

    /// Returns the raw ID value.
    #[inline]
    pub const fn as_u32(&self) -> u32 {
        self.0
    }

    /// Returns the ID as a usize for indexing.
    #[inline]
    pub const fn as_usize(&self) -> usize {
        self.0 as usize
    }
}

impl From<u32> for NodeId {
    fn from(id: u32) -> Self {
        NodeId(id)
    }
}

impl From<usize> for NodeId {
    fn from(id: usize) -> Self {
        NodeId(id as u32)
    }
}

impl fmt::Debug for NodeId {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "Node({})", self.0)
    }
}

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

/// A unique identifier for a message.
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct MessageId(pub u64);

impl MessageId {
    /// Creates a new message ID.
    #[inline]
    pub const fn new(id: u64) -> Self {
        MessageId(id)
    }

    /// Returns the raw ID value.
    #[inline]
    pub const fn as_u64(&self) -> u64 {
        self.0
    }
}

impl From<u64> for MessageId {
    fn from(id: u64) -> Self {
        MessageId(id)
    }
}

impl fmt::Debug for MessageId {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "Msg({})", self.0)
    }
}

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

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

    #[test]
    fn node_id_conversions() {
        let id = NodeId::new(42);
        assert_eq!(id.as_u32(), 42);
        assert_eq!(id.as_usize(), 42);

        let from_u32: NodeId = 10u32.into();
        assert_eq!(from_u32.as_u32(), 10);

        let from_usize: NodeId = 20usize.into();
        assert_eq!(from_usize.as_u32(), 20);
    }

    #[test]
    fn node_id_ordering() {
        let ids = [NodeId(3), NodeId(1), NodeId(2)];
        let mut sorted = ids;
        sorted.sort();
        assert_eq!(sorted, [NodeId(1), NodeId(2), NodeId(3)]);
    }

    #[test]
    fn message_id_basics() {
        let id = MessageId::new(12345);
        assert_eq!(id.as_u64(), 12345);
        assert_eq!(format!("{}", id), "M12345");
    }
}