DistParStream

amadeus_core::util

Struct DistParStream 

Source 
pub struct DistParStream<S>(/* private fields */);

Implementations§

Source§

impl<S> DistParStream<S>

Source

pub fn new(f0: S) -> Self

Constructs a new DistParStream.

Trait Implementations§

Source§

impl<S> ParallelStream for DistParStream<S>
where S: DistributedStream,

Source§

type Item = <S as DistributedStream>::Item

Source§

type Task = <S as DistributedStream>::Task

Source§

fn size_hint(&self) -> (usize, Option<usize>)

Source§

fn next_task( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Option<Self::Task>>

Source§

fn reduce<'life0, 'async_trait, P, B, R1, R3>( self, pool: &'life0 P, reduce_a: R1, reduce_c: R3, ) -> Pin<Box<dyn Future<Output = B> + 'async_trait>>
where P: ThreadPool + 'async_trait, R1: ReducerSend<Self::Item> + Clone + Send + 'static + 'async_trait, R3: Reducer<<R1 as ReducerSend<Self::Item>>::Done, Done = B> + 'async_trait, Self::Task: 'static, Self: Sized + 'async_trait, B: 'async_trait, 'life0: 'async_trait,

Source§

fn pipe<'life0, 'async_trait, P, ParSink, A>( self, pool: &'life0 P, sink: ParSink, ) -> Pin<Box<dyn Future<Output = A> + 'async_trait>>
where P: ThreadPool + 'async_trait, ParSink: ParallelSink<Self::Item, Done = A> + 'async_trait, <ParSink::Pipe as ParallelPipe<Self::Item>>::Task: 'static, ParSink::ReduceA: 'static, Self::Task: 'static, Self: Sized + 'async_trait, A: 'async_trait, 'life0: 'async_trait,

Source§

fn fork<'life0, 'async_trait, P, ParSinkA, ParSinkB, A, B>( self, pool: &'life0 P, sink_a: ParSinkA, sink_b: ParSinkB, ) -> Pin<Box<dyn Future<Output = (A, B)> + 'async_trait>>
where P: ThreadPool + 'async_trait, ParSinkA: ParallelSink<Self::Item, Done = A> + 'async_trait, ParSinkB: for<'a> ParallelSink<&'a Self::Item, Done = B> + 'static + 'async_trait, <ParSinkA::Pipe as ParallelPipe<Self::Item>>::Task: 'static, ParSinkA::ReduceA: 'static, <ParSinkB as ParallelSink<&'static Self::Item>>::ReduceA: 'static, <<ParSinkB as ParallelSink<&'static Self::Item>>::Pipe as ParallelPipe<&'static Self::Item>>::Task: 'static, Self::Item: 'static, Self::Task: 'static, Self: Sized + 'async_trait, A: 'async_trait, B: 'async_trait, 'life0: 'async_trait,

Source§

fn group_by<'life0, 'async_trait, P, S, A, B>( self, pool: &'life0 P, sink: S, ) -> Pin<Box<dyn Future<Output = IndexMap<A, S::Done>> + 'async_trait>>
where P: ThreadPool + 'async_trait, A: Eq + Hash + Send + 'static + 'async_trait, B: 'static + 'async_trait, S: ParallelSink<B> + 'async_trait, <S::Pipe as ParallelPipe<B>>::Task: Clone + Send + 'static, S::ReduceA: 'static, S::ReduceC: Clone, S::Done: Send + 'static, Self::Task: 'static, Self: ParallelStream<Item = (A, B)> + Sized + 'async_trait, 'life0: 'async_trait,

Source§

fn collect<'life0, 'async_trait, P, B>( self, pool: &'life0 P, ) -> Pin<Box<dyn Future<Output = B> + 'async_trait>>
where P: ThreadPool + 'async_trait, B: FromParallelStream<Self::Item> + 'async_trait, B::ReduceA: Send + 'static, Self::Task: 'static, Self: Sized + 'async_trait, 'life0: 'async_trait,

Source§

fn inspect<F>(self, f: F) -> Inspect<Self, F>
where F: FnMut(&Self::Item) + Clone + Send + 'static, Self: Sized,

Source§

fn update<F>(self, f: F) -> Update<Self, F>
where F: FnMut(&mut Self::Item) + Clone + Send + 'static, Self: Sized,

Source§

fn map<B, F>(self, f: F) -> Map<Self, F>
where F: FnMut(Self::Item) -> B + Clone + Send + 'static, Self: Sized,

Source§

fn flat_map<B, F>(self, f: F) -> FlatMap<Self, F>
where F: FnMut(Self::Item) -> B + Clone + Send + 'static, B: Stream, Self: Sized,

Source§

fn filter<F>(self, f: F) -> Filter<Self, F>
where F: FnMut(&Self::Item) -> bool + Clone + Send + 'static, Self: Sized,

Source§

fn left_join<K, V1, V2>( self, right: impl IntoIterator<Item = (K, V2)>, ) -> LeftJoin<Self, K, V1, V2>
where K: Eq + Hash + Clone + Send + 'static, V1: 'static, V2: Clone + Send + 'static, Self: ParallelStream<Item = (K, V1)> + Sized,

Source§

fn inner_join<K, V1, V2>( self, right: impl IntoIterator<Item = (K, V2)>, ) -> InnerJoin<Self, K, V1, V2>
where K: Eq + Hash + Clone + Send + 'static, V1: 'static, V2: Clone + Send + 'static, Self: ParallelStream<Item = (K, V1)> + Sized,

Source§

fn chain<C>(self, chain: C) -> Chain<Self, C::ParStream>
where C: IntoParallelStream<Item = Self::Item>, Self: Sized,

Source§

fn for_each<'life0, 'async_trait, P, F>( self, pool: &'life0 P, f: F, ) -> Pin<Box<dyn Future<Output = ()> + 'async_trait>>
where P: ThreadPool + 'async_trait, F: FnMut(Self::Item) + Clone + Send + 'static + 'async_trait, Self::Item: 'static, Self::Task: 'static, Self: Sized + 'async_trait, 'life0: 'async_trait,

Source§

fn fold<'life0, 'async_trait, P, ID, F, B>( self, pool: &'life0 P, identity: ID, op: F, ) -> Pin<Box<dyn Future<Output = B> + 'async_trait>>
where P: ThreadPool + 'async_trait, ID: FnMut() -> B + Clone + Send + 'static + 'async_trait, F: FnMut(B, Either<Self::Item, B>) -> B + Clone + Send + 'static + 'async_trait, B: Send + 'static + 'async_trait, Self::Item: 'static, Self::Task: 'static, Self: Sized + 'async_trait, 'life0: 'async_trait,

Source§

fn histogram<'life0, 'async_trait, P>( self, pool: &'life0 P, ) -> Pin<Box<dyn Future<Output = Vec<(Self::Item, usize)>> + 'async_trait>>
where P: ThreadPool + 'async_trait, Self::Item: Hash + Ord + Send + 'static, Self::Task: 'static, Self: Sized + 'async_trait, 'life0: 'async_trait,

Source§

fn sort_n_by<'life0, 'async_trait, P, F>( self, pool: &'life0 P, n: usize, cmp: F, ) -> Pin<Box<dyn Future<Output = Sort<Self::Item, F>> + 'async_trait>>
where P: ThreadPool + 'async_trait, F: Fn(&Self::Item, &Self::Item) -> Ordering + Clone + Send + 'static + 'async_trait, Self::Item: Clone + Send + 'static, Self::Task: 'static, Self: Sized + 'async_trait, 'life0: 'async_trait,

Source§

fn count<'life0, 'async_trait, P>( self, pool: &'life0 P, ) -> Pin<Box<dyn Future<Output = usize> + 'async_trait>>
where P: ThreadPool + 'async_trait, Self::Item: 'static, Self::Task: 'static, Self: Sized + 'async_trait, 'life0: 'async_trait,

Source§

fn sum<'life0, 'async_trait, P, S>( self, pool: &'life0 P, ) -> Pin<Box<dyn Future<Output = S> + 'async_trait>>
where P: ThreadPool + 'async_trait, S: Sum<Self::Item> + Sum<S> + Send + 'static + 'async_trait, Self::Item: 'static, Self::Task: 'static, Self: Sized + 'async_trait, 'life0: 'async_trait,

Source§

fn mean<'life0, 'async_trait, P>( self, pool: &'life0 P, ) -> Pin<Box<dyn Future<Output = f64> + 'async_trait>>
where P: ThreadPool + 'async_trait, Self::Item: 'static, Self::Task: 'static, Self: ParallelStream<Item = f64> + Sized + 'async_trait, 'life0: 'async_trait,

Source§

fn stddev<'life0, 'async_trait, P>( self, pool: &'life0 P, ) -> Pin<Box<dyn Future<Output = f64> + 'async_trait>>
where P: ThreadPool + 'async_trait, Self::Item: 'static, Self::Task: 'static, Self: ParallelStream<Item = f64> + Sized + 'async_trait, 'life0: 'async_trait,

Source§

fn combine<'life0, 'async_trait, P, F>( self, pool: &'life0 P, f: F, ) -> Pin<Box<dyn Future<Output = Option<Self::Item>> + 'async_trait>>
where P: ThreadPool + 'async_trait, F: FnMut(Self::Item, Self::Item) -> Self::Item + Clone + Send + 'static + 'async_trait, Self::Item: Send + 'static, Self::Task: 'static, Self: Sized + 'async_trait, 'life0: 'async_trait,

Source§

fn max<'life0, 'async_trait, P>( self, pool: &'life0 P, ) -> Pin<Box<dyn Future<Output = Option<Self::Item>> + 'async_trait>>
where P: ThreadPool + 'async_trait, Self::Item: Ord + Send + 'static, Self::Task: 'static, Self: Sized + 'async_trait, 'life0: 'async_trait,

Source§

fn max_by<'life0, 'async_trait, P, F>( self, pool: &'life0 P, f: F, ) -> Pin<Box<dyn Future<Output = Option<Self::Item>> + 'async_trait>>
where P: ThreadPool + 'async_trait, F: FnMut(&Self::Item, &Self::Item) -> Ordering + Clone + Send + 'static + 'async_trait, Self::Item: Send + 'static, Self::Task: 'static, Self: Sized + 'async_trait, 'life0: 'async_trait,

Source§

fn max_by_key<'life0, 'async_trait, P, F, B>( self, pool: &'life0 P, f: F, ) -> Pin<Box<dyn Future<Output = Option<Self::Item>> + 'async_trait>>
where P: ThreadPool + 'async_trait, F: FnMut(&Self::Item) -> B + Clone + Send + 'static + 'async_trait, B: Ord + 'static + 'async_trait, Self::Item: Send + 'static, Self::Task: 'static, Self: Sized + 'async_trait, 'life0: 'async_trait,

Source§

fn min<'life0, 'async_trait, P>( self, pool: &'life0 P, ) -> Pin<Box<dyn Future<Output = Option<Self::Item>> + 'async_trait>>
where P: ThreadPool + 'async_trait, Self::Item: Ord + Send + 'static, Self::Task: 'static, Self: Sized + 'async_trait, 'life0: 'async_trait,

Source§

fn min_by<'life0, 'async_trait, P, F>( self, pool: &'life0 P, f: F, ) -> Pin<Box<dyn Future<Output = Option<Self::Item>> + 'async_trait>>
where P: ThreadPool + 'async_trait, F: FnMut(&Self::Item, &Self::Item) -> Ordering + Clone + Send + 'static + 'async_trait, Self::Item: Send + 'static, Self::Task: 'static, Self: Sized + 'async_trait, 'life0: 'async_trait,

Source§

fn min_by_key<'life0, 'async_trait, P, F, B>( self, pool: &'life0 P, f: F, ) -> Pin<Box<dyn Future<Output = Option<Self::Item>> + 'async_trait>>
where P: ThreadPool + 'async_trait, F: FnMut(&Self::Item) -> B + Clone + Send + 'static + 'async_trait, B: Ord + 'static + 'async_trait, Self::Item: Send + 'static, Self::Task: 'static, Self: Sized + 'async_trait, 'life0: 'async_trait,

Source§

fn most_frequent<'life0, 'async_trait, P>( self, pool: &'life0 P, n: usize, probability: f64, tolerance: f64, ) -> Pin<Box<dyn Future<Output = Top<Self::Item, usize>> + 'async_trait>>
where P: ThreadPool + 'async_trait, Self::Item: Hash + Eq + Clone + Send + 'static, Self::Task: 'static, Self: Sized + 'async_trait, 'life0: 'async_trait,

Source§

fn most_distinct<'life0, 'async_trait, P, A, B>( self, pool: &'life0 P, n: usize, probability: f64, tolerance: f64, error_rate: f64, ) -> Pin<Box<dyn Future<Output = Top<A, HyperLogLogMagnitude<B>>> + 'async_trait>>
where P: ThreadPool + 'async_trait, Self: ParallelStream<Item = (A, B)> + Sized + 'async_trait, A: Hash + Eq + Clone + Send + 'static + 'async_trait, B: Hash + 'static + 'async_trait, Self::Task: 'static, 'life0: 'async_trait,

Source§

fn sample_unstable<'life0, 'async_trait, P>( self, pool: &'life0 P, samples: usize, ) -> Pin<Box<dyn Future<Output = SampleUnstable<Self::Item>> + 'async_trait>>
where P: ThreadPool + 'async_trait, Self::Item: Send + 'static, Self::Task: 'static, Self: Sized + 'async_trait, 'life0: 'async_trait,

Source§

fn all<'life0, 'async_trait, P, F>( self, pool: &'life0 P, f: F, ) -> Pin<Box<dyn Future<Output = bool> + 'async_trait>>
where P: ThreadPool + 'async_trait, F: FnMut(Self::Item) -> bool + Clone + Send + 'static + 'async_trait, Self::Item: 'static, Self::Task: 'static, Self: Sized + 'async_trait, 'life0: 'async_trait,

Source§

fn any<'life0, 'async_trait, P, F>( self, pool: &'life0 P, f: F, ) -> Pin<Box<dyn Future<Output = bool> + 'async_trait>>
where P: ThreadPool + 'async_trait, F: FnMut(Self::Item) -> bool + Clone + Send + 'static + 'async_trait, Self::Item: 'static, Self::Task: 'static, Self: Sized + 'async_trait, 'life0: 'async_trait,

Source§

impl<'pin, S> Unpin for DistParStream<S>
where __DistParStream<'pin, S>: Unpin,

Source§

impl<S> UnsafeUnpin for DistParStream<S>

Auto Trait Implementations§

§

impl<S> Freeze for DistParStream<S>
where S: Freeze,

§

impl<S> RefUnwindSafe for DistParStream<S>
where S: RefUnwindSafe,

§

impl<S> Send for DistParStream<S>
where S: Send,

§

impl<S> Sync for DistParStream<S>
where S: Sync,

§

impl<S> UnwindSafe for DistParStream<S>
where S: UnwindSafe,

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

impl<T> IntoParallelStream for T
where T: ParallelStream,

Source§

type ParStream = T

Source§

type Item = <T as ParallelStream>::Item

Source§

fn into_par_stream(self) -> <T as IntoParallelStream>::ParStream

Source§

fn par_stream_mut(&mut self) -> <&mut Self as IntoParallelStream>::ParStream
where for<'a> &'a mut Self: IntoParallelStream,

Source§

fn par_stream(&self) -> <&Self as IntoParallelStream>::ParStream
where for<'a> &'a Self: IntoParallelStream,

Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

Source§

fn vzip(self) -> V