singleton-registry 2.1.1

Thread-safe singleton registry for Rust with isolated, per-type storage — powers the JigsawFlow microkernel pattern
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

/// Events emitted by the registry during operations.
///
/// These events are passed to the tracing callback set via `set_trace_callback`.
/// The `Clone` derive allows callbacks to store or forward events if needed.
///
/// For `register`, two events are emitted per call: `Register` fires before the
/// value is stored (so a panic during storage is visible in the log), and
/// `RegisterCompleted` fires after the value is successfully stored. If only
/// `Register` appears without a following `RegisterCompleted`, the store panicked.
///
/// # Examples
///
/// ```rust
/// use singleton_registry::RegistryEvent;
///
/// let event = RegistryEvent::Register { type_name: "i32" };
/// assert_eq!(event.to_string(), "register { type_name: i32 }");
/// ```
#[derive(Debug, Clone)]
pub enum RegistryEvent {
    /// A register call was received. Fires before the value is stored.
    /// Followed by `RegisterCompleted` on success.
    Register {
        /// The type name of the value being registered (e.g., "i32", "alloc::string::String")
        type_name: &'static str,
    },

    /// A value was successfully stored in the registry. Fires after the insert.
    RegisterCompleted {
        /// The type name of the value that was stored
        type_name: &'static str,
    },

    /// A value was requested from the registry.
    Get {
        /// The type name that was requested
        type_name: &'static str,
        /// Whether the value was found in the registry
        found: bool,
    },

    /// A type existence check was performed.
    Contains {
        /// The type name that was checked
        type_name: &'static str,
        /// Whether the type exists in the registry
        found: bool,
    },

    /// The registry was cleared.
    Clear {},
}

impl std::fmt::Display for RegistryEvent {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            RegistryEvent::Register { type_name } => {
                write!(f, "register {{ type_name: {} }}", type_name)
            }
            RegistryEvent::RegisterCompleted { type_name } => {
                write!(f, "register_completed {{ type_name: {} }}", type_name)
            }
            RegistryEvent::Get { type_name, found } => {
                write!(f, "get {{ type_name: {}, found: {} }}", type_name, found)
            }
            RegistryEvent::Contains { type_name, found } => {
                write!(
                    f,
                    "contains {{ type_name: {}, found: {} }}",
                    type_name, found
                )
            }
            RegistryEvent::Clear {} => write!(f, "Clearing the Registry"),
        }
    }
}

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

    #[test]
    fn test_display_register() {
        let ev = RegistryEvent::Register { type_name: "i32" };
        assert_eq!(ev.to_string(), "register { type_name: i32 }");
    }

    #[test]
    fn test_display_register_completed() {
        let ev = RegistryEvent::RegisterCompleted { type_name: "i32" };
        assert_eq!(ev.to_string(), "register_completed { type_name: i32 }");
    }

    #[test]
    fn test_display_get() {
        let ev = RegistryEvent::Get {
            type_name: "String",
            found: true,
        };
        assert_eq!(ev.to_string(), "get { type_name: String, found: true }");
    }

    #[test]
    fn test_display_contains() {
        let ev = RegistryEvent::Contains {
            type_name: "u8",
            found: false,
        };
        assert_eq!(ev.to_string(), "contains { type_name: u8, found: false }");
    }

    #[test]
    fn test_display_clear() {
        let ev = RegistryEvent::Clear {};
        assert_eq!(ev.to_string(), "Clearing the Registry");
    }
}