Struct SymmetricHashJoin 

pub struct SymmetricHashJoin<Lhs, Rhs, LhsState, RhsState, LhsStateInner, RhsStateInner> { /* private fields */ }

Available on crate feature std only.

Pull combinator for symmetric hash join operations.

Joins two pulls on a common key, producing tuples of matched values. Items are processed as they arrive, with matches emitted immediately.

Trait Implementations

impl<Lhs: Clone, Rhs: Clone, LhsState: Clone, RhsState: Clone, LhsStateInner: Clone, RhsStateInner: Clone> Clone for SymmetricHashJoin<Lhs, Rhs, LhsState, RhsState, LhsStateInner, RhsStateInner>

fn clone( &self, ) -> SymmetricHashJoin<Lhs, Rhs, LhsState, RhsState, LhsStateInner, RhsStateInner>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Lhs: Debug, Rhs: Debug, LhsState: Debug, RhsState: Debug, LhsStateInner: Debug, RhsStateInner: Debug> Debug for SymmetricHashJoin<Lhs, Rhs, LhsState, RhsState, LhsStateInner, RhsStateInner>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<Lhs: Default, Rhs: Default, LhsState: Default, RhsState: Default, LhsStateInner: Default, RhsStateInner: Default> Default for SymmetricHashJoin<Lhs, Rhs, LhsState, RhsState, LhsStateInner, RhsStateInner>

fn default() -> SymmetricHashJoin<Lhs, Rhs, LhsState, RhsState, LhsStateInner, RhsStateInner>

Returns the “default value” for a type.

impl<Key, Lhs, V1, Rhs, V2, LhsState, RhsState, LhsStateInner, RhsStateInner> Pull for SymmetricHashJoin<Lhs, Rhs, LhsState, RhsState, LhsStateInner, RhsStateInner>

where Key: Eq + Hash + Clone, V1: Clone, V2: Clone, Lhs: FusedPull<Item = (Key, V1), Meta = ()>, Rhs: FusedPull<Item = (Key, V2), Meta = ()>, LhsState: BorrowMut<LhsStateInner>, RhsState: BorrowMut<RhsStateInner>, LhsStateInner: HalfJoinState<Key, V1, V2>, RhsStateInner: HalfJoinState<Key, V2, V1>,

type Ctx<'ctx> = <<Lhs as Pull>::Ctx<'ctx> as Context<'ctx>>::Merged<<Rhs as Pull>::Ctx<'ctx>>

The context type required to poll this pull.

type Item = (Key, (V1, V2))

The type of items yielded by this pull.

type Meta = ()

The metadata type associated with each item.

type CanPend = <<Lhs as Pull>::CanPend as Toggle>::Or<<Rhs as Pull>::CanPend>

Whether this pull can return PullStep::Pending.

type CanEnd = <<Lhs as Pull>::CanEnd as Toggle>::And<<Rhs as Pull>::CanEnd>

Whether this pull can return PullStep::Ended.

fn pull( self: Pin<&mut Self>, ctx: &mut Self::Ctx<'_>, ) -> PullStep<Self::Item, Self::Meta, Self::CanPend, Self::CanEnd>

Attempts to pull the next item from this stream.

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

Returns the bounds on the remaining length of the pull.

fn by_ref(&mut self) -> &mut Self

Borrows this pull, allowing it to be used by reference.

fn enumerate(self) -> Enumerate<Self>

where Self: Sized,

Creates a pull which gives the current iteration count as well as the next value.

fn filter<P>(self, predicate: P) -> Filter<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates a pull which uses a closure to determine if an element should be yielded.

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>

where Self: Sized, F: FnMut(Self::Item) -> Option<B>,

Creates a pull that both filters and maps.

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, F, U::IntoIter, Self::Meta>

where Self: Sized, F: FnMut(Self::Item) -> U, U: IntoIterator,

Creates a pull that works like map, but flattens nested structure.

fn flatten( self, ) -> Flatten<Self, <Self::Item as IntoIterator>::IntoIter, Self::Meta>

where Self: Sized, Self::Item: IntoIterator,

Creates a pull that flattens nested structure.

fn flatten_stream(self) -> FlattenStream<Self, Self::Item, Self::Meta>

where Self: Sized, Self::Item: Stream,

Creates a pull that flattens items that are streams by polling each inner stream.

fn for_each<F>(self, f: F) -> ForEach<Self, F>

where Self: Sized, F: FnMut(Self::Item),

Creates a future which runs the given function on each element of a pull.

fn collect<C>(self) -> Collect<Self, C>

where Self: Sized, C: Default + Extend<Self::Item>,

Creates a future which collects all elements of a pull into a collection.

fn fuse( self, ) -> impl for<'ctx> FusedPull<Ctx<'ctx> = Self::Ctx<'ctx>, Item = Self::Item, Meta = Self::Meta, CanPend = Self::CanPend, CanEnd = Self::CanEnd>

where Self: Sized,

Creates a pull that ends after the first None.

fn inspect<F>(self, f: F) -> Inspect<Self, F>

where Self: Sized, F: FnMut(&Self::Item),

Does something with each element of a pull, passing the value on.

fn map<B, F>(self, f: F) -> Map<Self, F>

where Self: Sized, F: FnMut(Self::Item) -> B,

Takes a closure and creates a pull that calls that closure on each element.

fn send_sink<Push>(self, push: Push) -> SendSink<Self, Push>

where Self: Sized, Push: Sink<Self::Item>,

Creates a future that pulls all items and sends them into a crate::Sink.

fn send_push<Psh>(self, push: Psh) -> SendPush<Self, Psh>

where Self: Sized, Psh: Push<Self::Item, Self::Meta>,

Creates a future that pulls all items and pushes them into a crate::push::Push.

fn skip(self, n: usize) -> Skip<Self>

where Self: Sized,

Creates a pull that skips the first n elements.

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates a pull that skips elements based on a predicate.

fn take(self, n: usize) -> Take<Self>

where Self: Sized,

Creates a pull that yields the first n elements, or fewer if the underlying pull ends sooner.

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates a pull that yields elements based on a predicate.

fn zip<U>(self, other: U) -> Zip<Self, U>

where Self: Sized, U: Pull<Meta = Self::Meta>,

Zips two pulls together, stopping once either is exhausted.

fn next(self) -> Next<Self>

where Self: Sized,

Creates a future that resolves with the next item from this pull.

fn cross_singleton<SinglePull>( self, singleton_pull: SinglePull, ) -> CrossSingleton<Self, SinglePull, Option<SinglePull::Item>>

where Self: Sized, SinglePull: Pull, SinglePull::Item: Clone,

Crosses each item from this pull with a singleton value from another pull.

fn cross_singleton_state<SinglePull>( self, singleton_pull: SinglePull, singleton_state: &mut Option<SinglePull::Item>, ) -> CrossSingleton<Self, SinglePull, &mut Option<SinglePull::Item>>

where Self: Sized, SinglePull: Pull, SinglePull::Item: Clone,

Self::cross_singleton with external state.

impl<'__pin, Lhs, Rhs, LhsState, RhsState, LhsStateInner, RhsStateInner> Unpin for SymmetricHashJoin<Lhs, Rhs, LhsState, RhsState, LhsStateInner, RhsStateInner>

where PinnedFieldsOf<__Origin<'__pin, Lhs, Rhs, LhsState, RhsState, LhsStateInner, RhsStateInner>>: Unpin,