Trait wundergraph::query_builder::selection::fields::FieldListExtractor

pub trait FieldListExtractor {
    type Out;

    const FIELD_COUNT: usize;

    fn map<F: Fn(usize) -> R, R>(local_index: usize, callback: F) -> Option<R>;
}

A helper trati to exctrat graphql fields, that represent database values, from the global field list

Associated Types

type Out

List of extracted fields

Normally a tuple with FIELD_COUNT values

Loading content...

Associated Constants

const FIELD_COUNT: usize

Number of extracted fields

Loading content...

Required methods

fn map<F: Fn(usize) -> R, R>(local_index: usize, callback: F) -> Option<R>

Execute the given callback with the converted global index (inside the complete field list) calculated from the passed local index (inside this specific field list)

Loading content...

Implementations on Foreign Types

impl FieldListExtractor for ()

type Out = ()

const FIELD_COUNT: usize

fn map<F: Fn(usize) -> R, R>(_local_index: usize, _callback: F) -> Option<R>

impl<A> FieldListExtractor for (A,) where
    (): TableFieldCollector<A>, 

type Out = <() as TableFieldCollector<A>>::Out

const FIELD_COUNT: usize

fn map<Func: Fn(usize) -> Ret, Ret>(
    local_index: usize,
    callback: Func
) -> Option<Ret>

impl<A, B> FieldListExtractor for (A, B) where
    (A,): TableFieldCollector<B>, 

type Out = <(A,) as TableFieldCollector<B>>::Out

const FIELD_COUNT: usize

fn map<Func: Fn(usize) -> Ret, Ret>(
    local_index: usize,
    callback: Func
) -> Option<Ret>

impl<A, B, C> FieldListExtractor for (A, B, C) where
    (A, B): TableFieldCollector<C>, 

type Out = <(A, B) as TableFieldCollector<C>>::Out

const FIELD_COUNT: usize

fn map<Func: Fn(usize) -> Ret, Ret>(
    local_index: usize,
    callback: Func
) -> Option<Ret>

impl<A, B, C, D> FieldListExtractor for (A, B, C, D) where
    (A, B, C): TableFieldCollector<D>, 

type Out = <(A, B, C) as TableFieldCollector<D>>::Out

const FIELD_COUNT: usize

fn map<Func: Fn(usize) -> Ret, Ret>(
    local_index: usize,
    callback: Func
) -> Option<Ret>

impl<A, B, C, D, E> FieldListExtractor for (A, B, C, D, E) where
    (A, B, C, D): TableFieldCollector<E>, 

type Out = <(A, B, C, D) as TableFieldCollector<E>>::Out

const FIELD_COUNT: usize

fn map<Func: Fn(usize) -> Ret, Ret>(
    local_index: usize,
    callback: Func
) -> Option<Ret>

impl<A, B, C, D, E, F> FieldListExtractor for (A, B, C, D, E, F) where
    (A, B, C, D, E): TableFieldCollector<F>, 

type Out = <(A, B, C, D, E) as TableFieldCollector<F>>::Out

const FIELD_COUNT: usize

fn map<Func: Fn(usize) -> Ret, Ret>(
    local_index: usize,
    callback: Func
) -> Option<Ret>

impl<A, B, C, D, E, F, G> FieldListExtractor for (A, B, C, D, E, F, G) where
    (A, B, C, D, E, F): TableFieldCollector<G>, 

type Out = <(A, B, C, D, E, F) as TableFieldCollector<G>>::Out

const FIELD_COUNT: usize

fn map<Func: Fn(usize) -> Ret, Ret>(
    local_index: usize,
    callback: Func
) -> Option<Ret>

impl<A, B, C, D, E, F, G, H> FieldListExtractor for (A, B, C, D, E, F, G, H) where
    (A, B, C, D, E, F, G): TableFieldCollector<H>, 

type Out = <(A, B, C, D, E, F, G) as TableFieldCollector<H>>::Out

const FIELD_COUNT: usize

fn map<Func: Fn(usize) -> Ret, Ret>(
    local_index: usize,
    callback: Func
) -> Option<Ret>

impl<A, B, C, D, E, F, G, H, I> FieldListExtractor for (A, B, C, D, E, F, G, H, I) where
    (A, B, C, D, E, F, G, H): TableFieldCollector<I>, 

type Out = <(A, B, C, D, E, F, G, H) as TableFieldCollector<I>>::Out

const FIELD_COUNT: usize

fn map<Func: Fn(usize) -> Ret, Ret>(
    local_index: usize,
    callback: Func
) -> Option<Ret>

impl<A, B, C, D, E, F, G, H, I, J> FieldListExtractor for (A, B, C, D, E, F, G, H, I, J) where
    (A, B, C, D, E, F, G, H, I): TableFieldCollector<J>, 

type Out = <(A, B, C, D, E, F, G, H, I) as TableFieldCollector<J>>::Out

const FIELD_COUNT: usize

fn map<Func: Fn(usize) -> Ret, Ret>(
    local_index: usize,
    callback: Func
) -> Option<Ret>

impl<A, B, C, D, E, F, G, H, I, J, K> FieldListExtractor for (A, B, C, D, E, F, G, H, I, J, K) where
    (A, B, C, D, E, F, G, H, I, J): TableFieldCollector<K>, 

type Out = <(A, B, C, D, E, F, G, H, I, J) as TableFieldCollector<K>>::Out

const FIELD_COUNT: usize

fn map<Func: Fn(usize) -> Ret, Ret>(
    local_index: usize,
    callback: Func
) -> Option<Ret>

impl<A, B, C, D, E, F, G, H, I, J, K, L> FieldListExtractor for (A, B, C, D, E, F, G, H, I, J, K, L) where
    (A, B, C, D, E, F, G, H, I, J, K): TableFieldCollector<L>, 

type Out = <(A, B, C, D, E, F, G, H, I, J, K) as TableFieldCollector<L>>::Out

const FIELD_COUNT: usize

fn map<Func: Fn(usize) -> Ret, Ret>(
    local_index: usize,
    callback: Func
) -> Option<Ret>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M> FieldListExtractor for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    (A, B, C, D, E, F, G, H, I, J, K, L): TableFieldCollector<M>, 

type Out = <(A, B, C, D, E, F, G, H, I, J, K, L) as TableFieldCollector<M>>::Out

const FIELD_COUNT: usize

fn map<Func: Fn(usize) -> Ret, Ret>(
    local_index: usize,
    callback: Func
) -> Option<Ret>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N> FieldListExtractor for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    (A, B, C, D, E, F, G, H, I, J, K, L, M): TableFieldCollector<N>, 

type Out = <(A, B, C, D, E, F, G, H, I, J, K, L, M) as TableFieldCollector<N>>::Out

const FIELD_COUNT: usize

fn map<Func: Fn(usize) -> Ret, Ret>(
    local_index: usize,
    callback: Func
) -> Option<Ret>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> FieldListExtractor for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    (A, B, C, D, E, F, G, H, I, J, K, L, M, N): TableFieldCollector<O>, 

type Out = <(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as TableFieldCollector<O>>::Out

const FIELD_COUNT: usize

fn map<Func: Fn(usize) -> Ret, Ret>(
    local_index: usize,
    callback: Func
) -> Option<Ret>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> FieldListExtractor for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O): TableFieldCollector<P>, 

type Out = <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as TableFieldCollector<P>>::Out

const FIELD_COUNT: usize

fn map<Func: Fn(usize) -> Ret, Ret>(
    local_index: usize,
    callback: Func
) -> Option<Ret>

Loading content...

Implementors

Loading content...