core_extensions/slices/
slice_split_while.rs

Help
1use std_::mem;
2
3#[allow(unused_imports)]
4use super::ValSliceExt;
5
6
7#[inline(always)]
8fn next_split<'a,T, P, U: Eq + Clone>(
9    pred: &mut P,
10    s: &mut &'a [T],
11    last: &mut U,
12) -> Option<KeySlice<'a,T, U>>
13where
14    P: FnMut(&'a T) -> U,
15{
16    let mut next = last.clone();
17    if s.is_empty() {
18        return None;
19    }
20    let end = s.iter()
21        .position(|x|{
22            next=pred(x);
23            *last!=next
24        })
25        .unwrap_or(s.len());
26    let (ret, new_s) = s.split_at(end);
27    *s = new_s;
28    let key = mem::replace(last, next);
29    Some(KeySlice { slice: ret, key })
30}
31
32#[inline(always)]
33fn next_rsplit<'a, T, P, U: Eq + Clone>(
34    pred: &mut P,
35    s: &mut &'a [T],
36    last: &mut U,
37) -> Option<KeySlice<'a, T, U>>
38where
39    P: FnMut(&'a T) -> U,
40{
41    let mut next = last.clone();
42    if s.is_empty() {
43        return None;
44    }
45    let left = (*s).iter()
46        .rposition(|x|{
47            next=pred(x);
48            *last!=next
49        })
50        .map_or(0,|x|x+1);
51    let (new_s, ret) = s.split_at(left);
52    *s = new_s;
53    let key = mem::replace(last, next);
54    Some(KeySlice { slice: ret, key })
55}
56
57//-------------------------------------------------------------------------------------------
58
59/// A pair of (slice, key) returned by the 
60/// [RSplitSliceWhile](struct.RSplitSliceWhile.html)/
61/// [SplitSliceWhile](struct.SplitSliceWhile.html) iterators.
62///
63#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd)]
64pub struct KeySlice<'a, T:'a, U> {
65    /// A slice where every element was mapped to the same key by a closure.
66    pub slice: &'a [T],
67    /// The value that all the elements in the slice were mapped to.
68    pub key: U,
69}
70
71impl<'a, T, U> KeySlice<'a, T, U> {
72    /// Converts this into a key-slice pair.
73    pub fn into_pair(self) -> (U, &'a [T]){
74        (self.key, self.slice)
75    }
76}
77
78//-------------------------------------------------------------------------------------------
79
80/// Iterator over slices,
81/// in which all the elements in each slice were mapped to the same key by a closure.
82///
83/// Look [here](trait.ValSliceExt.html#method.split_while) for examples.
84#[derive(Debug, Clone)]
85pub struct SplitSliceWhile<'a, T:'a, P, U> {
86    pub(super) mapper: P,
87    pub(super) s: &'a [T],
88    pub(super) last_left: Option<U>,
89    pub(super) last_right: Option<U>,
90}
91
92impl<'a, T, P, U: Eq + Clone> Iterator for SplitSliceWhile<'a, T, P, U>
93where
94    P: FnMut(&'a T) -> U,
95{
96    type Item = KeySlice<'a, T, U>;
97    fn next(&mut self) -> Option<Self::Item> {
98        next_split(&mut self.mapper, &mut self.s,self.last_left.as_mut()?)
99    }
100    fn size_hint(&self)->(usize,Option<usize>){
101        let s=self.s;
102        let min_len=if s.is_empty() { 0 }else{ 1 };
103        ( min_len , Some(s.len()) )
104    }
105}
106
107impl<'a, T, P, U: Eq + Clone> DoubleEndedIterator for SplitSliceWhile<'a, T, P, U>
108where
109    P: FnMut(&'a T) -> U,
110{
111    fn next_back(&mut self) -> Option<Self::Item> {
112        next_rsplit(&mut self.mapper, &mut self.s, self.last_right.as_mut()?)
113    }
114}
115
116//-------------------------------------------------------------------------------------------
117
118/// Iterator over slices,
119/// in which all the elements in each slice were mapped to the same key by a closure,
120/// iterating from the end.
121///
122/// Look [here](trait.ValSliceExt.html#method.rsplit_while) for examples.
123#[derive(Debug, Clone)]
124pub struct RSplitSliceWhile<'a, T:'a, P, U> {
125    pub(super) mapper: P,
126    pub(super) s: &'a [T],
127    pub(super) last_left: Option<U>,
128    pub(super) last_right: Option<U>,
129}
130
131impl<'a, T, P, U: Eq + Clone> Iterator for RSplitSliceWhile<'a, T, P, U>
132where
133    P: FnMut(&'a T) -> U,
134{
135    type Item = KeySlice<'a, T, U>;
136    fn next(&mut self) -> Option<Self::Item> {
137        next_rsplit(&mut self.mapper, &mut self.s, self.last_right.as_mut()?)
138    }
139    fn size_hint(&self)->(usize,Option<usize>){
140        let s=self.s;
141        let min_len=if s.is_empty() { 0 }else{ 1 };
142        ( min_len , Some(s.len()) )
143    }
144}
145
146impl<'a, T, P, U: Eq + Clone> DoubleEndedIterator for RSplitSliceWhile<'a, T, P, U>
147where
148    P: FnMut(&'a T) -> U,
149{
150    fn next_back(&mut self) -> Option<Self::Item> {
151        next_split(&mut self.mapper, &mut self.s, self.last_left.as_mut()?)
152    }
153}
154
155//-------------------------------------------------------------------------------------------
156
157
158#[cfg(test)]
159#[cfg(feature = "alloc")]
160mod test{
161    use super::*;
162
163    use alloc::{
164        vec::Vec,
165        vec,
166    };
167
168    fn func<'a,T,U,F>(s:&'a [T],f:F)->Vec<(U,Vec<T>)>
169    where
170        T:Clone,
171        F:FnMut(&'a T)->U,
172        U:Eq+Clone,
173    {
174        s.split_while(f).map(|v| (v.key,v.slice.to_vec()) ).collect()
175    }
176
177    fn rfunc<'a,T,U,F>(s:&'a [T],f:F)->Vec<(U,Vec<T>)>
178    where
179        T:Clone,
180        F:FnMut(&'a T)->U,
181        U:Eq+Clone,
182    {
183        s.rsplit_while(f).map(|v| (v.key,v.slice.to_vec()) ).collect()
184    }
185
186    fn new_singletons()->Vec<Vec<u32>>{
187        (0..30).map(|x| vec![x] ).collect()
188    }
189
190    fn new_list_0()->Vec<u32>{
191        vec![0,9,1,4,5]
192    }
193    fn new_list_1()->Vec<u32>{
194        vec![90,91,92,93,94,95]
195    }
196    fn new_list_2()->Vec<u32>{
197        vec![10,5,4,17]
198    }
199    fn mapper_0(x:&u32)->u32{x%3}
200
201    fn mapper_1(x:&u32)->u32{*x}
202
203    fn mapper_2(x:&u32)->u32{x/3}
204
205    fn spair<T>(v:&T)->(T,Vec<T>)
206    where T:Clone
207    {
208        (v.clone(),vec![v.clone()])
209    }
210
211
212
213    #[test]
214    fn with_every_mapper(){
215
216        for mapper in vec![ mapper_0 as fn(&_)->_,mapper_1,mapper_2 ] {
217            assert_eq!(func(&vec![] ,mapper_0),vec![]);
218            assert_eq!(rfunc(&vec![] ,mapper_0),vec![]);
219            
220            let singletons=new_singletons();
221            for list in singletons.iter() {
222                assert_eq!(func(list,mapper),vec![(mapper(&list[0]),list.clone())]);
223                assert_eq!(rfunc(list,mapper),vec![(mapper(&list[0]),list.clone())]);
224            }
225        }
226    }
227
228
229
230    #[test]
231    fn with_mapper_0(){
232        {
233            let list_0=new_list_0();
234            let mut expected=vec![(0,vec![0,9]),(1,vec![1,4]),(2,vec![5])];
235            assert_eq!(func(&list_0,mapper_0),expected);
236            expected.reverse();
237            assert_eq!(rfunc(&list_0,mapper_0),expected);
238        }
239        for list in vec![new_list_1(),new_list_2()] {
240            let mut expected=list.iter()
241                .map(|x| (mapper_0(x),vec![*x]) )
242                .collect::<Vec<_>>();
243            assert_eq!(func(&list,mapper_0),expected);
244            expected.reverse();
245            assert_eq!(rfunc(&list,mapper_0),expected);
246        }
247    }
248
249    #[test]
250    fn with_mapper_1(){
251        for list in vec![new_list_0(),new_list_1(),new_list_2()] {
252            let mut expected=list.iter().map(spair).collect::<Vec<_>>();
253            assert_eq!(func(&list,mapper_1),expected);
254            expected.reverse();
255            assert_eq!(rfunc(&list,mapper_1),expected);
256        }    
257    }
258
259    #[test]
260    fn with_mapper_2(){
261        {
262            let list_0=new_list_0();
263            let mut expected=vec![(0,vec![0]),(3,vec![9]),(0,vec![1]),(1,vec![4,5])];
264            assert_eq!(func(&list_0,mapper_2),expected);
265            expected.reverse();
266            assert_eq!(rfunc(&list_0,mapper_2),expected);
267        }
268        {
269            let list_1=new_list_1();
270            let mut expected=vec![(30,vec![90,91,92]),(31,vec![93,94,95])];
271            assert_eq!(func(&list_1,mapper_2),expected);
272            expected.reverse();
273            assert_eq!(rfunc(&list_1,mapper_2),expected);
274        }
275        {
276            let list_2=new_list_2();
277            let mut expected=vec![(3,vec![10]),(1,vec![5,4]),(5,vec![17])];
278            assert_eq!(func(&list_2,mapper_2),expected);
279            expected.reverse();
280            assert_eq!(rfunc(&list_2,mapper_2),expected);
281        }
282    }
283
284
285
286}
core_extensions/slices/slice_split_while.rs

core_extensions/slices/
slice_split_while.rs
