more_itertools/grouping/
divide.rs

1use std::rc::Rc;
2
3use crate::error;
4use crate::error::Error;
5use crate::itertools::accumulate::accumulate;
6use crate::sequence::Sequence;
7use crate::utils::extract_value_from_result_vec;
8
9
10#[allow(dead_code)]
11pub(crate) struct DivideInner<T> {
12    buf: Box<dyn Sequence<T>>,
13    pub(crate) n: usize,
14    len_vec: Vec<usize>,
15    accumulate_overflow: bool
16}
17
18pub struct Divide<T> {
19    pub(crate) inner: Rc<DivideInner<T>>
20}
21
22impl<T> Divide<T> 
23where
24T: Clone + 'static
25{
26    pub fn new(buf: Box<dyn Sequence<T>>, bucket_count: usize) -> Divide<T> {
27        let mut _len_vec = Vec::new();
28        let base = buf.len() / bucket_count;
29        let _mod = buf.len() % bucket_count;
30
31        for _ in 0..bucket_count {
32            _len_vec.push(base);
33        }
34        for i in 0.._mod {
35            _len_vec[i] = _len_vec[i] + 1;
36        }
37
38
39        let mut accumulate_overflow = false; 
40        let a = accumulate(_len_vec);
41        let mut _len_vec3 = extract_value_from_result_vec(a.collect::<Vec<_>>());
42        println!("{:?}", _len_vec3);
43        if _len_vec3.1.is_some() {
44            accumulate_overflow = true;
45        }
46
47        let mut _len_vec2 = Vec::new();
48        _len_vec2.push(0 as usize);
49        _len_vec2.append(&mut _len_vec3.0);
50
51
52        let inner = DivideInner {
53            buf: buf,
54            n: bucket_count,
55            len_vec: _len_vec2,
56            accumulate_overflow: accumulate_overflow
57        };
58
59        let ret = Divide {
60            inner: Rc::new(inner)
61        };
62
63        return ret;
64    }
65
66    pub fn iter_cnt(&self) -> usize {
67        return self.inner.n;
68    }
69
70    pub fn iter(&self, bucket_no: usize) -> Box<dyn Iterator<Item = Result<T, Error>>> {
71        assert!(bucket_no < self.inner.len_vec.len() - 1);
72        let start = self.inner.len_vec[bucket_no];
73        let end = self.inner.len_vec[bucket_no+1];
74
75        let ret: Box<dyn Iterator<Item = Result<T, Error>>> = Box::new(Cursor {
76            inner: Rc::clone(&self.inner),
77            cur: start,
78            end: end,
79            bucket_count: self.inner.n,
80            accumulate_overflow: self.inner.accumulate_overflow
81        });
82
83        return ret;
84    }
85}
86
87pub fn divide<T>(buf: Box<dyn Sequence<T>>, bucket_cnt: usize) -> Divide<T>
88where
89T: Clone + 'static
90{
91    return Divide::new(buf, bucket_cnt);
92}
93
94pub struct Cursor<T>
95{
96    inner: Rc<DivideInner<T>>,
97    cur: usize,
98    end: usize,
99    bucket_count: usize,
100    accumulate_overflow: bool
101}
102
103impl<T> Iterator for Cursor<T>
104where
105T: Clone
106{
107    type Item = Result<T, Error>;
108
109    fn next(&mut self) -> Option<Self::Item> {
110        if self.bucket_count == 0 {
111            return Some(Err(error::value_error("bucket count should not be 0".to_string())));
112        }
113
114        if self.accumulate_overflow {
115            return Some(Err(error::value_error("accumulate overflow".to_string())));
116        }
117
118        if self.cur >= self.end {
119            return None;
120        }
121
122        let real_ret: Option<Result<_, _>> = Some(Ok(self.inner.buf.get(self.cur).unwrap().clone()));
123
124        self.cur += 1;
125
126        return real_ret;
127    }
128}
129
130impl<T> Drop for Cursor<T> {
131    fn drop(&mut self) {
132        println!("Cursor, refcnt={}", Rc::strong_count(&self.inner));
133    }
134}
135impl<T> Drop for Divide<T> {
136    fn drop(&mut self) {
137        println!("Divide, refcnt={}", Rc::strong_count(&self.inner));
138    }
139}
140
141
142#[cfg(test)]
143mod tests {
144    use crate::sequence::create_seq_from_vec;
145
146    use super::*;
147
148    #[test]
149    fn test1() {
150        let v = vec![1,2,3,4,5,6,7,8,9,10];
151        let seq = create_seq_from_vec(v);
152        let div = divide(seq, 3);
153
154        let mut cur_0 = div.iter(0);
155        assert_eq!(1, cur_0.next().unwrap().ok().unwrap());
156        assert_eq!(2, cur_0.next().unwrap().ok().unwrap());
157        assert_eq!(3, cur_0.next().unwrap().ok().unwrap());
158        assert_eq!(4, cur_0.next().unwrap().ok().unwrap());
159        assert_eq!(None, cur_0.next());
160
161
162        let mut cur_1 = div.iter(1);
163        assert_eq!(5, cur_1.next().unwrap().ok().unwrap());
164        assert_eq!(6, cur_1.next().unwrap().ok().unwrap());
165        assert_eq!(7, cur_1.next().unwrap().ok().unwrap());
166        assert_eq!(None, cur_0.next());
167
168        let mut cur_2 = div.iter(2);
169        assert_eq!(8, cur_2.next().unwrap().ok().unwrap());
170        assert_eq!(9, cur_2.next().unwrap().ok().unwrap());
171        assert_eq!(10, cur_2.next().unwrap().ok().unwrap());
172        assert_eq!(None, cur_2.next());
173    }
174
175    #[test]
176    fn test2() {
177        let v = create_seq_from_vec(vec![1,2,3,4,5,6,7,8,9,10]);
178        let div = divide(v, 3);
179
180        let mut cur_0 = div.iter(0);
181        println!("{:?}", cur_0.next());
182    }
183}
more_itertools/grouping/divide.rs

more_itertools/grouping/
divide.rs
