Skip to main content

Penta

Struct Penta 

Source
pub struct Penta<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, Sc>
where Sc: Score, P1: CompileCondition<Plan: IndexedPlan>, P2: CompileCondition<Plan: IndexedPlan>, P3: CompileCondition<Plan: IndexedPlan>, P4: CompileCondition<Plan: IndexedPlan>,
{ /* private fields */ }
Expand description

Five-collection join stream: the tri join extended with D through P3 and then E through P4, each step compiled into its own plan over the row before it.

Implementations§

Source§

impl<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, Sc> Penta<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, Sc>
where S: Send + Sync + 'static, A: Clone + Send + Sync + 'static, B: Clone + Send + Sync + 'static, C: Clone + Send + Sync + 'static, D: Clone + Send + Sync + 'static, E: Clone + Send + Sync + 'static, EA: 'static, EB: 'static, EC: 'static, ED: 'static, EE: 'static, P1: CompileCondition<Plan: IndexedPlan> + 'static, P2: CompileCondition<Plan: IndexedPlan> + 'static, P3: CompileCondition<Plan: IndexedPlan> + 'static, P4: CompileCondition<Plan: IndexedPlan> + 'static, for<'a> JoinNode<S, JoinNode<S, JoinNode<S, JoinNode<S, CollectionNode<S, EA>, CollectionNode<S, EB>, <P1 as CompileCondition>::Plan>, CollectionNode<S, EC>, <P2 as CompileCondition>::Plan>, CollectionNode<S, ED>, <P3 as CompileCondition>::Plan>, CollectionNode<S, EE>, <P4 as CompileCondition>::Plan>: Operator<S>, F: PentaFilter<S, A, B, C, D, E>, Sc: Score + 'static,

Source

pub fn filter<P>( self, predicate: P, ) -> Penta<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, AndPentaFilter<F, FnPentaFilter<impl Fn(&S, &A, &B, &C, &D, &E, usize, usize, usize, usize, usize) -> bool + Send + Sync>>, Sc>
where P: Fn(&A, &B, &C, &D, &E) -> bool + Send + Sync,

Adds a filter predicate to the stream.

Source

pub fn penalize<W>( self, weight: W, ) -> PentaBuilder<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, impl Fn(&A, &B, &C, &D, &E) -> Sc + Send + Sync, Sc>
where W: for<'w> ConstraintWeight<(&'w A, &'w B, &'w C, &'w D, &'w E), Sc> + Send + Sync,

Penalizes each match by weight.

weight is a fixed score, or a closure over the matched entities returning one. A fixed weight with a non-zero hard level marks the constraint hard; closures are soft unless wrapped in hard_weight.

Source

pub fn reward<W>( self, weight: W, ) -> PentaBuilder<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, impl Fn(&A, &B, &C, &D, &E) -> Sc + Send + Sync, Sc>
where W: for<'w> ConstraintWeight<(&'w A, &'w B, &'w C, &'w D, &'w E), Sc> + Send + Sync,

Rewards each match by weight.

weight is a fixed score, or a closure over the matched entities returning one. A fixed weight with a non-zero hard level marks the constraint hard; closures are soft unless wrapped in hard_weight.

Source§

impl<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, Sc> Penta<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, Sc>
where S: Send + Sync + 'static, A: Clone + Send + Sync + 'static, B: Clone + Send + Sync + 'static, C: Clone + Send + Sync + 'static, D: Clone + Send + Sync + 'static, E: Clone + Send + Sync + 'static, EA: 'static, EB: 'static, EC: 'static, ED: 'static, EE: 'static, P1: CompileCondition<Plan: IndexedPlan> + 'static, P2: CompileCondition<Plan: IndexedPlan> + 'static, P3: CompileCondition<Plan: IndexedPlan> + 'static, P4: CompileCondition<Plan: IndexedPlan> + 'static, F: PentaFilter<S, A, B, C, D, E> + 'static, Sc: Score + 'static, for<'a> JoinNode<S, JoinNode<S, JoinNode<S, JoinNode<S, CollectionNode<S, EA>, CollectionNode<S, EB>, <P1 as CompileCondition>::Plan>, CollectionNode<S, EC>, <P2 as CompileCondition>::Plan>, CollectionNode<S, ED>, <P3 as CompileCondition>::Plan>, CollectionNode<S, EE>, <P4 as CompileCondition>::Plan>: Operator<S, View<'a> = Pair<Pair<Pair<Pair<Leaf<'a, A>, Leaf<'a, B>>, Leaf<'a, C>>, Leaf<'a, D>>, Leaf<'a, E>>> + Send + Sync,

Zero-erasure builder for finalizing a canonical penta constraint.

Source

pub fn join<G, EG, P5>( self, target: (EG, P5), ) -> Chain<S, JoinNode<S, PentaScored<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F>, CollectionNode<S, EG>, <P5 as CompileCondition>::Plan>, Sc>
where G: Clone + Send + Sync + 'static, EG: CollectionExtract<S, Item = G> + 'static, P5: CompileCondition + 'static, for<'a> P5::Plan: IndexedPlan + ExecutablePlan<<JoinNode<S, JoinNode<S, JoinNode<S, JoinNode<S, CollectionNode<S, EA>, CollectionNode<S, EB>, <P1 as CompileCondition>::Plan>, CollectionNode<S, EC>, <P2 as CompileCondition>::Plan>, CollectionNode<S, ED>, <P3 as CompileCondition>::Plan>, CollectionNode<S, EE>, <P4 as CompileCondition>::Plan> as Operator<S>>::View<'a>, Leaf<'a, G>>, for<'a> JoinNode<S, PentaScored<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F>, CollectionNode<S, EG>, <P5 as CompileCondition>::Plan>: Operator<S>,

Continues the chain past the named cross-stream arities.

Returns a Chain over this penta’s tree with every filter authored so far applied once at the penta boundary; subsequent .join(...) calls nest further JoinNodes with no fixed ceiling.

§Key shapes

This join also takes VIEW keys, not entity keys: the left key closure receives the whole borrowed (A, B, C, D, E) row and the right key receives &Leaf<'_, G> (read fields via .entity). equal_bi with entity closures does NOT typecheck here (E0631) — use equal_on.

Source§

impl<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, Sc> Penta<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, Sc>
where S: Send + Sync + 'static, A: Clone + Send + Sync + 'static, B: Clone + Send + Sync + 'static, C: Clone + Send + Sync + 'static, D: Clone + Send + Sync + 'static, E: Clone + Send + Sync + 'static, EA: 'static, EB: 'static, EC: 'static, ED: 'static, EE: 'static, P1: CompileCondition<Plan: IndexedPlan> + 'static, P2: CompileCondition<Plan: IndexedPlan> + 'static, P3: CompileCondition<Plan: IndexedPlan> + 'static, P4: CompileCondition<Plan: IndexedPlan> + 'static, for<'a> JoinNode<S, JoinNode<S, JoinNode<S, JoinNode<S, CollectionNode<S, EA>, CollectionNode<S, EB>, <P1 as CompileCondition>::Plan>, CollectionNode<S, EC>, <P2 as CompileCondition>::Plan>, CollectionNode<S, ED>, <P3 as CompileCondition>::Plan>, CollectionNode<S, EE>, <P4 as CompileCondition>::Plan>: Operator<S, View<'a> = Pair<Pair<Pair<Pair<Leaf<'a, A>, Leaf<'a, B>>, Leaf<'a, C>>, Leaf<'a, D>>, Leaf<'a, E>>> + Send + Sync, F: PentaFilter<S, A, B, C, D, E> + 'static, Sc: Score + 'static,

Source

pub fn group_by<GK, GF, Co, V, R, Acc>( self, key: GF, collector: Co, ) -> JoinedGroupedStream<S, FilterNode<JoinNode<S, JoinNode<S, JoinNode<S, JoinNode<S, CollectionNode<S, EA>, CollectionNode<S, EB>, <P1 as CompileCondition>::Plan>, CollectionNode<S, EC>, <P2 as CompileCondition>::Plan>, CollectionNode<S, ED>, <P3 as CompileCondition>::Plan>, CollectionNode<S, EE>, <P4 as CompileCondition>::Plan>, impl Fn(&S, &Pair<Pair<Pair<Pair<Leaf<'_, A>, Leaf<'_, B>>, Leaf<'_, C>>, Leaf<'_, D>>, Leaf<'_, E>>) -> bool + Send + Sync>, impl Fn(&Pair<Pair<Pair<Pair<Leaf<'_, A>, Leaf<'_, B>>, Leaf<'_, C>>, Leaf<'_, D>>, Leaf<'_, E>>) -> GK + Send + Sync, TupleCollector<Co, V, R, Acc>, GK, V, R, Acc, Sc>
where GK: Eq + Hash + Clone + Send + Sync + 'static, GF: Fn(&A, &B, &C, &D, &E) -> GK + Send + Sync + 'static, Co: for<'i> Collector<(&'i A, &'i B, &'i C, &'i D, &'i E), Value = V, Result = R, Accumulator = Acc> + 'static, V: Send + Sync + 'static, R: Send + Sync + 'static, Acc: Accumulator<V, R> + 'static,

Groups joined tuples by a key and an owned-value collector. Upstream filters remain binding on full and incremental evaluation.

Auto Trait Implementations§

§

