1use core::slice;
8use std::{marker::PhantomData, ptr::NonNull};
9
10use crate::raw::{self, RawUnsizedStack, TableItem};
11
12pub struct Iter<'a, T: ?Sized> {
13 base: NonNull<u8>,
14 table_iter: slice::Iter<'a, TableItem>,
15 _phantom: PhantomData<&'a T>,
16}
17
18impl<'a, T: ?Sized> Iter<'a, T> {
19 pub fn new(raw: &'a RawUnsizedStack<T>) -> Self {
20 Self {
21 base: raw.buf_ptr(),
22 table_iter: raw.table().iter(),
23 _phantom: PhantomData,
24 }
25 }
26
27 fn with_iter(
28 &mut self,
29 func: impl FnOnce(&mut slice::Iter<'a, TableItem>) -> Option<&'a TableItem>,
30 ) -> Option<&'a T> {
31 Some(unsafe { &*raw::compose::<T>(self.base.as_ptr(), *func(&mut self.table_iter)?) })
33 }
34}
35
36impl<'a, T: ?Sized> Iterator for Iter<'a, T> {
37 type Item = &'a T;
38
39 fn next(&mut self) -> Option<Self::Item> {
40 self.with_iter(|iter| iter.next())
41 }
42
43 fn size_hint(&self) -> (usize, Option<usize>) {
44 self.table_iter.size_hint()
45 }
46
47 fn count(self) -> usize
48 where
49 Self: Sized,
50 {
51 self.table_iter.count()
52 }
53
54 fn nth(&mut self, n: usize) -> Option<Self::Item> {
55 self.with_iter(|iter| iter.nth(n))
56 }
57}
58
59impl<'a, T: 'a + ?Sized> DoubleEndedIterator for Iter<'a, T> {
60 fn next_back(&mut self) -> Option<Self::Item> {
61 self.with_iter(slice::Iter::next_back)
62 }
63
64 fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
65 self.with_iter(|iter| iter.nth_back(n))
66 }
67}
68
69impl<'a, T: ?Sized> ExactSizeIterator for Iter<'a, T> {}
70
71pub struct IterMut<'a, T: ?Sized> {
72 base: NonNull<u8>,
73 table_iter: slice::Iter<'a, TableItem>,
74 _phantom: PhantomData<&'a mut T>,
75}
76
77impl<'a, T: ?Sized> IterMut<'a, T> {
78 pub fn new(raw: &'a mut RawUnsizedStack<T>) -> Self {
79 Self {
80 base: raw.buf_ptr(),
81 table_iter: raw.table().iter(),
82 _phantom: PhantomData,
83 }
84 }
85
86 fn with_iter(
87 &mut self,
88 func: impl FnOnce(&mut slice::Iter<'a, TableItem>) -> Option<&'a TableItem>,
89 ) -> Option<&'a mut T> {
90 Some(unsafe {
92 &mut *raw::compose::<T>(self.base.as_ptr(), *func(&mut self.table_iter)?).cast_mut()
93 })
94 }
95}
96
97impl<'a, T: 'a + ?Sized> Iterator for IterMut<'a, T> {
98 type Item = &'a mut T;
99
100 fn next(&mut self) -> Option<Self::Item> {
101 self.with_iter(slice::Iter::next)
102 }
103
104 fn size_hint(&self) -> (usize, Option<usize>) {
105 self.table_iter.size_hint()
106 }
107
108 fn count(self) -> usize
109 where
110 Self: Sized,
111 {
112 self.table_iter.count()
113 }
114
115 fn nth(&mut self, n: usize) -> Option<Self::Item> {
116 self.with_iter(|iter| iter.nth(n))
117 }
118}
119
120impl<'a, T: ?Sized> DoubleEndedIterator for IterMut<'a, T> {
121 fn next_back(&mut self) -> Option<Self::Item> {
122 self.with_iter(slice::Iter::next_back)
123 }
124
125 fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
126 self.with_iter(|iter| iter.nth_back(n))
127 }
128}
129
130impl<'a, T: ?Sized> ExactSizeIterator for IterMut<'a, T> {}