kompact 0.12.0

Kompact is a Rust implementation of the Kompics component model combined with the Actor model.
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

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 {}