Struct wundergraph::prelude::HasMany

pub struct HasMany<T, FK>(_, _);

Type used to indicate that a given field references multiple other entities by a given id

Trait Implementations

impl<L, O, DB, Ctx, FK> AsNonColumnFilter<L, DB, Ctx> for HasMany<O, FK> where
    L: HasTable,
    FK: Default + NonAggregate + QueryFragment<DB> + SelectableExpression<O::Table>,
    O: WundergraphBelongsTo<L::Table, DB, Ctx, FK>,
    O::Table: 'static,
    DB: Backend + ApplyOffset + 'static,
    <O::Table as QuerySource>::FromClause: QueryFragment<DB>,
    DB::QueryBuilder: Default, 

type Filter = ReferenceFilter<<L::Table as Table>::PrimaryKey, Filter<O::Filter, O::Table>, FK, ()>

Type of the filter

impl<T: Clone, FK: Clone> Clone for HasMany<T, FK>

fn clone(&self) -> HasMany<T, FK>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug, FK: Debug> Debug for HasMany<T, FK>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<T: Eq, FK: Eq> Eq for HasMany<T, FK>

impl<T: Hash, FK: Hash> Hash for HasMany<T, FK>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<A, Next, ForeignKey> NonTableFieldCollector<HasMany<Next, ForeignKey>> for (A,) where
    (A,): NonTableFieldExtractor,
    <(A,) as NonTableFieldExtractor>::Out: AppendToTuple<HasMany<Next, ForeignKey>>, 

type Out = <<(A,) as NonTableFieldExtractor>::Out as AppendToTuple<HasMany<Next, ForeignKey>>>::Out

List of all collected fields

const FIELD_COUNT: usize

Number of collected fields

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

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)

impl<A, B, Next, ForeignKey> NonTableFieldCollector<HasMany<Next, ForeignKey>> for (A, B) where
    (A, B): NonTableFieldExtractor,
    <(A, B) as NonTableFieldExtractor>::Out: AppendToTuple<HasMany<Next, ForeignKey>>, 

type Out = <<(A, B) as NonTableFieldExtractor>::Out as AppendToTuple<HasMany<Next, ForeignKey>>>::Out

List of all collected fields

const FIELD_COUNT: usize

Number of collected fields

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

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)

impl<A, B, C, D, E, F, G, H, I, J, K, Next, ForeignKey> NonTableFieldCollector<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): NonTableFieldExtractor,
    <(A, B, C, D, E, F, G, H, I, J, K) as NonTableFieldExtractor>::Out: AppendToTuple<HasMany<Next, ForeignKey>>, 

type Out = <<(A, B, C, D, E, F, G, H, I, J, K) as NonTableFieldExtractor>::Out as AppendToTuple<HasMany<Next, ForeignKey>>>::Out

List of all collected fields

const FIELD_COUNT: usize

Number of collected fields

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

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)

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

type Out = <<(A, B, C, D, E, F, G, H, I, J, K, L) as NonTableFieldExtractor>::Out as AppendToTuple<HasMany<Next, ForeignKey>>>::Out

List of all collected fields

const FIELD_COUNT: usize

Number of collected fields

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

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)

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

type Out = <<(A, B, C, D, E, F, G, H, I, J, K, L, M) as NonTableFieldExtractor>::Out as AppendToTuple<HasMany<Next, ForeignKey>>>::Out

List of all collected fields

const FIELD_COUNT: usize

Number of collected fields

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

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)

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

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

List of all collected fields

const FIELD_COUNT: usize

Number of collected fields

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

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)

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

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

List of all collected fields

const FIELD_COUNT: usize

Number of collected fields

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

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)

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

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

List of all collected fields

const FIELD_COUNT: usize

Number of collected fields

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

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)

impl<A, B, C, Next, ForeignKey> NonTableFieldCollector<HasMany<Next, ForeignKey>> for (A, B, C) where
    (A, B, C): NonTableFieldExtractor,
    <(A, B, C) as NonTableFieldExtractor>::Out: AppendToTuple<HasMany<Next, ForeignKey>>, 

type Out = <<(A, B, C) as NonTableFieldExtractor>::Out as AppendToTuple<HasMany<Next, ForeignKey>>>::Out

List of all collected fields

const FIELD_COUNT: usize

Number of collected fields

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

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)

impl<A, B, C, D, Next, ForeignKey> NonTableFieldCollector<HasMany<Next, ForeignKey>> for (A, B, C, D) where
    (A, B, C, D): NonTableFieldExtractor,
    <(A, B, C, D) as NonTableFieldExtractor>::Out: AppendToTuple<HasMany<Next, ForeignKey>>, 

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

List of all collected fields

const FIELD_COUNT: usize

Number of collected fields

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

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)

impl<A, B, C, D, E, Next, ForeignKey> NonTableFieldCollector<HasMany<Next, ForeignKey>> for (A, B, C, D, E) where
    (A, B, C, D, E): NonTableFieldExtractor,
    <(A, B, C, D, E) as NonTableFieldExtractor>::Out: AppendToTuple<HasMany<Next, ForeignKey>>, 

type Out = <<(A, B, C, D, E) as NonTableFieldExtractor>::Out as AppendToTuple<HasMany<Next, ForeignKey>>>::Out

List of all collected fields

const FIELD_COUNT: usize

Number of collected fields

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

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)

