my_stack/
lib.rs

1#[derive(Debug)]
2pub struct Stack<T> {
3    size: usize,
4    data: Vec<T>,
5}
6
7impl<T> Stack<T> {
8    pub fn new() -> Self {
9        Stack {
10            size: 0,
11            data: Vec::new(),
12        }
13    }
14
15    pub fn is_empty(&self) -> bool {
16        self.size == 0
17    }
18
19    pub fn push(&mut self, item: T) {
20        self.data.push(item);
21        self.size += 1;
22    }
23
24    pub fn pop(&mut self) -> Option<T> {
25        if self.size == 0 {
26            None
27        } else {
28            self.size -= 1;
29            self.data.pop()
30        }
31    }
32
33    pub fn peek(&self) -> Option<&T> {
34        if self.size == 0 {
35            None
36        } else {
37            self.data.last()
38        }
39    }
40
41    pub fn size(&self) -> usize {
42        self.size
43    }
44
45    pub fn clear(&mut self) {
46        self.data.clear();
47    }
48
49    pub fn into_iter(self) -> IntoIter<T> {
50        IntoIter(self)
51    }
52
53    pub fn iter(&self) -> Iter<T> {
54        Iter {
55            stack: self.data.iter().collect(),
56        }
57    }
58
59    pub fn iter_mut(&mut self) -> IterMut<T> {
60        IterMut {
61            stack: self.data.iter_mut().collect(),
62        }
63    }
64}
65
66pub struct IntoIter<T>(Stack<T>);
67impl<T: Clone> Iterator for IntoIter<T> {
68    type Item = T;
69
70    fn next(&mut self) -> Option<Self::Item> {
71        if self.0.is_empty() {
72            None
73        } else {
74            self.0.size -= 1;
75            self.0.data.pop()
76        }
77    }
78}
79
80pub struct Iter<'a, T: 'a> {
81    stack: Vec<&'a T>,
82}
83impl<'a, T> Iterator for Iter<'a, T> {
84    type Item = &'a T;
85
86    fn next(&mut self) -> Option<Self::Item> {
87        self.stack.pop()
88    }
89}
90pub struct IterMut<'a, T: 'a> {
91    stack: Vec<&'a mut T>,
92}
93impl<'a, T> Iterator for IterMut<'a, T> {
94    type Item = &'a mut T;
95
96    fn next(&mut self) -> Option<Self::Item> {
97        self.stack.pop()
98    }
99}
100
101#[cfg(test)]
102mod tests {
103    use super::*;
104
105    #[test]
106    fn test_stack_new() {
107        let stack = Stack::<i32>::new();
108
109        assert_eq!(stack.size, 0);
110    }
111    #[test]
112    fn test_stack_is_empty() {
113        let stack = Stack::<i32>::new();
114
115        assert!(stack.is_empty());
116    }
117
118    #[test]
119    fn test_stack_push() {
120        let mut stack = Stack::<i32>::new();
121        stack.push(1);
122        stack.push(2);
123        stack.push(3);
124
125        assert_eq!(stack.size, 3);
126    }
127
128    #[test]
129    fn test_stack_pop() {
130        let mut stack = Stack::<i32>::new();
131        stack.push(1);
132        stack.push(2);
133        stack.push(3);
134
135        assert_eq!(stack.pop(), Some(3));
136    }
137
138    #[test]
139    fn test_stack_peek() {
140        let mut stack = Stack::<i32>::new();
141        stack.push(1);
142        stack.push(2);
143        stack.push(3);
144
145        assert_eq!(stack.peek(), Some(&3));
146    }
147
148    #[test]
149    fn test_stack_into_iter() {
150        let mut stack = Stack::<i32>::new();
151        stack.push(1);
152        stack.push(2);
153        stack.push(3);
154
155        let mut iter = stack.into_iter();
156        assert_eq!(iter.next(), Some(3));
157        assert_eq!(iter.next(), Some(2));
158        assert_eq!(iter.next(), Some(1));
159        assert_eq!(iter.next(), None);
160    }
161
162    #[test]
163    fn test_stack_iter() {
164        let mut stack = Stack::<i32>::new();
165        stack.push(1);
166        stack.push(2);
167        stack.push(3);
168
169        let mut iter = stack.iter();
170        assert_eq!(iter.next(), Some(&3));
171        assert_eq!(iter.next(), Some(&2));
172        assert_eq!(iter.next(), Some(&1));
173        assert_eq!(iter.next(), None);
174    }
175
176    #[test]
177    fn test_stack_iter_mut() {
178        let mut stack = Stack::<i32>::new();
179        stack.push(1);
180        stack.push(2);
181        stack.push(3);
182
183        let mut iter = stack.iter_mut();
184
185        assert_eq!(iter.next(), Some(&mut 3));
186        assert_eq!(iter.next(), Some(&mut 2));
187        assert_eq!(iter.next(), Some(&mut 1));
188    }
189}
my_stack/lib.rs

my_stack/
lib.rs
