orx_parallel/computations/generalized_values/
values.rs

1use orx_concurrent_bag::ConcurrentBag;
2use orx_concurrent_ordered_bag::ConcurrentOrderedBag;
3use orx_pinned_vec::{IntoConcurrentPinnedVec, PinnedVec};
4
5pub trait Values: Send + Sync {
6    type Item;
7
8    type Mapped<M, O>: Values<Item = O>
9    where
10        O: Send + Sync,
11        M: Fn(Self::Item) -> O + Send + Sync;
12
13    type Filtered<F>: Values<Item = Self::Item>
14    where
15        F: Fn(&Self::Item) -> bool + Send + Sync;
16
17    type FlatMapped<Fm, Vo>: Values<Item = Vo::Item>
18    where
19        Vo: IntoIterator + Send + Sync,
20        Vo::Item: Send + Sync,
21        Vo::IntoIter: Send + Sync,
22        Fm: Fn(Self::Item) -> Vo + Send + Sync;
23
24    type FilterMapped<Fm, O>: Values<Item = O>
25    where
26        O: Send + Sync,
27        Fm: Fn(Self::Item) -> Option<O> + Send + Sync;
28
29    fn values(self) -> impl IntoIterator<Item = Self::Item>;
30
31    fn push_to_pinned_vec<P>(self, vector: &mut P)
32    where
33        P: PinnedVec<Self::Item>;
34
35    fn push_to_bag<P>(self, bag: &ConcurrentBag<Self::Item, P>)
36    where
37        P: IntoConcurrentPinnedVec<Self::Item>,
38        Self::Item: Send + Sync;
39
40    fn push_to_ordered_bag<P>(self, idx: usize, o_bag: &ConcurrentOrderedBag<Self::Item, P>)
41    where
42        P: IntoConcurrentPinnedVec<Self::Item>,
43        Self::Item: Send + Sync;
44
45    fn push_to_vec_with_idx(self, idx: usize, vec: &mut Vec<(usize, Self::Item)>);
46
47    fn map<M, O>(self, map: M) -> Self::Mapped<M, O>
48    where
49        O: Send + Sync,
50        M: Fn(Self::Item) -> O + Send + Sync;
51
52    fn flat_map<Fm, Vo>(self, flat_map: Fm) -> Self::FlatMapped<Fm, Vo>
53    where
54        Vo: IntoIterator + Send + Sync,
55        Vo::Item: Send + Sync,
56        Vo::IntoIter: Send + Sync,
57        Fm: Fn(Self::Item) -> Vo + Send + Sync;
58
59    fn filter_map<Fm, O>(self, filter_map: Fm) -> Self::FilterMapped<Fm, O>
60    where
61        O: Send + Sync,
62        Fm: Fn(Self::Item) -> Option<O> + Send + Sync;
63
64    fn filter<F>(self, filter: F) -> Self::Filtered<F>
65    where
66        F: Fn(&Self::Item) -> bool + Send + Sync;
67
68    fn acc_reduce<X>(self, acc: Option<Self::Item>, reduce: X) -> Option<Self::Item>
69    where
70        X: Fn(Self::Item, Self::Item) -> Self::Item + Send + Sync;
71
72    fn fx_reduce<F, M2, Vo, X>(
73        self,
74        acc: Option<Vo::Item>,
75        filter: F,
76        map2: M2,
77        reduce: X,
78    ) -> Option<Vo::Item>
79    where
80        Self: Sized,
81        F: Fn(&Self::Item) -> bool + Send + Sync,
82        M2: Fn(Self::Item) -> Vo + Send + Sync,
83        Vo: Values,
84        Vo::Item: Send + Sync,
85        X: Fn(Vo::Item, Vo::Item) -> Vo::Item + Send + Sync;
86
87    fn first(self) -> Option<Self::Item>;
88
89    fn fx_next<F, M2, Vo>(self, filter: F, map2: M2) -> Option<Vo::Item>
90    where
91        F: Fn(&Self::Item) -> bool + Send + Sync,
92        M2: Fn(Self::Item) -> Vo + Send + Sync,
93        Vo: Values,
94        Vo::Item: Send + Sync;
95
96    fn filter_map_collect_sequential<F, M2, P, Vo>(self, filter: F, map2: M2, vector: &mut P)
97    where
98        F: Fn(&Self::Item) -> bool + Send + Sync,
99        M2: Fn(Self::Item) -> Vo + Send + Sync,
100        Vo: Values,
101        P: IntoConcurrentPinnedVec<Vo::Item>;
102
103    fn filter_map_collect_arbitrary<F, M2, P, Vo>(
104        self,
105        filter: F,
106        map2: M2,
107        bag: &ConcurrentBag<Vo::Item, P>,
108    ) where
109        F: Fn(&Self::Item) -> bool + Send + Sync,
110        M2: Fn(Self::Item) -> Vo + Send + Sync,
111        Vo: Values,
112        Vo::Item: Send + Sync,
113        P: IntoConcurrentPinnedVec<Vo::Item>;
114
115    fn xfx_collect_heap<F, M2, Vo>(
116        self,
117        input_idx: usize,
118        filter: F,
119        map2: M2,
120        vec: &mut Vec<(usize, Vo::Item)>,
121    ) where
122        F: Fn(&Self::Item) -> bool + Send + Sync,
123        M2: Fn(Self::Item) -> Vo + Send + Sync,
124        Vo: Values,
125        Vo::Item: Send + Sync;
126
127    fn filter_map_collect_in_input_order<F, M2, P, Vo>(
128        self,
129        input_idx: usize,
130        filter: F,
131        map2: M2,
132        o_bag: &ConcurrentOrderedBag<Vo::Item, P>,
133    ) where
134        F: Fn(&Self::Item) -> bool + Send + Sync,
135        M2: Fn(Self::Item) -> Vo + Send + Sync,
136        Vo: Values,
137        Vo::Item: Send + Sync,
138        P: IntoConcurrentPinnedVec<Vo::Item>;
139}
orx_parallel/computations/generalized_values/values.rs

orx_parallel/computations/generalized_values/
values.rs
