Skip to main content

JoinTarget

Trait JoinTarget 

Source
pub trait JoinTarget<S, A, E, F, Sc: Score> {
    type Output;

    // Required method
    fn apply(self, extractor_a: E, filter_a: F) -> Self::Output;
}
Expand description

Trait for single .join() dispatch.

E is the extractor type of the left stream. F is the filter type of the left stream. Implementors consume self and receive the left stream’s extractor and filter, producing the appropriate cross-stream type.

Required Associated Types§

Source

type Output

The resulting constraint stream type.

Required Methods§

Source

fn apply(self, extractor_a: E, filter_a: F) -> Self::Output

Applies the join, consuming both the target and the left stream’s components.

Dyn Compatibility§

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types§

Source§

impl<S, A, B, E, F, EB, FB, P, Sc> JoinTarget<S, A, E, F, Sc> for (UniConstraintStream<S, B, EB, FB, Sc>, P)
where S: Send + Sync + 'static, A: Send + Sync + 'static, B: Send + Sync + 'static, E: CollectionExtract<S, Item = A>, F: UniFilter<S, A>, EB: CollectionExtract<S, Item = B>, FB: UniFilter<S, B>, P: Fn(&A, &B) -> bool + Send + Sync + 'static, Sc: Score + 'static,

Predicate cross-join: .join((other_stream, |a, b| predicate)) — an explicit opposite-input scan under the exact predicate. The relationship compiles to FilteringJoiner, so no synthetic constant equality key is ever built for a non-indexable condition.

Source§

type Output = Bi<S, A, B, BiPredicatePlan<P>, E, EB, UniPairFilter<F, FB>, Sc>

Source§

fn apply(self, extractor_a: E, filter_a: F) -> Self::Output

Source§

impl<S, A, B, E, F, EB, J1, J2, Sc> JoinTarget<S, A, E, F, Sc> for (EB, AndJoiner<J1, J2>)
where S: Send + Sync + 'static, A: Send + Sync + 'static, B: Send + Sync + 'static, E: CollectionExtract<S, Item = A>, F: UniFilter<S, A>, EB: CollectionExtract<S, Item = B>, J1: ToViewPlan<A, B> + 'static, J2: ToViewPlan<A, B> + 'static, AndJoiner<J1::ViewPlan, J2::ViewPlan>: CompileCondition<Plan: IndexedPlan> + 'static, for<'a> <AndJoiner<J1::ViewPlan, J2::ViewPlan> as CompileCondition>::Plan: ExecutablePlan<Leaf<'a, A>, Leaf<'a, B>>, Sc: Score + 'static,

Composed conjunction: each operand converts to its view plan, then the two compose into one concrete AndJoiner plan. No dynamic condition list.

Source§

type Output = Bi<S, A, B, <AndJoiner<<J1 as ToViewPlan<A, B>>::ViewPlan, <J2 as ToViewPlan<A, B>>::ViewPlan> as CompileCondition>::Plan, E, EB, UniLeftBiFilter<F, B>, Sc>

Source§

fn apply(self, extractor_a: E, filter_a: F) -> Self::Output

Source§

impl<S, A, B, E, F, EB, K, KA, KB, Mode, Sc> JoinTarget<S, A, E, F, Sc> for (EB, EqualJoiner<KA, KB, K, Mode>)
where S: Send + Sync + 'static, A: Send + Sync + 'static, B: Send + Sync + 'static, E: CollectionExtract<S, Item = A>, F: UniFilter<S, A>, EB: CollectionExtract<S, Item = B>, K: Eq + Hash + Clone + Send + Sync, KA: Fn(&A) -> K + Send + Sync, KB: Fn(&B) -> K + Send + Sync, Sc: Score + 'static,

Keyed cross-join: .join((extractor_b, equal_bi(ka, kb))) — pairs two collections by key.

Source§

type Output = Bi<S, A, B, BiUnaryPlan<K, KA, KB>, FilteredExtract<E, F>, EB, TrueFilter, Sc>

Source§

fn apply(self, extractor_a: E, filter_a: F) -> Self::Output

Source§

impl<S, A, B, E, F, EB, K, KA, KB, Sc> JoinTarget<S, A, E, F, Sc> for (EB, GreaterThanJoiner<KA, KB, K>)
where S: Send + Sync + 'static, A: Send + Sync + 'static, B: Send + Sync + 'static, E: CollectionExtract<S, Item = A>, F: UniFilter<S, A>, EB: CollectionExtract<S, Item = B>, K: Ord + Clone + Send + Sync + 'static, KA: Fn(&A) -> K + Send + Sync + 'static, KB: Fn(&B) -> K + Send + Sync + 'static, Sc: Score + 'static,

