Trait ArgumentSource 

pub trait ArgumentSource<A: Alignment, V: ValueDomain = <Self as SourceDomain>::ValueDomain>:
    SourceDomain
    + Prepare
    + Explain
    + PlanIdentity
    + PlanInputs
    + Estimated {
    type Retention: Retention;

    // Required method
    fn lookup<'a, 'prepared>(
        prepared: &'prepared Self::Prepared<'a>,
        address: &A::Address<'a>,
    ) -> Lookup<'prepared, QueryResult<V::Value<'a>>>
       where Self: 'a;

    // Provided method
    fn resolve<'a>(
        prepared: &Self::Prepared<'a>,
        address: &A::Address<'a>,
        label: &'static str,
    ) -> <Self::Retention as ElementEmission>::Step<QueryResult<V::Value<'a>>>
       where Self: 'a { ... }
}

Required Associated Types

type Retention: Retention

Required Methods

fn lookup<'a, 'prepared>( prepared: &'prepared Self::Prepared<'a>, address: &A::Address<'a>, ) -> Lookup<'prepared, QueryResult<V::Value<'a>>>

where Self: 'a,

Provided Methods

fn resolve<'a>( prepared: &Self::Prepared<'a>, address: &A::Address<'a>, label: &'static str, ) -> <Self::Retention as ElementEmission>::Step<QueryResult<V::Value<'a>>>

where Self: 'a,

Dyn Compatibility

This trait is not dyn compatible.

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

Implementations on Foreign Types

impl<A, V> ArgumentSource<A, V> for EdgeIndex

where A: Alignment, for<'a> V: ValueDomain<Value<'a> = Self>,

type Retention = Preserving

fn lookup<'a, 'prepared>( prepared: &'prepared Self::Prepared<'a>, _address: &A::Address<'a>, ) -> Lookup<'prepared, QueryResult<V::Value<'a>>>

where Self: 'a,

impl<A, V> ArgumentSource<A, V> for GraphRecordAttribute

where A: Alignment, for<'a> V: ValueDomain<Value<'a> = Self>,

type Retention = Preserving

fn lookup<'a, 'prepared>( prepared: &'prepared Self::Prepared<'a>, _address: &A::Address<'a>, ) -> Lookup<'prepared, QueryResult<V::Value<'a>>>

where Self: 'a,

impl<A, V> ArgumentSource<A, V> for GraphRecordValue

where A: Alignment, for<'a> V: ValueDomain<Value<'a> = Self>,

type Retention = Preserving

fn lookup<'a, 'prepared>( prepared: &'prepared Self::Prepared<'a>, _address: &A::Address<'a>, ) -> Lookup<'prepared, QueryResult<V::Value<'a>>>

where Self: 'a,

impl<A, V> ArgumentSource<A, V> for bool

where A: Alignment, for<'a> V: ValueDomain<Value<'a> = Self>,

type Retention = Preserving

fn lookup<'a, 'prepared>( prepared: &'prepared Self::Prepared<'a>, _address: &A::Address<'a>, ) -> Lookup<'prepared, QueryResult<V::Value<'a>>>

where Self: 'a,

Implementors

impl<A, V, R> ArgumentSource<A, V> for Argument<A, V, R>

where A: Alignment, V: ValueDomain, R: Retention,

type Retention = R

impl<A, V> ArgumentSource<A, V> for FailureKind

where A: Alignment, for<'a> V: ValueDomain<Value<'a> = Self>,

type Retention = Preserving

impl<A, V> ArgumentSource<A, V> for Position

where A: Alignment, for<'a> V: ValueDomain<Value<'a> = Self>,

type Retention = Preserving

impl<A: Alignment, S: MaybeAbsent<A>, P: MissingPolicy<A, S>> ArgumentSource<A> for WithMissing<A, S, P>

type Retention = <P as MissingPolicy<A, S>>::Retention

impl<S: ElementShape, C: AlignableArity<S, A>, A: Alignment> ArgumentSource<A> for OperandHandle<S, C>

type Retention = <C as AlignableArity<S, A>>::Retention