sqnc/
rev.rs

1use crate::traits::*;
2use core::iter;
3
4pub struct Rev<Seq>(Seq);
5
6impl<Seq> Rev<Seq> {
7    pub(crate) fn new(seq: Seq) -> Self {
8        Self(seq)
9    }
10}
11
12impl<'this, Seq> SequenceTypes<'this> for Rev<Seq>
13where
14    Seq: SequenceTypes<'this>,
15{
16    type Item = Seq::Item;
17    type Iter = iter::Rev<Seq::Iter>;
18}
19
20impl<'this, Seq> MutSequenceTypes<'this> for Rev<Seq>
21where
22    Seq: MutSequenceTypes<'this>,
23{
24    type MutItem = Seq::MutItem;
25    type IterMut = iter::Rev<Seq::IterMut>;
26}
27
28impl<Seq> Sequence for Rev<Seq>
29where
30    Seq: Sequence,
31{
32    #[inline]
33    fn len(&self) -> usize {
34        self.0.len()
35    }
36
37    #[inline]
38    fn is_empty(&self) -> bool {
39        self.0.is_empty()
40    }
41
42    #[inline]
43    fn get(&self, index: usize) -> Option<<Self as SequenceTypes<'_>>::Item> {
44        self.0.rget(index)
45    }
46
47    #[inline]
48    fn rget(&self, rindex: usize) -> Option<<Self as SequenceTypes<'_>>::Item> {
49        self.0.get(rindex)
50    }
51
52    #[inline]
53    fn first(&self) -> Option<<Self as SequenceTypes<'_>>::Item> {
54        self.0.last()
55    }
56
57    #[inline]
58    fn last(&self) -> Option<<Self as SequenceTypes<'_>>::Item> {
59        self.0.first()
60    }
61
62    #[inline]
63    fn iter(&self) -> <Self as SequenceTypes<'_>>::Iter {
64        self.0.iter().rev()
65    }
66
67    #[inline]
68    fn min<'a>(&'a self) -> Option<<Self as SequenceTypes<'a>>::Item>
69    where
70        <Self as SequenceTypes<'a>>::Item: Ord,
71    {
72        self.0.min()
73    }
74
75    #[inline]
76    fn max<'a>(&'a self) -> Option<<Self as SequenceTypes<'a>>::Item>
77    where
78        <Self as SequenceTypes<'a>>::Item: Ord,
79    {
80        self.0.max()
81    }
82}
83
84impl<Seq> MutSequence for Rev<Seq>
85where
86    Seq: MutSequence,
87{
88    #[inline]
89    fn get_mut(&mut self, index: usize) -> Option<<Self as MutSequenceTypes<'_>>::MutItem> {
90        self.0.rget_mut(index)
91    }
92
93    #[inline]
94    fn rget_mut(&mut self, rindex: usize) -> Option<<Self as MutSequenceTypes<'_>>::MutItem> {
95        self.0.get_mut(rindex)
96    }
97
98    #[inline]
99    fn first_mut(&mut self) -> Option<<Self as MutSequenceTypes<'_>>::MutItem> {
100        self.0.last_mut()
101    }
102
103    #[inline]
104    fn last_mut(&mut self) -> Option<<Self as MutSequenceTypes<'_>>::MutItem> {
105        self.0.first_mut()
106    }
107
108    #[inline]
109    fn iter_mut(&mut self) -> <Self as MutSequenceTypes<'_>>::IterMut {
110        self.0.iter_mut().rev()
111    }
112}
113
114// SAFETY: Any permutation of a unique sequence is unique.
115unsafe impl<Seq> UniqueSequence for Rev<Seq> where Seq: UniqueSequence {}
116
117#[cfg(test)]
118mod tests {
119    use super::Rev;
120    use crate::traits::*;
121
122    #[test]
123    fn len() {
124        assert_eq!(Rev::new(2..5).len(), 3);
125    }
126
127    #[test]
128    fn is_empty() {
129        assert_eq!(Rev::new(2..5).is_empty(), false);
130        assert_eq!(Rev::new(0..0).is_empty(), true);
131    }
132
133    #[test]
134    fn get() {
135        let x = Rev::new(2..5);
136        assert_eq!(x.get(0), Some(4));
137        assert_eq!(x.get(1), Some(3));
138        assert_eq!(x.get(2), Some(2));
139        assert_eq!(x.get(3), None);
140    }
141
142    #[test]
143    fn rget() {
144        let x = Rev::new(2..5);
145        assert_eq!(x.rget(0), Some(2));
146        assert_eq!(x.rget(1), Some(3));
147        assert_eq!(x.rget(2), Some(4));
148        assert_eq!(x.rget(3), None);
149    }
150
151    #[test]
152    fn first() {
153        assert_eq!(Rev::new(2..5).first(), Some(4));
154        assert_eq!(Rev::new(0..0).first(), None);
155    }
156
157    #[test]
158    fn last() {
159        assert_eq!(Rev::new(2..5).last(), Some(2));
160        assert_eq!(Rev::new(0..0).last(), None);
161    }
162
163    #[test]
164    fn iter() {
165        assert!(Rev::new(2..5).iter().eq(Iterator::rev(2..5)));
166    }
167
168    #[test]
169    fn min() {
170        assert_eq!(Rev::new(2..5).min(), Some(2));
171        assert_eq!(Rev::new(0..0).min(), None);
172    }
173
174    #[test]
175    fn max() {
176        assert_eq!(Rev::new(2..5).max(), Some(4));
177        assert_eq!(Rev::new(0..0).max(), None);
178    }
179
180    #[test]
181    fn get_mut() {
182        let mut x = [2, 3, 4];
183        let mut y = Rev::new(x.as_mut_sqnc());
184        *y.get_mut(0).unwrap() = 7;
185        *y.get_mut(1).unwrap() = 6;
186        *y.get_mut(2).unwrap() = 5;
187        assert!(y.get_mut(3).is_none());
188        assert_eq!(x, [5, 6, 7]);
189    }
190
191    #[test]
192    fn rget_mut() {
193        let mut x = [2, 3, 4];
194        let mut y = Rev::new(x.as_mut_sqnc());
195        *y.rget_mut(0).unwrap() = 5;
196        *y.rget_mut(1).unwrap() = 6;
197        *y.rget_mut(2).unwrap() = 7;
198        assert!(y.rget_mut(3).is_none());
199        assert_eq!(x, [5, 6, 7]);
200    }
201
202    #[test]
203    fn first_mut() {
204        let mut x = [2, 3, 4];
205        let mut y = Rev::new(x.as_mut_sqnc());
206        *y.first_mut().unwrap() = 5;
207        assert_eq!(x, [2, 3, 5]);
208        assert!(Rev::<[usize; 0]>::new([]).first_mut().is_none());
209    }
210
211    #[test]
212    fn last_mut() {
213        let mut x = [2, 3, 4];
214        let mut y = Rev::new(x.as_mut_sqnc());
215        *y.last_mut().unwrap() = 5;
216        assert_eq!(x, [5, 3, 4]);
217        assert!(Rev::<[usize; 0]>::new([]).last_mut().is_none());
218    }
219
220    #[test]
221    fn iter_mut() {
222        let mut x = [2, 3, 4];
223        let mut y = Rev::new(x.as_mut_sqnc());
224        let mut iter = y.iter_mut();
225        *iter.next().unwrap() = 7;
226        *iter.next().unwrap() = 6;
227        *iter.next().unwrap() = 5;
228        assert!(iter.next().is_none());
229        assert_eq!(x, [5, 6, 7]);
230    }
231}
sqnc/rev.rs

sqnc/
rev.rs
