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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
pub use iter_extras_impl::*;
#[cfg(not(nightly))]
mod iter_extras_impl {
use crate::serialisation::{SerError, TryClone};
/// Additional iterator functions
pub trait IterExtras: Iterator + Sized {
/// Iterate over each item in the iterator and apply a function to it and a clone of the given value `t`
///
/// Behaves like `iterator.for_each(|item| f(item, t.clone()))`, except that it avoids cloning
/// in the case where the iterator contains a single item or for the last item in a larger iterator.
///
/// Use this when cloning `T` is relatively expensive compared to `f`.
fn for_each_with<T, F>(mut self, t: T, mut f: F)
where
T: Clone,
F: FnMut(Self::Item, T),
{
let mut current: Option<Self::Item> = self.next();
let mut next: Option<Self::Item> = self.next();
while next.is_some() {
let item = current.take().unwrap();
f(item, t.clone());
current = next;
next = self.next();
}
if let Some(item) = current.take() {
f(item, t)
}
}
/// Iterate over each item in the iterator and apply a function to it and a clone of the given value `t`
/// if such a clone can be created
///
/// Behaves like `iterator.for_each(|item| f(item, t.try_clone()))`, except that it avoids cloning
/// in the case where the iterator contains a single item or for the last item in a larger iterator.
/// It also shortcircuits on cloning errors.
///
/// Use this when trying to clone `T` is relatively expensive compared to `f`.
fn for_each_try_with<T, F>(mut self, t: T, mut f: F) -> Result<(), SerError>
where
T: TryClone,
F: FnMut(Self::Item, T),
{
let mut current: Option<Self::Item> = self.next();
let mut next: Option<Self::Item> = self.next();
while next.is_some() {
let item = current.take().unwrap();
let cloned = t.try_clone()?;
f(item, cloned);
current = next;
next = self.next();
}
if let Some(item) = current.take() {
f(item, t)
}
Ok(())
}
}
impl<T: Sized> IterExtras for T where T: Iterator {}
}
// this variant requires #![feature(unsized_locals)]
#[cfg(nightly)]
mod iter_extras_impl {
use crate::serialisation::{SerError, TryClone};
/// Additional iterator functions
pub trait IterExtras: Iterator {
/// Iterate over each item in the iterator and apply a function to it and a clone of the given value `t`
///
/// Behaves like `iterator.for_each(|item| f(item, t.clone()))`, except that it avoids cloning
/// in the case where the iterator contains a single item or for the last item in a larger iterator.
///
/// Use this when cloning `T` is relatively expensive compared to `f`.
fn for_each_with<T, F>(mut self, t: T, mut f: F)
where
T: Clone,
F: FnMut(Self::Item, T),
{
let mut current: Option<Self::Item> = self.next();
let mut next: Option<Self::Item> = self.next();
while next.is_some() {
let item = current.take().unwrap();
f(item, t.clone());
current = next;
next = self.next();
}
if let Some(item) = current.take() {
f(item, t)
}
}
/// Iterate over each item in the iterator and apply a function to it and a clone of the given value `t`
/// if such a clone can be created
///
/// Behaves like `iterator.for_each(|item| f(item, t.try_clone()))`, except that it avoids cloning
/// in the case where the iterator contains a single item or for the last item in a larger iterator.
/// It also shortcircuits on cloning errors.
///
/// Use this when trying to clone `T` is relatively expensive compared to `f`.
fn for_each_try_with<T, F>(mut self, t: T, mut f: F) -> Result<(), SerError>
where
T: TryClone,
F: FnMut(Self::Item, T),
{
let mut current: Option<Self::Item> = self.next();
let mut next: Option<Self::Item> = self.next();
while next.is_some() {
let item = current.take().unwrap();
let cloned = t.try_clone()?;
f(item, cloned);
current = next;
next = self.next();
}
if let Some(item) = current.take() {
f(item, t)
}
Ok(())
}
}
impl<T: ?Sized> IterExtras for T where T: Iterator {}
}