lamellar 0.8.1

Lamellar is an asynchronous tasking runtime for HPC systems developed in RUST.
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
102
103
104
105
106
107
108
109
110
111
112

use crate::array::iterator::{local_iterator::*, IterLockFuture};

/// `Map` is an iterator that applies a function to each element of the input iterator,
/// transforming it into a new type.
#[derive(Clone, Debug)]
pub struct Map<I, F> {
    iter: I,
    f: F,
}

impl<I: InnerIter, F: Clone> InnerIter for Map<I, F> {
    fn lock_if_needed(&self, _s: Sealed) -> Option<IterLockFuture> {
        None
    }
    fn iter_clone(&self, _s: Sealed) -> Self {
        Map {
            iter: self.iter.iter_clone(Sealed),
            f: self.f.clone(),
        }
    }
}

impl<I, F> Map<I, F>
where
    I: LocalIterator,
{
    pub(crate) fn new(iter: I, f: F) -> Map<I, F> {
        Map { iter, f }
    }
}

impl<B, I, F> LocalIterator for Map<I, F>
where
    I: LocalIterator,
    F: FnMut(I::Item) -> B + SyncSend + Clone + 'static,
    B: Send,
{
    type Item = B;
    type Array = <I as LocalIterator>::Array;
    fn init(&self, start_i: usize, cnt: usize, _s: Sealed) -> Map<I, F> {
        Map::new(self.iter.init(start_i, cnt, _s), self.f.clone())
    }
    fn array(&self) -> Self::Array {
        self.iter.array()
    }
    fn next(&mut self) -> Option<Self::Item> {
        self.iter.next().map(&mut self.f)
    }

    fn elems(&self, in_elems: usize) -> usize {
        let in_elems = self.iter.elems(in_elems);
        in_elems
    }

    fn advance_index(&mut self, count: usize) {
        self.iter.advance_index(count);
    }
}

// #[derive(Clone, Debug)]
// pub struct MapIndexed<I, F> {
//     iter: I,
//     f: F,
// }
// impl<I, F> MapIndexed<I, F>
// where
//     I: IndexedLocalIterator,
// {
//     pub(crate) fn new(iter: I, f: F) -> MapIndexed<I, F> {
//         MapIndexed { iter, f }
//     }
// }

// impl<B, I, F> LocalIterator for MapIndexed<I, F>
// where
//     I: IndexedLocalIterator,
//     F: FnMut(I::Item) -> B + SyncSend + Clone + 'static,
//     B: Send,
// {
//     type Item = B;
//     type Array = I::Array;
//     fn init(&self, start_i: usize, cnt: usize, _s: Sealed) -> MapIndexed<I, F> {
//         MapIndexed::new(self.iter.init(start_i, cnt,_s), self.f.clone())
//     }
//     fn array(&self) -> Self::Array {
//         self.iter.array()
//     }
//     fn next(&mut self) -> Option<Self::Item> {
//         self.iter.next().map(&mut self.f)
//     }

//     fn elems(&self, in_elems: usize) -> usize {
//         let in_elems = self.iter.elems(in_elems);
//         in_elems
//     }

//     fn advance_index(&mut self, count: usize) {
//         self.iter.advance_index(count);
//     }
// }

// impl<B, I, F> IndexedLocalIterator for MapIndexed<I, F>
// where
//     I: IndexedLocalIterator,
//     F: FnMut(I::Item) -> B + SyncSend + Clone + 'static,
//     B: Send,
// {
//     fn iterator_index(&self, index: usize) -> Option<usize> {
//         let i_index = self.iter.iterator_index(index);
//         i_index
//     }
// }