Trait wundergraph::query_builder::selection::fields::TableFieldCollector

pub trait TableFieldCollector<T> {
    type Out;

    const FIELD_COUNT: usize;

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

A helper trait to collect extracted graphql fields which represents a database value

Associated Types

type Out

List of all collected fields

Normally a tuple with FIELD_COUNT values

Loading content...

Associated Constants

const FIELD_COUNT: usize

Number of collected 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<T> TableFieldCollector<T> for () where
    T: WundergraphValue, 

type Out = (T,)

const FIELD_COUNT: usize

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

impl<T, FK> TableFieldCollector<HasMany<T, FK>> for ()

type Out = ()

const FIELD_COUNT: usize

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

impl<A, Next> TableFieldCollector<Next> for (A,) where
    Next: WundergraphValue,
    (A,): FieldListExtractor,
    <(A,) as FieldListExtractor>::Out: AppendToTuple<Next>, 

type Out = <<(A,) as FieldListExtractor>::Out as AppendToTuple<Next>>::Out

const FIELD_COUNT: usize

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

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

type Out = <(A,) as FieldListExtractor>::Out

const FIELD_COUNT: usize

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

impl<A, B, Next> TableFieldCollector<Next> for (A, B) where
    Next: WundergraphValue,
    (A, B): FieldListExtractor,
    <(A, B) as FieldListExtractor>::Out: AppendToTuple<Next>, 

type Out = <<(A, B) as FieldListExtractor>::Out as AppendToTuple<Next>>::Out

const FIELD_COUNT: usize

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

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

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

const FIELD_COUNT: usize

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

impl<A, B, C, Next> TableFieldCollector<Next> for (A, B, C) where
    Next: WundergraphValue,
    (A, B, C): FieldListExtractor,
    <(A, B, C) as FieldListExtractor>::Out: AppendToTuple<Next>, 

type Out = <<(A, B, C) as FieldListExtractor>::Out as AppendToTuple<Next>>::Out

const FIELD_COUNT: usize

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

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

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

const FIELD_COUNT: usize

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

impl<A, B, C, D, Next> TableFieldCollector<Next> for (A, B, C, D) where
    Next: WundergraphValue,
    (A, B, C, D): FieldListExtractor,
    <(A, B, C, D) as FieldListExtractor>::Out: AppendToTuple<Next>, 

type Out = <<(A, B, C, D) as FieldListExtractor>::Out as AppendToTuple<Next>>::Out

const FIELD_COUNT: usize

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

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

type Out = <(A, B, C, D) as FieldListExtractor>::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, Next> TableFieldCollector<Next> for (A, B, C, D, E) where
    Next: WundergraphValue,
    (A, B, C, D, E): FieldListExtractor,
    <(A, B, C, D, E) as FieldListExtractor>::Out: AppendToTuple<Next>, 

type Out = <<(A, B, C, D, E) as FieldListExtractor>::Out as AppendToTuple<Next>>::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, Next, ForeignKey> TableFieldCollector<HasMany<Next, ForeignKey>> for (A, B, C, D, E) where
    (A, B, C, D, E): FieldListExtractor, 

type Out = <(A, B, C, D, E) as FieldListExtractor>::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, Next> TableFieldCollector<Next> for (A, B, C, D, E, F) where
    Next: WundergraphValue,
    (A, B, C, D, E, F): FieldListExtractor,
    <(A, B, C, D, E, F) as FieldListExtractor>::Out: AppendToTuple<Next>, 

type Out = <<(A, B, C, D, E, F) as FieldListExtractor>::Out as AppendToTuple<Next>>::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, Next, ForeignKey> TableFieldCollector<HasMany<Next, ForeignKey>> for (A, B, C, D, E, F) where
    (A, B, C, D, E, F): FieldListExtractor, 

type Out = <(A, B, C, D, E, F) as FieldListExtractor>::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, Next> TableFieldCollector<Next> for (A, B, C, D, E, F, G) where
    Next: WundergraphValue,
    (A, B, C, D, E, F, G): FieldListExtractor,
    <(A, B, C, D, E, F, G) as FieldListExtractor>::Out: AppendToTuple<Next>, 

type Out = <<(A, B, C, D, E, F, G) as FieldListExtractor>::Out as AppendToTuple<Next>>::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, Next, ForeignKey> TableFieldCollector<HasMany<Next, ForeignKey>> for (A, B, C, D, E, F, G) where
    (A, B, C, D, E, F, G): FieldListExtractor, 

type Out = <(A, B, C, D, E, F, G) as FieldListExtractor>::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, Next> TableFieldCollector<Next> for (A, B, C, D, E, F, G, H) where
    Next: WundergraphValue,
    (A, B, C, D, E, F, G, H): FieldListExtractor,
    <(A, B, C, D, E, F, G, H) as FieldListExtractor>::Out: AppendToTuple<Next>, 

type Out = <<(A, B, C, D, E, F, G, H) as FieldListExtractor>::Out as AppendToTuple<Next>>::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, Next, ForeignKey> TableFieldCollector<HasMany<Next, ForeignKey>> for (A, B, C, D, E, F, G, H) where
    (A, B, C, D, E, F, G, H): FieldListExtractor, 

type Out = <(A, B, C, D, E, F, G, H) as FieldListExtractor>::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, Next> TableFieldCollector<Next> for (A, B, C, D, E, F, G, H, I) where
    Next: WundergraphValue,
    (A, B, C, D, E, F, G, H, I): FieldListExtractor,
    <(A, B, C, D, E, F, G, H, I) as FieldListExtractor>::Out: AppendToTuple<Next>, 

type Out = <<(A, B, C, D, E, F, G, H, I) as FieldListExtractor>::Out as AppendToTuple<Next>>::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, Next, ForeignKey> TableFieldCollector<HasMany<Next, ForeignKey>> for (A, B, C, D, E, F, G, H, I) where
    (A, B, C, D, E, F, G, H, I): FieldListExtractor, 

type Out = <(A, B, C, D, E, F, G, H, I) as FieldListExtractor>::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, Next> TableFieldCollector<Next> for (A, B, C, D, E, F, G, H, I, J) where
    Next: WundergraphValue,
    (A, B, C, D, E, F, G, H, I, J): FieldListExtractor,
    <(A, B, C, D, E, F, G, H, I, J) as FieldListExtractor>::Out: AppendToTuple<Next>, 

type Out = <<(A, B, C, D, E, F, G, H, I, J) as FieldListExtractor>::Out as AppendToTuple<Next>>::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, Next, ForeignKey> TableFieldCollector<HasMany<Next, ForeignKey>> for (A, B, C, D, E, F, G, H, I, J) where
    (A, B, C, D, E, F, G, H, I, J): FieldListExtractor, 

type Out = <(A, B, C, D, E, F, G, H, I, J) as FieldListExtractor>::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, Next> TableFieldCollector<Next> for (A, B, C, D, E, F, G, H, I, J, K) where
    Next: WundergraphValue,
    (A, B, C, D, E, F, G, H, I, J, K): FieldListExtractor,
    <(A, B, C, D, E, F, G, H, I, J, K) as FieldListExtractor>::Out: AppendToTuple<Next>, 

type Out = <<(A, B, C, D, E, F, G, H, I, J, K) as FieldListExtractor>::Out as AppendToTuple<Next>>::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, Next, ForeignKey> TableFieldCollector<HasMany<Next, ForeignKey>> for (A, B, C, D, E, F, G, H, I, J, K) where
    (A, B, C, D, E, F, G, H, I, J, K): FieldListExtractor, 

type Out = <(A, B, C, D, E, F, G, H, I, J, K) as FieldListExtractor>::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, Next> TableFieldCollector<Next> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    Next: WundergraphValue,
    (A, B, C, D, E, F, G, H, I, J, K, L): FieldListExtractor,
    <(A, B, C, D, E, F, G, H, I, J, K, L) as FieldListExtractor>::Out: AppendToTuple<Next>, 

type Out = <<(A, B, C, D, E, F, G, H, I, J, K, L) as FieldListExtractor>::Out as AppendToTuple<Next>>::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, Next, ForeignKey> TableFieldCollector<HasMany<Next, ForeignKey>> 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, L): FieldListExtractor, 