Source§

type Output = Bi<S, A, B, ViewComparisonPlan<K, KA, KB, false, false>, E, EB, UniLeftBiFilter<F, B>, Sc>

Source§

fn apply(self, extractor_a: E, filter_a: F) -> Self::Output

Source§

impl<S, A, B, E, F, EB, K, KA, KB, Sc> JoinTarget<S, A, E, F, Sc> for (EB, GreaterThanOrEqualJoiner<KA, KB, K>)
where S: Send + Sync + 'static, A: Send + Sync + 'static, B: Send + Sync + 'static, E: CollectionExtract<S, Item = A>, F: UniFilter<S, A>, EB: CollectionExtract<S, Item = B>, K: Ord + Clone + Send + Sync + 'static, KA: Fn(&A) -> K + Send + Sync + 'static, KB: Fn(&B) -> K + Send + Sync + 'static, Sc: Score + 'static,

Source§

type Output = Bi<S, A, B, ViewComparisonPlan<K, KA, KB, false, true>, E, EB, UniLeftBiFilter<F, B>, Sc>

Source§

fn apply(self, extractor_a: E, filter_a: F) -> Self::Output

Source§

impl<S, A, B, E, F, EB, K, KA, KB, Sc> JoinTarget<S, A, E, F, Sc> for (EB, LessThanJoiner<KA, KB, K>)
where S: Send + Sync + 'static, A: Send + Sync + 'static, B: Send + Sync + 'static, E: CollectionExtract<S, Item = A>, F: UniFilter<S, A>, EB: CollectionExtract<S, Item = B>, K: Ord + Clone + Send + Sync + 'static, KA: Fn(&A) -> K + Send + Sync + 'static, KB: Fn(&B) -> K + Send + Sync + 'static, Sc: Score + 'static,

Source§

type Output = Bi<S, A, B, ViewComparisonPlan<K, KA, KB, true, false>, E, EB, UniLeftBiFilter<F, B>, Sc>

Source§

fn apply(self, extractor_a: E, filter_a: F) -> Self::Output

Source§

impl<S, A, B, E, F, EB, K, KA, KB, Sc> JoinTarget<S, A, E, F, Sc> for (EB, LessThanOrEqualJoiner<KA, KB, K>)
where S: Send + Sync + 'static, A: Send + Sync + 'static, B: Send + Sync + 'static, E: CollectionExtract<S, Item = A>, F: UniFilter<S, A>, EB: CollectionExtract<S, Item = B>, K: Ord + Clone + Send + Sync + 'static, KA: Fn(&A) -> K + Send + Sync + 'static, KB: Fn(&B) -> K + Send + Sync + 'static, Sc: Score + 'static,

Source§

type Output = Bi<S, A, B, ViewComparisonPlan<K, KA, KB, true, true>, E, EB, UniLeftBiFilter<F, B>, Sc>

Source§

fn apply(self, extractor_a: E, filter_a: F) -> Self::Output

Source§

impl<S, A, B, E, F, EB, K, SA, EA, SB, EBd, Sc> JoinTarget<S, A, E, F, Sc> for (EB, OverlappingJoiner<SA, EA, SB, EBd, K>)
where S: Send + Sync + 'static, A: Send + Sync + 'static, B: Send + Sync + 'static, E: CollectionExtract<S, Item = A>, F: UniFilter<S, A>, EB: CollectionExtract<S, Item = B>, K: Ord + Clone + Send + Sync + 'static, SA: Fn(&A) -> K + Send + Sync + 'static, EA: Fn(&A) -> K + Send + Sync + 'static, SB: Fn(&B) -> K + Send + Sync + 'static, EBd: Fn(&B) -> K + Send + Sync + 'static, Sc: Score + 'static,

Interval overlap over entity-authored bounds, executed over leaf views.

Source§

type Output = Bi<S, A, B, ViewOverlapPlan<K, SA, EA, SB, EBd>, E, EB, UniLeftBiFilter<F, B>, Sc>

Source§

fn apply(self, extractor_a: E, filter_a: F) -> Self::Output

Implementors§

Source§

impl<S, A, E, F, K, KA, Sc> JoinTarget<S, A, E, F, Sc> for EqualJoiner<KA, KA, K, Symmetric>
where S: Send + Sync + 'static, A: Hash + PartialEq + Send + Sync + 'static, E: CollectionExtract<S, Item = A>, F: UniFilter<S, A>, K: Eq + Hash + Clone + Send + Sync, KA: Fn(&A) -> K + Send + Sync, Sc: Score + 'static,

Self-join: .join(equal(|a: &A| a.key)) — pairs same-collection entities.