13828738578

Committed 13 Mar 2025 06:49AM UTC coverage: 79.359% (-9.9%) from 89.24%

Build # 13828738578

Build Type

push

github

Committed by

kaidokert

Commit Message

Minim2: Another ground up rethink

Run Details

435 of 518 new or added lines in 3 files covered. (83.98%)

88 existing lines in 7 files now uncovered.

1584 of 1996 relevant lines covered (79.36%)

7.6 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

54.67

/src/containers/queues/circularqueue.rs

// SPDX-License-Identifier: Apache-2.0

use super::Deque;

/// A minimal circular queue with a fixed capacity.
pub struct CircularQueue<T, const N: usize> {
    buffer: [T; N],
    head: usize,
    tail: usize,
    size: usize,
}

impl<T: Default + Copy, const N: usize> Default for CircularQueue<T, N> {
    fn default() -> Self {
        Self::new()
    }
}

impl<T: Default + Copy, const N: usize> CircularQueue<T, N> {
    pub fn new() -> Self {
        Self {
            buffer: [T::default(); N],
            head: 0,
            tail: 0,
            size: 0,
        }
    }
}

impl<T: Default + Copy, const N: usize> Deque<T> for CircularQueue<T, N> {
    fn push_front(&mut self, value: T) -> Result<(), T> {
        if self.is_full() {
            Err(value)
        } else {
            self.head = (self.head + N - 1) % N;
            self.buffer[self.head] = value;
            self.size += 1;
            Ok(())
        }
    }
    fn pop_front(&mut self) -> Option<T> {
        if self.is_empty() {
            return None;
        }
        let value = self.buffer[self.head];
        self.head = (self.head + 1) % N;
        self.size -= 1;
        Some(value)
    }
    fn push_back(&mut self, value: T) -> Result<(), T> {
        if self.is_full() {
            Err(value)
        } else {
            self.buffer[self.tail] = value;
            self.tail = (self.tail + 1) % N;
            self.size += 1;
            Ok(())
        }
    }
    fn pop_back(&mut self) -> Option<T> {
        if self.is_empty() {
            return None;
        }
        self.tail = (self.tail + N - 1) % N;
        let value = self.buffer[self.tail];
        self.size -= 1;
        Some(value)
    }

    fn is_empty(&self) -> bool {
        self.size == 0
    }

    fn len(&self) -> usize {
        self.size
    }

    fn clear(&mut self) {
        self.head = 0;
        self.tail = 0;
        self.size = 0;
    }

    fn capacity(&self) -> usize {
        N
    }

    fn back(&self) -> Option<&T> {
        if self.is_empty() {
            return None;
        }
        let index = (self.tail + N - 1) % N;
        Some(&self.buffer[index])
    }

    fn front(&self) -> Option<&T> {
        if self.is_empty() {
            return None;
        }
        Some(&self.buffer[self.head])
    }
    fn is_full(&self) -> bool {
        self.size >= N
    }
}

1	// SPDX-License-Identifier: Apache-2.0
2
3	use super::Deque;
4
5	/// A minimal circular queue with a fixed capacity.
6	pub struct CircularQueue<T, const N: usize> {
7	buffer: [T; N],
8	head: usize,
9	tail: usize,
10	size: usize,
11	}
12
13	impl<T: Default + Copy, const N: usize> Default for CircularQueue<T, N> {
14	fn default() -> Self {	×
15	Self::new()	×
16	}	×
17	}
18
19	impl<T: Default + Copy, const N: usize> CircularQueue<T, N> {
20	pub fn new() -> Self {	1✔
21	Self {	1✔
22	buffer: [T::default(); N],	1✔
23	head: 0,	1✔
24	tail: 0,	1✔
25	size: 0,	1✔
26	}	1✔
27	}	1✔
28	}
29
30	impl<T: Default + Copy, const N: usize> Deque<T> for CircularQueue<T, N> {
31	fn push_front(&mut self, value: T) -> Result<(), T> {	8✔
32	if self.is_full() {	8✔
33	Err(value)	1✔
34	} else {
35	self.head = (self.head + N - 1) % N;	7✔
36	self.buffer[self.head] = value;	7✔
37	self.size += 1;	7✔
38	Ok(())	7✔
39	}
40	}	8✔
41	fn pop_front(&mut self) -> Option<T> {	×
42	if self.is_empty() {	×
43	return None;	×
44	}	×
45	let value = self.buffer[self.head];	×
46	self.head = (self.head + 1) % N;	×
47	self.size -= 1;	×
48	Some(value)	×
49	}	×
UNCOV 50	fn push_back(&mut self, value: T) -> Result<(), T> {	×
UNCOV 51	if self.is_full() {	×
UNCOV 52	Err(value)	×
53	} else {
UNCOV 54	self.buffer[self.tail] = value;	×
UNCOV 55	self.tail = (self.tail + 1) % N;	×
UNCOV 56	self.size += 1;	×
UNCOV 57	Ok(())	×
58	}
UNCOV 59	}	×
60	fn pop_back(&mut self) -> Option<T> {	2✔
61	if self.is_empty() {	2✔
UNCOV 62	return None;	×
63	}	2✔
64	self.tail = (self.tail + N - 1) % N;	2✔
65	let value = self.buffer[self.tail];	2✔
66	self.size -= 1;	2✔
67	Some(value)	2✔
68	}	2✔
69
70	fn is_empty(&self) -> bool {	6✔
71	self.size == 0	6✔
72	}	6✔
73
74	fn len(&self) -> usize {	2✔
75	self.size	2✔
76	}	2✔
77
78	fn clear(&mut self) {	2✔
79	self.head = 0;	2✔
80	self.tail = 0;	2✔
81	self.size = 0;	2✔
82	}	2✔
83
84	fn capacity(&self) -> usize {	2✔
85	N	2✔
86	}	2✔
87
88	fn back(&self) -> Option<&T> {	×
89	if self.is_empty() {	×
90	return None;	×
91	}	×
92	let index = (self.tail + N - 1) % N;	×
93	Some(&self.buffer[index])	×
94	}	×
95
96	fn front(&self) -> Option<&T> {	×
97	if self.is_empty() {	×
98	return None;	×
99	}	×
100	Some(&self.buffer[self.head])	×
101	}	×
102	fn is_full(&self) -> bool {	8✔
103	self.size >= N	8✔
104	}	8✔
105	}

kaidokert / heapless-graphs-rs / 13828738578

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous