Trait Apply 

pub trait Apply<P: Operation<Scope = S>, S: OperationScope = <P as Operation>::Scope>: Operand {
    type Output: Operand;

    // Required methods
    fn apply<'a>(
        graphrecord: &'a GraphRecord,
        values: Self::ReturnValue<'a>,
        prepared: P::Prepared<'a>,
    ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>
       where Self: 'a;
    fn estimate(operation: &P, input: Estimate, stats: &Stats<'_>) -> Estimate;
}

Required Associated Types

type Output: Operand

Required Methods

fn apply<'a>( graphrecord: &'a GraphRecord, values: Self::ReturnValue<'a>, prepared: P::Prepared<'a>, ) -> QueryResult<<Self::Output as EvaluateOperand>::ReturnValue<'a>>

where Self: 'a,

fn estimate(operation: &P, input: Estimate, stats: &Stats<'_>) -> Estimate

Dyn Compatibility

This trait is not dyn compatible.

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

Implementors

impl<M, K, N, L, O, P, S> Apply<P, S> for GroupOperand<M, K, GroupOperand<N, L, O>>

where M: IndexDomain, K: GroupKey, N: IndexDomain, L: GroupKey, O: Operand, P: Operation<Scope = S>, S: OperationScope, GroupOperand<N, L, O>: Apply<P, S>,

type Output = GroupOperand<M, K, <GroupOperand<N, L, O> as Apply<P, S>>::Output>

impl<M, K, S, C, P> Apply<P, Element> for GroupOperand<M, K, OperandHandle<S, C>>

where M: IndexDomain, K: GroupKey, S: ElementShape + ElementTransition<P::OutShape, P::Emission>, C: Arity, P: ElementKernel<S>,

type Output = GroupOperand<M, K, <OperandHandle<S, C> as Apply<P, Element>>::Output>

impl<M, K, S, C, P> Apply<P, Group> for GroupOperand<M, K, OperandHandle<S, C>>

where M: IndexDomain, K: GroupKey, S: ElementShape, C: Arity, P: GroupKernel<M, K, OperandHandle<S, C>>,

type Output = <P as GroupKernel<M, K, OperandHandle<S, C>>>::Output

impl<M: IndexDomain, K: GroupKey, S: ElementShape, C: Arity, P: LaneKernel<S, C>> Apply<P, Lane> for GroupOperand<M, K, OperandHandle<S, C>>

type Output = GroupOperand<M, K, <OperandHandle<S, C> as Apply<P, Lane>>::Output>

impl<S, C, P> Apply<P, Element> for OperandHandle<S, C>

where S: ElementShape + ElementTransition<P::OutShape, P::Emission>, C: Arity, P: ElementKernel<S>,

type Output = OperandHandle<<P as ElementKernel<S>>::OutShape, <<P as ElementKernel<S>>::Emission as ElementEmission>::OutArity<C>>

impl<S: ElementShape, C: Arity, P: LaneKernel<S, C>> Apply<P, Lane> for OperandHandle<S, C>

type Output = <P as LaneKernel<S, C>>::Output