Trait JoinTarget 

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

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

Required Associated Types

type Output

Required Methods

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

Dyn Compatibility

This trait is dyn compatible.

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

Implementations on Foreign Types

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: Clone + Send + Sync + 'static, B: Clone + 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,

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

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

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: Clone + Send + Sync + 'static, B: Clone + 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,

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>

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

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: Clone + Send + Sync + 'static, B: Clone + 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,

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

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

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: Clone + Send + Sync + 'static, B: Clone + 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,

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

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

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: Clone + Send + Sync + 'static, B: Clone + 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,

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

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

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: Clone + Send + Sync + 'static, B: Clone + 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,

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

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

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: Clone + Send + Sync + 'static, B: Clone + 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,

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

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

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: Clone + Send + Sync + 'static, B: Clone + 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,

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

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

Implementors

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: Clone + 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,

type Output = BiConstraintStream<S, A, K, E, EntityKeyAdapter<KA>, UniBiFilter<F, A>, Sc>