Skip to main content

oxihuman_core/
simple_message_queue.rs

1// Copyright (C) 2026 COOLJAPAN OU (Team KitaSan)
2// SPDX-License-Identifier: Apache-2.0
3#![allow(dead_code)]
4
5use std::collections::VecDeque;
6
7pub struct SimpleMessageQueue {
8    pub messages: VecDeque<String>,
9    pub capacity: usize,
10}
11
12impl SimpleMessageQueue {
13    pub fn new(capacity: usize) -> Self {
14        SimpleMessageQueue {
15            messages: VecDeque::new(),
16            capacity,
17        }
18    }
19}
20
21pub fn new_message_queue_simple(capacity: usize) -> SimpleMessageQueue {
22    SimpleMessageQueue::new(capacity)
23}
24
25pub fn smq_push(q: &mut SimpleMessageQueue, msg: &str) -> bool {
26    if q.messages.len() >= q.capacity {
27        return false;
28    }
29    q.messages.push_back(msg.to_string());
30    true
31}
32
33pub fn smq_pop(q: &mut SimpleMessageQueue) -> Option<String> {
34    q.messages.pop_front()
35}
36
37pub fn smq_peek(q: &SimpleMessageQueue) -> Option<&str> {
38    q.messages.front().map(|s| s.as_str())
39}
40
41pub fn smq_len(q: &SimpleMessageQueue) -> usize {
42    q.messages.len()
43}
44
45pub fn smq_is_empty(q: &SimpleMessageQueue) -> bool {
46    q.messages.is_empty()
47}
48
49pub fn smq_is_full(q: &SimpleMessageQueue) -> bool {
50    q.messages.len() >= q.capacity
51}
52
53pub fn smq_clear(q: &mut SimpleMessageQueue) {
54    q.messages.clear();
55}
56
57#[cfg(test)]
58mod tests {
59    use super::*;
60
61    #[test]
62    fn test_new_empty() {
63        /* new queue is empty */
64        let q = new_message_queue_simple(5);
65        assert!(smq_is_empty(&q));
66        assert_eq!(smq_len(&q), 0);
67    }
68
69    #[test]
70    fn test_push_and_pop() {
71        /* push then pop returns message in FIFO order */
72        let mut q = new_message_queue_simple(5);
73        smq_push(&mut q, "hello");
74        smq_push(&mut q, "world");
75        assert_eq!(smq_pop(&mut q).expect("should succeed"), "hello");
76        assert_eq!(smq_pop(&mut q).expect("should succeed"), "world");
77    }
78
79    #[test]
80    fn test_push_full() {
81        /* push on full queue returns false */
82        let mut q = new_message_queue_simple(2);
83        smq_push(&mut q, "a");
84        smq_push(&mut q, "b");
85        assert!(!smq_push(&mut q, "c"));
86    }
87
88    #[test]
89    fn test_peek() {
90        /* peek returns front without removing */
91        let mut q = new_message_queue_simple(5);
92        smq_push(&mut q, "front");
93        assert_eq!(smq_peek(&q), Some("front"));
94        assert_eq!(smq_len(&q), 1);
95    }
96
97    #[test]
98    fn test_is_full() {
99        /* is_full at capacity */
100        let mut q = new_message_queue_simple(1);
101        smq_push(&mut q, "x");
102        assert!(smq_is_full(&q));
103    }
104
105    #[test]
106    fn test_clear() {
107        /* clear empties the queue */
108        let mut q = new_message_queue_simple(5);
109        smq_push(&mut q, "m");
110        smq_clear(&mut q);
111        assert!(smq_is_empty(&q));
112    }
113
114    #[test]
115    fn test_pop_empty() {
116        /* pop on empty returns None */
117        let mut q = new_message_queue_simple(5);
118        assert!(smq_pop(&mut q).is_none());
119    }
120
121    #[test]
122    fn test_len() {
123        /* len tracks correctly */
124        let mut q = new_message_queue_simple(10);
125        smq_push(&mut q, "a");
126        smq_push(&mut q, "b");
127        smq_push(&mut q, "c");
128        assert_eq!(smq_len(&q), 3);
129    }
130}