type Out = <(A, B, C, D, E, F, G, H, I, J, K, L) as FieldListExtractor>::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, Next> TableFieldCollector<Next> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    Next: WundergraphValue,
    (A, B, C, D, E, F, G, H, I, J, K, L, M): FieldListExtractor,
    <(A, B, C, D, E, F, G, H, I, J, K, L, M) as FieldListExtractor>::Out: AppendToTuple<Next>, 

type Out = <<(A, B, C, D, E, F, G, H, I, J, K, L, M) as FieldListExtractor>::Out as AppendToTuple<Next>>::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, Next, ForeignKey> TableFieldCollector<HasMany<Next, ForeignKey>> 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, M): FieldListExtractor, 

type Out = <(A, B, C, D, E, F, G, H, I, J, K, L, M) as FieldListExtractor>::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, Next> TableFieldCollector<Next> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    Next: WundergraphValue,
    (A, B, C, D, E, F, G, H, I, J, K, L, M, N): FieldListExtractor,
    <(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as FieldListExtractor>::Out: AppendToTuple<Next>, 

type Out = <<(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as FieldListExtractor>::Out as AppendToTuple<Next>>::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, Next, ForeignKey> TableFieldCollector<HasMany<Next, ForeignKey>> 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, N): FieldListExtractor, 

type Out = <(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as FieldListExtractor>::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, Next> TableFieldCollector<Next> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    Next: WundergraphValue,
    (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O): FieldListExtractor,
    <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as FieldListExtractor>::Out: AppendToTuple<Next>, 

type Out = <<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as FieldListExtractor>::Out as AppendToTuple<Next>>::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, Next, ForeignKey> TableFieldCollector<HasMany<Next, ForeignKey>> 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, O): FieldListExtractor, 

type Out = <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as FieldListExtractor>::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, Next> TableFieldCollector<Next> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    Next: WundergraphValue,
    (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P): FieldListExtractor,
    <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as FieldListExtractor>::Out: AppendToTuple<Next>, 

type Out = <<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as FieldListExtractor>::Out as AppendToTuple<Next>>::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, Next, ForeignKey> TableFieldCollector<HasMany<Next, ForeignKey>> 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, P): FieldListExtractor, 

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

const FIELD_COUNT: usize

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

Loading content...

Implementors

Loading content...