byte_array_ops/
iter.rs

1//! Iterator implementations for ByteArray
2//!
3//! Provides controlled iteration over byte references
4
5use super::model::ByteArray;
6
7// TODO document this in my md notes
8
9/// Iterator over immutable references to bytes in a [`ByteArray`].
10///
11/// Created by `ByteArray::iter()` or via `IntoIterator` for `&ByteArray`.
12pub struct ByteArrayIter<'a> {
13    inner: core::slice::Iter<'a, u8>,
14}
15
16/// Iterator over mutable references to bytes in a [`ByteArray`].
17///
18/// Created by `ByteArray::iter_mut()` or via `IntoIterator` for `&mut ByteArray`.
19pub struct ByteArrayIterMut<'a> {
20    inner: core::slice::IterMut<'a, u8>,
21}
22
23impl<'a> Iterator for ByteArrayIter<'a> {
24    type Item = &'a u8;
25
26    fn next(&mut self) -> Option<Self::Item> {
27        self.inner.next()
28    }
29}
30
31impl<'a> Iterator for ByteArrayIterMut<'a> {
32    type Item = &'a mut u8;
33
34    fn next(&mut self) -> Option<Self::Item> {
35        self.inner.next()
36    }
37}
38
39impl<'a> ExactSizeIterator for ByteArrayIter<'a> {
40    fn len(&self) -> usize {
41        self.inner.len()
42    }
43}
44
45impl<'a> ExactSizeIterator for ByteArrayIterMut<'a> {
46    fn len(&self) -> usize {
47        self.inner.len()
48    }
49}
50
51impl<'a> IntoIterator for &'a ByteArray {
52    type Item = &'a u8;
53    type IntoIter = ByteArrayIter<'a>;
54
55    fn into_iter(self) -> Self::IntoIter {
56        ByteArrayIter {
57            inner: self.bytes.iter(),
58        }
59    }
60}
61
62impl<'a> IntoIterator for &'a mut ByteArray {
63    type Item = &'a mut u8;
64    type IntoIter = ByteArrayIterMut<'a>;
65
66    fn into_iter(self) -> Self::IntoIter {
67        ByteArrayIterMut {
68            inner: self.bytes.iter_mut(),
69        }
70    }
71}
72impl ByteArray {
73    /// Returns an iterator over the bytes.
74    ///
75    /// # Example
76    /// ```
77    /// use byte_array_ops::ByteArray;
78    ///
79    /// let arr: ByteArray = "0xdeadbeef".parse().unwrap();
80    /// let mut iter = arr.iter();
81    /// assert_eq!(iter.next(), Some(&0xde));
82    /// assert_eq!(iter.next(),Some(&0xad));
83    /// assert_eq!(iter.next(),Some(&0xbe));
84    /// assert_eq!(iter.next(),Some(&0xef));
85    /// assert_eq!(iter.next(),None);
86    ///
87    /// ```
88    pub fn iter(&'_ self) -> ByteArrayIter<'_> {
89        ByteArrayIter {
90            inner: self.bytes.iter(),
91        }
92    }
93
94    /// Returns an iterator that allows modifying each byte.
95    ///
96    /// # Example
97    /// ```
98    /// use byte_array_ops::ByteArray;
99    ///
100    /// let mut arr: ByteArray = "0xff00ff".parse().unwrap();
101    /// let mut iter_mut = arr.iter_mut();
102    /// iter_mut.next();
103    /// let mut byte = iter_mut.next().unwrap();
104    /// *byte = 0xee;
105    /// assert_eq!(arr.as_bytes(),[0x0ff,0xee,0xff]);
106    ///
107    /// ```
108    pub fn iter_mut(&'_ mut self) -> ByteArrayIterMut<'_> {
109        ByteArrayIterMut {
110            inner: self.bytes.iter_mut(),
111        }
112    }
113}
114
115#[cfg(test)]
116mod tests {
117    use super::*;
118    use alloc::vec::Vec;
119
120    #[test]
121    fn test_iter_empty() {
122        let arr = ByteArray::default();
123
124        let mut iter = arr.iter();
125        assert_eq!(iter.next(), None);
126        assert_eq!(iter.next(), None);
127    }
128
129    #[test]
130    fn test_iter_single_byte() {
131        let arr: ByteArray = "0xff".parse().unwrap();
132
133        let mut iter = arr.iter();
134        assert_eq!(iter.next(), Some(&0xff));
135        assert_eq!(iter.next(), None);
136    }
137
138    #[test]
139    fn test_iter_exhaustion() {
140        let arr: ByteArray = "0xaabbcc".parse().unwrap();
141
142        let mut iter = arr.iter();
143        assert_eq!(iter.next(), Some(&0xaa));
144        assert_eq!(iter.next(), Some(&0xbb));
145        assert_eq!(iter.next(), Some(&0xcc));
146        assert_eq!(iter.next(), None);
147        assert_eq!(iter.next(), None);
148    }
149
150    #[test]
151    fn test_multiple_iterators() {
152        let arr: ByteArray = "0xaabb".parse().unwrap();
153
154        let mut iter1 = arr.iter();
155        let mut iter2 = arr.iter();
156
157        assert_eq!(iter1.next(), Some(&0xaa));
158        assert_eq!(iter2.next(), Some(&0xaa));
159        assert_eq!(iter1.next(), Some(&0xbb));
160    }
161
162    #[test]
163    fn test_partial_iteration() {
164        let arr: ByteArray = "0xaabbccdd".parse().unwrap();
165
166        let mut iter = arr.iter();
167        assert_eq!(iter.next(), Some(&0xaa));
168        assert_eq!(iter.next(), Some(&0xbb));
169        // Drop iterator without consuming all elements
170    }
171
172    #[test]
173    fn test_for_loop() {
174        let arr: ByteArray = "0x010203".parse().unwrap();
175
176        let mut sum = 0u32;
177        for byte in &arr {
178            sum += *byte as u32;
179        }
180        assert_eq!(sum, 1 + 2 + 3);
181    }
182
183    #[test]
184    fn test_iter_mut_modification() {
185        let mut arr: ByteArray = "0x000000".parse().unwrap();
186
187        for byte in arr.iter_mut() {
188            *byte = 0xff;
189        }
190
191        assert_eq!(arr.as_bytes(), &[0xff, 0xff, 0xff]);
192    }
193
194    #[test]
195    fn test_iter_after_mutation() {
196        let mut arr: ByteArray = "0xaa".parse().unwrap();
197        arr[0] = 0xbb;
198
199        let mut iter = arr.iter();
200        assert_eq!(iter.next(), Some(&0xbb));
201    }
202
203    #[test]
204    fn test_collect() {
205        let arr: ByteArray = "0xaabbcc".parse().unwrap();
206
207        let collected: Vec<u8> = arr.iter().copied().collect();
208        let expected = Vec::from([0xaa, 0xbb, 0xcc]);
209        assert_eq!(collected, expected);
210    }
211
212    #[test]
213    fn test_iterator_methods() {
214        let arr: ByteArray = "0x010203".parse().unwrap();
215
216        assert_eq!(arr.iter().count(), 3);
217        assert!(arr.iter().any(|&b| b == 0x02));
218        assert!(arr.iter().all(|&b| b > 0));
219        assert_eq!(arr.iter().find(|&&b| b == 0x03), Some(&0x03));
220    }
221
222    #[test]
223    fn test_large_array() {
224        let arr = ByteArray::init_value(0xff, 10000);
225        assert_eq!(arr.iter().count(), 10000);
226    }
227
228    #[test]
229    fn test_borrow_then_iterate() {
230        let arr: ByteArray = "0xaa".parse().unwrap();
231        let _slice = arr.as_bytes();
232
233        let mut iter = arr.iter();
234        assert_eq!(iter.next(), Some(&0xaa));
235    }
236
237    #[test]
238    fn test_exact_size_iterator() {
239        let arr: ByteArray = "0xaabbccdd".parse().unwrap();
240
241        let iter = arr.iter();
242        assert_eq!(iter.len(), 4);
243
244        let mut iter = arr.iter();
245        iter.next();
246        assert_eq!(iter.len(), 3);
247
248        iter.next();
249        assert_eq!(iter.len(), 2);
250    }
251
252    #[test]
253    fn test_exact_size_iterator_mut() {
254        let mut arr: ByteArray = "0xaabbcc".parse().unwrap();
255
256        let iter = arr.iter_mut();
257        assert_eq!(iter.len(), 3);
258
259        let mut iter = arr.iter_mut();
260        iter.next();
261        assert_eq!(iter.len(), 2);
262    }
263
264    #[test]
265    fn test_exact_size_empty() {
266        let arr = ByteArray::default();
267
268        let iter = arr.iter();
269        assert_eq!(iter.len(), 0);
270    }
271
272    #[test]
273    fn test_iter_mut_for_loop() {
274        let mut arr: ByteArray = "0x010203".parse().unwrap();
275
276        for byte in &mut arr {
277            *byte = byte.wrapping_add(1);
278        }
279
280        assert_eq!(arr.as_bytes(), &[0x02, 0x03, 0x04]);
281    }
282}
byte_array_ops/iter.rs

byte_array_ops/
iter.rs
