more_itertools/
utils.rs

1use crate::error;
2use crate::error::Error;
3use std::collections::{HashMap, VecDeque};
4use std::hash::Hash;
5
6pub fn extract_value_from_result_vec<T>(vec: Vec<Result<T, Error>>) -> (Vec<T>, Option<Error>) {
7    let mut ret_vec = Vec::new();
8    for v in vec.into_iter() {
9        match v {
10            Err(err2) => { return (ret_vec, Some(err2)); },
11            Ok(v2) => { ret_vec.push(v2); }
12        }
13    }
14    return (ret_vec, None);
15}
16
17pub fn join_string_vec(v: &Vec<char>) -> String{
18    return v.iter().collect();
19}
20
21pub fn join_char_vec_second_level(l: &Vec<Vec<char>>) -> Vec<String> {
22    let mut ret = vec![];
23    for item in l {
24        ret.push(join_string_vec(item));
25    }
26    return ret;
27}
28
29pub fn any(v: &Vec<bool>) -> bool {
30    for i in v.iter() {
31        if *i {
32            return true;
33        }
34    }
35    return false;
36}
37
38pub fn any1(v: Vec<bool>) -> Result<bool,Error> {
39    for i in v.iter() {
40        if *i {
41            return Ok(true);
42        }
43    }
44    return Ok(false);
45}
46
47
48
49// pub fn any_result(v: Result<Vec<bool>, Error>) -> bool {
50//     if v.is_err() {
51//         return false;
52//     }
53//     return any(&(v.as_ref().ok().unwrap()));
54// }
55
56pub fn any_result2(v: Vec<Result<bool, Error>>) -> Result<bool, Error> {
57    for i in v.iter() {
58        if i.is_ok() {
59            if *i.as_ref().unwrap() {
60                return Ok(true);
61            }
62        } else {
63            return i.clone();
64        }
65    }
66    return Ok(false);
67}
68
69
70
71pub fn are_same<T>(op1: Option<&T> , op2: Option<&T>) -> bool 
72where T: PartialEq
73{
74    match (op1, op2) {
75        (None, None) => { return true; },
76        (Some(v1), Some(v2)) => { return *v1 == *v2; },
77        _ => { return false; }
78    }
79}
80
81pub fn argsort<T: Ord>(data: &[T]) -> Vec<usize> {
82    let mut indices = (0..data.len()).collect::<Vec<_>>();
83    indices.sort_by_key(|&i| &data[i]);
84    return indices;
85}
86
87
88pub fn counter<T>(hm: &mut HashMap<T, usize>, mut iter: Box<dyn Iterator<Item = Result<T,Error>>>) -> Result<(), Error>
89where T: Hash + Eq + PartialEq
90{
91    loop {
92        let _next = iter.next();
93
94        if let Some(res) = _next {
95            match res {
96                Ok(key) => {
97                    let value = hm.get_mut(&key);
98                    let add_res;
99                    if value.is_none() {
100                        add_res = (1, false);
101                    } else {
102                        add_res = usize::overflowing_add(*value.unwrap(), 1);
103                    }
104                    
105                    if add_res.1 {
106                        return Err(error::overflow_error("[counter] overflow".to_string()));
107                    } else {
108                        hm.insert(key, add_res.0);
109                        continue;
110                    }
111                },
112                Err(err) => {
113                    return Err(error::any_error(err.kind(), err.message().unwrap().clone()));
114                }
115            }
116        } else {
117            return Ok(());
118        }
119    }
120}
121
122struct Okok<T> {
123    ok_vec: Vec<T>,
124    cur: usize
125}
126
127impl<T> Iterator for Okok<T> 
128where
129T: Clone + 'static
130{
131    type Item = Result<T, Error>;
132
133    fn next(&mut self) -> Option<Self::Item> {
134        if self.cur >= self.ok_vec.len() {
135            return None;
136        } else {
137            let ret = self.ok_vec.get(self.cur).unwrap().clone();
138            self.cur += 1;
139            return Some(Ok(ret));
140        }
141    }
142}
143
144pub fn generate_okok_iterator<T>(ok_vec: Vec<T>) -> Box<dyn Iterator<Item = Result<T, Error>>> 
145where
146T: Clone + 'static
147{
148    return Box::new(Okok {
149        ok_vec,
150        cur: 0
151    });
152}
153
154struct Okokerr<T> {
155    ok_vec: Vec<T>,
156    err: Error,
157    cur: usize
158}
159
160impl<T> Iterator for Okokerr<T> 
161where
162T: Clone + 'static
163{
164    type Item = Result<T, Error>;
165
166    fn next(&mut self) -> Option<Self::Item> {
167        if self.cur >= self.ok_vec.len() {
168            return Some(Err(error::any_error(self.err.kind(), self.err.message().unwrap().clone())));
169        } else {
170            let ret = self.ok_vec.get(self.cur).unwrap().clone();
171            self.cur += 1;
172            return Some(Ok(ret));
173        }
174    }
175}
176
177pub fn generate_okokerr_iterator<T>(ok_vec: Vec<T>, err: Error) -> Box<dyn Iterator<Item = Result<T, Error>>> 
178where
179T: Clone + 'static
180{
181    return Box::new(Okokerr {
182        ok_vec,
183        err,
184        cur: 0
185    });
186}
187
188pub fn vecdeque_2_vec<T>(vd: &mut VecDeque<T>) -> Vec<T> {
189    let mut ret = Vec::<T>::new();
190    while vd.len() > 0 {
191        ret.push(vd.pop_front().unwrap());
192    }
193    return ret;
194}
195
196#[cfg(test)]
197mod tests {
198    use super::*;
199    use crate::error;
200
201    #[test]
202    fn test1() {
203        let v = vec![Ok(4),Ok(3),Ok(3)];
204        let a = extract_value_from_result_vec(v);
205        assert!(a.1.is_none());
206        assert_eq!(vec![4,3,3], a.0);
207
208        let v = vec![Ok(4),Err(error::any_error(error::Kind::OverflowError, "Overflow".to_string())),Ok(3)];
209        let a = extract_value_from_result_vec(v);
210        assert!(a.1.is_some());
211        assert_eq!(vec![4], a.0);
212    }
213
214    #[test]
215    fn test2() {
216        let v = vec!['a', 'b', 'c'];
217        assert_eq!(join_string_vec(&v), "abc".to_string());
218    }
219
220    #[test]
221    fn test_any() {
222        let v = vec![true,true];
223        assert_eq!(true, any(&v));
224
225        let v = vec![true,false];
226        assert_eq!(true, any(&v));
227
228        let v: Vec<bool> = vec![false,false];
229        assert_eq!(false, any(&v));
230
231    }
232
233    #[test]
234    fn test_are_same() {
235        assert!(are_same(None::<&i32>, None));
236        assert!(!are_same(None, Some(&1)));
237        assert!(!are_same(Some(&1), None));
238        assert!(are_same(Some(&1), Some(&1)));
239        assert!(!are_same(Some(&2), Some(&1)));
240    }
241
242    #[test]
243    fn test_argsort() {
244        let v = [3,1,2,4];
245        let ret = argsort(v.as_slice());
246        assert_eq!(vec![1usize,2usize,0usize,3usize], ret);
247    }
248
249    #[test]
250    fn test_counter() {
251        let v = vec![5,1,2,2,3,3,3,4,4,4,4,5,5,5,5];
252        let mut hm = HashMap::new();
253        let _ = counter(&mut hm, generate_okok_iterator(v));
254        assert_eq!(&1, hm.get(&1).unwrap());
255        assert_eq!(&2, hm.get(&2).unwrap());
256        assert_eq!(&3, hm.get(&3).unwrap());
257        assert_eq!(&4, hm.get(&4).unwrap());
258        assert_eq!(&5, hm.get(&5).unwrap());
259    }
260
261    #[test]
262    fn test_vecdeque_2_vec() {
263        let mut vd = VecDeque::new();
264        vd.push_back(1i32);
265        vd.push_back(2i32);
266        vd.push_back(3i32);
267
268        assert_eq!(vec![1,2,3], vecdeque_2_vec(&mut vd));
269    }
270}
more_itertools/utils.rs

more_itertools/
utils.rs
