iterator-cache 0.1.0

Evaluate and cache iterator values now for future use
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

#[cfg(test)]
mod tests {

use crate::*;
	#[test]
	fn queue_some() {
		let mut iter = vec![1,2,3,4,5].into_iter().cache(3).unwrap();
		assert_eq!(iter.next(), Some(1));
		assert_eq!(iter.next(), Some(2));
		assert_eq!(iter.next(), Some(3));
		assert_eq!(iter.next(), Some(4));
		assert_eq!(iter.next(), Some(5));
		assert_eq!(iter.next(), None);
	}
	#[test]
	#[should_panic]
	fn queue_too_many() {
		let mut iter = vec![1,2,3,4,5].into_iter().cache(6).unwrap();
	}
	#[test]
	fn queue_all() {
		let mut iter = vec![1,2,3,4,5].into_iter().cache_all();
		assert_eq!(iter.next(), Some(1));
		assert_eq!(iter.next(), Some(2));
		assert_eq!(iter.next(), Some(3));
		assert_eq!(iter.next(), Some(4));
		assert_eq!(iter.next(), Some(5));
		assert_eq!(iter.next(), None);
	}
	#[test]
	fn queue_overshoot_ok() {
		let mut iter = vec![1,2,3,4,5].into_iter().cache_or_all(500);
		assert_eq!(iter.next(), Some(1));
		assert_eq!(iter.next(), Some(2));
		assert_eq!(iter.next(), Some(3));
		assert_eq!(iter.next(), Some(4));
		assert_eq!(iter.next(), Some(5));
		assert_eq!(iter.next(), None);
	}
	#[test]
	fn iterator_methods() {
		let mut iter = vec![1,2,3,4,5].into_iter()
			.map(|i| i*2)
			.cache_all();
		assert_eq!(iter.next(), Some(2));
		assert_eq!(iter.next(), Some(4));
		assert_eq!(iter.next(), Some(6));
		assert_eq!(iter.next(), Some(8));
		assert_eq!(iter.next(), Some(10));
		assert_eq!(iter.next(), None);
	}
	#[test]
	fn lasy_eval() {
		static mut COUNTER: i32 = 0;
		let mut iter = vec![1,2,3,4,5].into_iter()
			.map(|i| {
				unsafe { // unsafe for threading reasons, probably ok
					COUNTER += 1;
				}
				i*2
			});
		unsafe {
			assert_eq!(COUNTER,0);
		}
		let mut iter = iter.cache(2).unwrap();
		unsafe {
			assert_eq!(COUNTER,2);
		}
		iter.cache_more(2);
		unsafe {
			assert_eq!(COUNTER,4);
			COUNTER = 0;
		}
		let mut iter = vec![1,2,3,4,5].into_iter()
			.map(|i| {
				unsafe { // unsafe for threading reasons, probably ok
					COUNTER += 1;
				}
				i*2
			})
			.cache_all();
		unsafe {
			assert_eq!(COUNTER,5);
		}
		
	}
	#[test]
	fn return_errors() {
		let err = (0..5).cache(40);
		match err {
			Ok(_) => panic!(),
			Err(_) => (),
		}
	}
	#[test]
	fn from_doc_test() {
		let mut cache = (0..5).cache_or_all(2); // Caches 2 values
     	cache.cache_more(2).unwrap(); // Caches 2 more values for a total of 4
    	cache.for_each(|i| println!("{}",i)); // Exhausts the 4 values in the cache, then prints the last item directly out of the iterator
	}
}