Skip to main content

oxihuman_core/
observer_pattern.rs

1// Copyright (C) 2026 COOLJAPAN OU (Team KitaSan)
2// SPDX-License-Identifier: Apache-2.0
3#![allow(dead_code)]
4
5pub struct ObserverEventBus {
6    events: Vec<(String, String)>,
7}
8
9pub fn new_event_bus_observer() -> ObserverEventBus {
10    ObserverEventBus { events: Vec::new() }
11}
12
13pub fn bus_emit(b: &mut ObserverEventBus, event_type: &str, payload: &str) {
14    b.events.push((event_type.to_string(), payload.to_string()));
15}
16
17pub fn bus_events_of_type<'a>(b: &'a ObserverEventBus, event_type: &str) -> Vec<&'a str> {
18    b.events
19        .iter()
20        .filter(|(t, _)| t == event_type)
21        .map(|(_, p)| p.as_str())
22        .collect()
23}
24
25pub fn bus_event_count(b: &ObserverEventBus) -> usize {
26    b.events.len()
27}
28
29pub fn bus_clear(b: &mut ObserverEventBus) {
30    b.events.clear();
31}
32
33pub fn bus_has_event_type(b: &ObserverEventBus, t: &str) -> bool {
34    b.events.iter().any(|(et, _)| et == t)
35}
36
37#[cfg(test)]
38mod tests {
39    use super::*;
40
41    #[test]
42    fn test_emit_and_count() {
43        /* emit events and count them */
44        let mut b = new_event_bus_observer();
45        bus_emit(&mut b, "click", "button1");
46        bus_emit(&mut b, "hover", "button2");
47        assert_eq!(bus_event_count(&b), 2);
48    }
49
50    #[test]
51    fn test_events_of_type() {
52        /* filter events by type */
53        let mut b = new_event_bus_observer();
54        bus_emit(&mut b, "click", "a");
55        bus_emit(&mut b, "click", "b");
56        bus_emit(&mut b, "hover", "c");
57        let clicks = bus_events_of_type(&b, "click");
58        assert_eq!(clicks.len(), 2);
59        assert!(clicks.contains(&"a"));
60    }
61
62    #[test]
63    fn test_has_event_type() {
64        /* check if event type exists */
65        let mut b = new_event_bus_observer();
66        bus_emit(&mut b, "keydown", "enter");
67        assert!(bus_has_event_type(&b, "keydown"));
68        assert!(!bus_has_event_type(&b, "keyup"));
69    }
70
71    #[test]
72    fn test_clear() {
73        /* clear removes all events */
74        let mut b = new_event_bus_observer();
75        bus_emit(&mut b, "x", "y");
76        bus_clear(&mut b);
77        assert_eq!(bus_event_count(&b), 0);
78    }
79
80    #[test]
81    fn test_empty_bus() {
82        /* new bus has no events */
83        let b = new_event_bus_observer();
84        assert_eq!(bus_event_count(&b), 0);
85    }
86
87    #[test]
88    fn test_events_of_type_empty() {
89        /* no matching events returns empty */
90        let b = new_event_bus_observer();
91        let r = bus_events_of_type(&b, "click");
92        assert!(r.is_empty());
93    }
94
95    #[test]
96    fn test_multiple_types() {
97        /* multiple event types tracked correctly */
98        let mut b = new_event_bus_observer();
99        for _ in 0..3 {
100            bus_emit(&mut b, "A", "p");
101        }
102        bus_emit(&mut b, "B", "q");
103        assert_eq!(bus_events_of_type(&b, "A").len(), 3);
104        assert_eq!(bus_events_of_type(&b, "B").len(), 1);
105    }
106}