impl<A, B, C, D, E, F, Next, ForeignKey> NonTableFieldCollector<HasMany<Next, ForeignKey>> for (A, B, C, D, E, F) where
    (A, B, C, D, E, F): NonTableFieldExtractor,
    <(A, B, C, D, E, F) as NonTableFieldExtractor>::Out: AppendToTuple<HasMany<Next, ForeignKey>>, 

type Out = <<(A, B, C, D, E, F) as NonTableFieldExtractor>::Out as AppendToTuple<HasMany<Next, ForeignKey>>>::Out

List of all collected fields

const FIELD_COUNT: usize

Number of collected fields

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

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)

impl<A, B, C, D, E, F, G, Next, ForeignKey> NonTableFieldCollector<HasMany<Next, ForeignKey>> for (A, B, C, D, E, F, G) where
    (A, B, C, D, E, F, G): NonTableFieldExtractor,
    <(A, B, C, D, E, F, G) as NonTableFieldExtractor>::Out: AppendToTuple<HasMany<Next, ForeignKey>>, 

type Out = <<(A, B, C, D, E, F, G) as NonTableFieldExtractor>::Out as AppendToTuple<HasMany<Next, ForeignKey>>>::Out

List of all collected fields

const FIELD_COUNT: usize

Number of collected fields

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

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)

impl<A, B, C, D, E, F, G, H, Next, ForeignKey> NonTableFieldCollector<HasMany<Next, ForeignKey>> for (A, B, C, D, E, F, G, H) where
    (A, B, C, D, E, F, G, H): NonTableFieldExtractor,
    <(A, B, C, D, E, F, G, H) as NonTableFieldExtractor>::Out: AppendToTuple<HasMany<Next, ForeignKey>>, 

type Out = <<(A, B, C, D, E, F, G, H) as NonTableFieldExtractor>::Out as AppendToTuple<HasMany<Next, ForeignKey>>>::Out

List of all collected fields

const FIELD_COUNT: usize

Number of collected fields

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

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)

impl<A, B, C, D, E, F, G, H, I, Next, ForeignKey> NonTableFieldCollector<HasMany<Next, ForeignKey>> for (A, B, C, D, E, F, G, H, I) where
    (A, B, C, D, E, F, G, H, I): NonTableFieldExtractor,
    <(A, B, C, D, E, F, G, H, I) as NonTableFieldExtractor>::Out: AppendToTuple<HasMany<Next, ForeignKey>>, 

type Out = <<(A, B, C, D, E, F, G, H, I) as NonTableFieldExtractor>::Out as AppendToTuple<HasMany<Next, ForeignKey>>>::Out

List of all collected fields

const FIELD_COUNT: usize

Number of collected fields

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

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)

impl<A, B, C, D, E, F, G, H, I, J, Next, ForeignKey> NonTableFieldCollector<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): NonTableFieldExtractor,
    <(A, B, C, D, E, F, G, H, I, J) as NonTableFieldExtractor>::Out: AppendToTuple<HasMany<Next, ForeignKey>>, 

type Out = <<(A, B, C, D, E, F, G, H, I, J) as NonTableFieldExtractor>::Out as AppendToTuple<HasMany<Next, ForeignKey>>>::Out

List of all collected fields

const FIELD_COUNT: usize

Number of collected fields

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

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)

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

type Out = (HasMany<T, FK>,)

List of all collected fields

const FIELD_COUNT: usize

Number of collected fields

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)

impl<T: PartialEq, FK: PartialEq> PartialEq<HasMany<T, FK>> for HasMany<T, FK>

fn eq(&self, other: &HasMany<T, FK>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &HasMany<T, FK>) -> bool

This method tests for !=.

impl<T, FK> StructuralEq for HasMany<T, FK>

impl<T, FK> StructuralPartialEq for HasMany<T, FK>

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

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

List of all collected fields

const FIELD_COUNT: usize

Number of collected fields

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

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)

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

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

List of all collected fields

const FIELD_COUNT: usize

Number of collected fields

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

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)

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

List of all collected fields

const FIELD_COUNT: usize

Number of collected fields

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

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)

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

List of all collected fields

const FIELD_COUNT: usize

Number of collected fields

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

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)

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

List of all collected fields

const FIELD_COUNT: usize

Number of collected fields

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

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)

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

List of all collected fields

const FIELD_COUNT: usize

Number of collected fields

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

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)

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

List of all collected fields

const FIELD_COUNT: usize

Number of collected fields

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

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)

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

List of all collected fields

const FIELD_COUNT: usize

Number of collected fields

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

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)

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

List of all collected fields

const FIELD_COUNT: usize

Number of collected fields

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

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)

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

List of all collected fields

const FIELD_COUNT: usize

Number of collected fields

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

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)

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

List of all collected fields

const FIELD_COUNT: usize

Number of collected fields

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

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)

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

List of all collected fields

const FIELD_COUNT: usize

Number of collected fields

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

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)

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

List of all collected fields

const FIELD_COUNT: usize

Number of collected fields

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

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)

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

List of all collected fields

const FIELD_COUNT: usize

Number of collected fields

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

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)

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

List of all collected fields

const FIELD_COUNT: usize

Number of collected fields

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

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)

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

List of all collected fields

const FIELD_COUNT: usize

Number of collected fields

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

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)

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

type Out = ()

List of all collected fields

const FIELD_COUNT: usize

Number of collected fields

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)