impl<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, Sc> Freeze for Penta<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, Sc>
where JoinNode<S, JoinNode<S, JoinNode<S, JoinNode<S, CollectionNode<S, EA>, CollectionNode<S, EB>, <P1 as CompileCondition>::Plan>, CollectionNode<S, EC>, <P2 as CompileCondition>::Plan>, CollectionNode<S, ED>, <P3 as CompileCondition>::Plan>, CollectionNode<S, EE>, <P4 as CompileCondition>::Plan>: Freeze, F: Freeze, PhantomData<(fn() -> S, fn() -> A, fn() -> B, fn() -> C, fn() -> D, fn() -> E, fn() -> Sc)>: Freeze,

§

impl<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, Sc> RefUnwindSafe for Penta<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, Sc>
where JoinNode<S, JoinNode<S, JoinNode<S, JoinNode<S, CollectionNode<S, EA>, CollectionNode<S, EB>, <P1 as CompileCondition>::Plan>, CollectionNode<S, EC>, <P2 as CompileCondition>::Plan>, CollectionNode<S, ED>, <P3 as CompileCondition>::Plan>, CollectionNode<S, EE>, <P4 as CompileCondition>::Plan>: RefUnwindSafe, F: RefUnwindSafe, PhantomData<(fn() -> S, fn() -> A, fn() -> B, fn() -> C, fn() -> D, fn() -> E, fn() -> Sc)>: RefUnwindSafe,

§

impl<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, Sc> Send for Penta<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, Sc>
where JoinNode<S, JoinNode<S, JoinNode<S, JoinNode<S, CollectionNode<S, EA>, CollectionNode<S, EB>, <P1 as CompileCondition>::Plan>, CollectionNode<S, EC>, <P2 as CompileCondition>::Plan>, CollectionNode<S, ED>, <P3 as CompileCondition>::Plan>, CollectionNode<S, EE>, <P4 as CompileCondition>::Plan>: Send, F: Send, PhantomData<(fn() -> S, fn() -> A, fn() -> B, fn() -> C, fn() -> D, fn() -> E, fn() -> Sc)>: Send,

§

impl<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, Sc> Sync for Penta<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, Sc>
where JoinNode<S, JoinNode<S, JoinNode<S, JoinNode<S, CollectionNode<S, EA>, CollectionNode<S, EB>, <P1 as CompileCondition>::Plan>, CollectionNode<S, EC>, <P2 as CompileCondition>::Plan>, CollectionNode<S, ED>, <P3 as CompileCondition>::Plan>, CollectionNode<S, EE>, <P4 as CompileCondition>::Plan>: Sync, F: Sync, PhantomData<(fn() -> S, fn() -> A, fn() -> B, fn() -> C, fn() -> D, fn() -> E, fn() -> Sc)>: Sync,

§

impl<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, Sc> Unpin for Penta<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, Sc>
where JoinNode<S, JoinNode<S, JoinNode<S, JoinNode<S, CollectionNode<S, EA>, CollectionNode<S, EB>, <P1 as CompileCondition>::Plan>, CollectionNode<S, EC>, <P2 as CompileCondition>::Plan>, CollectionNode<S, ED>, <P3 as CompileCondition>::Plan>, CollectionNode<S, EE>, <P4 as CompileCondition>::Plan>: Unpin, F: Unpin, PhantomData<(fn() -> S, fn() -> A, fn() -> B, fn() -> C, fn() -> D, fn() -> E, fn() -> Sc)>: Unpin,

§

impl<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, Sc> UnsafeUnpin for Penta<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, Sc>
where JoinNode<S, JoinNode<S, JoinNode<S, JoinNode<S, CollectionNode<S, EA>, CollectionNode<S, EB>, <P1 as CompileCondition>::Plan>, CollectionNode<S, EC>, <P2 as CompileCondition>::Plan>, CollectionNode<S, ED>, <P3 as CompileCondition>::Plan>, CollectionNode<S, EE>, <P4 as CompileCondition>::Plan>: UnsafeUnpin, F: UnsafeUnpin, PhantomData<(fn() -> S, fn() -> A, fn() -> B, fn() -> C, fn() -> D, fn() -> E, fn() -> Sc)>: UnsafeUnpin,

§

impl<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, Sc> UnwindSafe for Penta<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, Sc>
where JoinNode<S, JoinNode<S, JoinNode<S, JoinNode<S, CollectionNode<S, EA>, CollectionNode<S, EB>, <P1 as CompileCondition>::Plan>, CollectionNode<S, EC>, <P2 as CompileCondition>::Plan>, CollectionNode<S, ED>, <P3 as CompileCondition>::Plan>, CollectionNode<S, EE>, <P4 as CompileCondition>::Plan>: UnwindSafe, F: UnwindSafe, PhantomData<(fn() -> S, fn() -> A, fn() -> B, fn() -> C, fn() -> D, fn() -> E, fn() -> Sc)>: 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, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = !

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

fn try_from(value: U) -> Result<T, !>

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.