[−][src]Trait wundergraph::query_builder::selection::fields::NonTableFieldCollector
A helper trait to collect extracted graphql fields which not represent a database value
Associated Types
type Out
List of all collected fields
Normally a tuple with FIELD_COUNT
values
Associated Constants
const FIELD_COUNT: usize
Number of collected fields
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)
Implementations on Foreign Types
impl<T> NonTableFieldCollector<T> for () where
T: WundergraphValue,
[src]
T: WundergraphValue,
type Out = ()
const FIELD_COUNT: usize
[src]
fn map<F: Fn(usize) -> R, R>(_local_index: usize, _callback: F) -> Option<R>
[src]
impl<T, FK> NonTableFieldCollector<HasMany<T, FK>> for ()
[src]
type Out = (HasMany<T, FK>,)
const FIELD_COUNT: usize
[src]
fn map<F: Fn(usize) -> R, R>(local_index: usize, callback: F) -> Option<R>
[src]
impl<A, Next> NonTableFieldCollector<Next> for (A,) where
Next: WundergraphValue,
(A,): NonTableFieldExtractor,
[src]
Next: WundergraphValue,
(A,): NonTableFieldExtractor,
type Out = <(A,) as NonTableFieldExtractor>::Out
const FIELD_COUNT: usize
[src]
fn map<Func: Fn(usize) -> Ret, Ret>(
local_index: usize,
callback: Func
) -> Option<Ret>
[src]
local_index: usize,
callback: Func
) -> Option<Ret>
impl<A, Next, ForeignKey> NonTableFieldCollector<HasMany<Next, ForeignKey>> for (A,) where
(A,): NonTableFieldExtractor,
<(A,) as NonTableFieldExtractor>::Out: AppendToTuple<HasMany<Next, ForeignKey>>,
[src]
(A,): NonTableFieldExtractor,
<(A,) as NonTableFieldExtractor>::Out: AppendToTuple<HasMany<Next, ForeignKey>>,
type Out = <<(A,) as NonTableFieldExtractor>::Out as AppendToTuple<HasMany<Next, ForeignKey>>>::Out
const FIELD_COUNT: usize
[src]
fn map<Func: Fn(usize) -> Ret, Ret>(
local_index: usize,
callback: Func
) -> Option<Ret>
[src]
local_index: usize,
callback: Func
) -> Option<Ret>
impl<A, B, Next> NonTableFieldCollector<Next> for (A, B) where
Next: WundergraphValue,
(A, B): NonTableFieldExtractor,
[src]
Next: WundergraphValue,
(A, B): NonTableFieldExtractor,
type Out = <(A, B) as NonTableFieldExtractor>::Out
const FIELD_COUNT: usize
[src]
fn map<Func: Fn(usize) -> Ret, Ret>(
local_index: usize,
callback: Func
) -> Option<Ret>
[src]
local_index: usize,
callback: Func
) -> Option<Ret>
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>>,
[src]
(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
const FIELD_COUNT: usize
[src]
fn map<Func: Fn(usize) -> Ret, Ret>(
local_index: usize,
callback: Func
) -> Option<Ret>
[src]
local_index: usize,
callback: Func
) -> Option<Ret>
impl<A, B, C, Next> NonTableFieldCollector<Next> for (A, B, C) where
Next: WundergraphValue,
(A, B, C): NonTableFieldExtractor,
[src]
Next: WundergraphValue,
(A, B, C): NonTableFieldExtractor,
type Out = <(A, B, C) as NonTableFieldExtractor>::Out
const FIELD_COUNT: usize
[src]
fn map<Func: Fn(usize) -> Ret, Ret>(
local_index: usize,
callback: Func
) -> Option<Ret>
[src]
local_index: usize,
callback: Func
) -> Option<Ret>
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>>,
[src]
(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
const FIELD_COUNT: usize
[src]
fn map<Func: Fn(usize) -> Ret, Ret>(
local_index: usize,
callback: Func
) -> Option<Ret>
[src]
local_index: usize,
callback: Func
) -> Option<Ret>
impl<A, B, C, D, Next> NonTableFieldCollector<Next> for (A, B, C, D) where
Next: WundergraphValue,
(A, B, C, D): NonTableFieldExtractor,
[src]
Next: WundergraphValue,
(A, B, C, D): NonTableFieldExtractor,
type Out = <(A, B, C, D) as NonTableFieldExtractor>::Out
const FIELD_COUNT: usize
[src]
fn map<Func: Fn(usize) -> Ret, Ret>(
local_index: usize,
callback: Func
) -> Option<Ret>
[src]
local_index: usize,
callback: Func
) -> Option<Ret>
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>>,
[src]
(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
const FIELD_COUNT: usize
[src]
fn map<Func: Fn(usize) -> Ret, Ret>(
local_index: usize,
callback: Func
) -> Option<Ret>
[src]
local_index: usize,
callback: Func
) -> Option<Ret>
impl<A, B, C, D, E, Next> NonTableFieldCollector<Next> for (A, B, C, D, E) where
Next: WundergraphValue,
(A, B, C, D, E): NonTableFieldExtractor,
[src]
Next: WundergraphValue,
(A, B, C, D, E): NonTableFieldExtractor,
type Out = <(A, B, C, D, E) as NonTableFieldExtractor>::Out
const FIELD_COUNT: usize
[src]
fn map<Func: Fn(usize) -> Ret, Ret>(
local_index: usize,
callback: Func
) -> Option<Ret>
[src]
local_index: usize,
callback: Func
) -> Option<Ret>
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>>,
[src]
(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
const FIELD_COUNT: usize
[src]
fn map<Func: Fn(usize) -> Ret, Ret>(
local_index: usize,
callback: Func
) -> Option<Ret>
[src]
local_index: usize,
callback: Func
) -> Option<Ret>
impl<A, B, C, D, E, F, Next> NonTableFieldCollector<Next> for (A, B, C, D, E, F) where
Next: WundergraphValue,
(A, B, C, D, E, F): NonTableFieldExtractor,
[src]
Next: WundergraphValue,
(A, B, C, D, E, F): NonTableFieldExtractor,
type Out = <(A, B, C, D, E, F) as NonTableFieldExtractor>::Out
const FIELD_COUNT: usize
[src]
fn map<Func: Fn(usize) -> Ret, Ret>(
local_index: usize,
callback: Func
) -> Option<Ret>
[src]
local_index: usize,
callback: Func
) -> Option<Ret>
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>>,
[src]
(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
const FIELD_COUNT: usize
[src]
fn map<Func: Fn(usize) -> Ret, Ret>(
local_index: usize,
callback: Func
) -> Option<Ret>
[src]
local_index: usize,
callback: Func
) -> Option<Ret>
impl<A, B, C, D, E, F, G, Next> NonTableFieldCollector<Next> for (A, B, C, D, E, F, G) where
Next: WundergraphValue,
(A, B, C, D, E, F, G): NonTableFieldExtractor,
[src]
Next: WundergraphValue,
(A, B, C, D, E, F, G): NonTableFieldExtractor,
type Out = <(A, B, C, D, E, F, G) as NonTableFieldExtractor>::Out
const FIELD_COUNT: usize
[src]
fn map<Func: Fn(usize) -> Ret, Ret>(
local_index: usize,
callback: Func
) -> Option<Ret>
[src]
local_index: usize,
callback: Func
) -> Option<Ret>
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>>,
[src]
(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
const FIELD_COUNT: usize
[src]
fn map<Func: Fn(usize) -> Ret, Ret>(
local_index: usize,
callback: Func
) -> Option<Ret>
[src]
local_index: usize,
callback: Func
) -> Option<Ret>
impl<A, B, C, D, E, F, G, H, Next> NonTableFieldCollector<Next> for (A, B, C, D, E, F, G, H) where
Next: WundergraphValue,
(A, B, C, D, E, F, G, H): NonTableFieldExtractor,
[src]
Next: WundergraphValue,
(A, B, C, D, E, F, G, H): NonTableFieldExtractor,
type Out = <(A, B, C, D, E, F, G, H) as NonTableFieldExtractor>::Out
const FIELD_COUNT: usize
[src]
fn map<Func: Fn(usize) -> Ret, Ret>(
local_index: usize,
callback: Func
) -> Option<Ret>
[src]
local_index: usize,
callback: Func
) -> Option<Ret>
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>>,
[src]
(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
const FIELD_COUNT: usize
[src]
fn map<Func: Fn(usize) -> Ret, Ret>(
local_index: usize,
callback: Func
) -> Option<Ret>
[src]
local_index: usize,
callback: Func
) -> Option<Ret>
impl<A, B, C, D, E, F, G, H, I, Next> NonTableFieldCollector<Next> for (A, B, C, D, E, F, G, H, I) where
Next: WundergraphValue,
(A, B, C, D, E, F, G, H, I): NonTableFieldExtractor,
[src]
Next: WundergraphValue,
(A, B, C, D, E, F, G, H, I): NonTableFieldExtractor,
type Out = <(A, B, C, D, E, F, G, H, I) as NonTableFieldExtractor>::Out
const FIELD_COUNT: usize
[src]
fn map<Func: Fn(usize) -> Ret, Ret>(
local_index: usize,
callback: Func
) -> Option<Ret>
[src]
local_index: usize,
callback: Func
) -> Option<Ret>
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>>,
[src]
(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
const FIELD_COUNT: usize
[src]
fn map<Func: Fn(usize) -> Ret, Ret>(
local_index: usize,
callback: Func
) -> Option<Ret>
[src]
local_index: usize,
callback: Func
) -> Option<Ret>
impl<A, B, C, D, E, F, G, H, I, J, Next> NonTableFieldCollector<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): NonTableFieldExtractor,
[src]
Next: WundergraphValue,
(A, B, C, D, E, F, G, H, I, J): NonTableFieldExtractor,
type Out = <(A, B, C, D, E, F, G, H, I, J) as NonTableFieldExtractor>::Out
const FIELD_COUNT: usize
[src]
fn map<Func: Fn(usize) -> Ret, Ret>(
local_index: usize,
callback: Func
) -> Option<Ret>
[src]
local_index: usize,
callback: Func
) -> Option<Ret>
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>>,
[src]
(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
const FIELD_COUNT: usize
[src]
fn map<Func: Fn(usize) -> Ret, Ret>(
local_index: usize,
callback: Func
) -> Option<Ret>
[src]
local_index: usize,
callback: Func
) -> Option<Ret>
impl<A, B, C, D, E, F, G, H, I, J, K, Next> NonTableFieldCollector<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): NonTableFieldExtractor,
[src]
Next: WundergraphValue,
(A, B, C, D, E, F, G, H, I, J, K): NonTableFieldExtractor,
type Out = <(A, B, C, D, E, F, G, H, I, J, K) as NonTableFieldExtractor>::Out
const FIELD_COUNT: usize
[src]
fn map<Func: Fn(usize) -> Ret, Ret>(
local_index: usize,
callback: Func
) -> Option<Ret>
[src]
local_index: usize,
callback: Func
) -> Option<Ret>
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>>,
[src]
(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
const FIELD_COUNT: usize
[src]
fn map<Func: Fn(usize) -> Ret, Ret>(
local_index: usize,
callback: Func
) -> Option<Ret>
[src]
local_index: usize,
callback: Func
) -> Option<Ret>
impl<A, B, C, D, E, F, G, H, I, J, K, L, Next> NonTableFieldCollector<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): NonTableFieldExtractor,
[src]
Next: WundergraphValue,
(A, B, C, D, E, F, G, H, I, J, K, L): NonTableFieldExtractor,
type Out = <(A, B, C, D, E, F, G, H, I, J, K, L) as NonTableFieldExtractor>::Out
const FIELD_COUNT: usize
[src]
fn map<Func: Fn(usize) -> Ret, Ret>(
local_index: usize,
callback: Func
) -> Option<Ret>
[src]
local_index: usize,
callback: Func
) -> Option<Ret>
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>>,
[src]
(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
const FIELD_COUNT: usize
[src]
fn map<Func: Fn(usize) -> Ret, Ret>(
local_index: usize,
callback: Func
) -> Option<Ret>
[src]
local_index: usize,
callback: Func
) -> Option<Ret>
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, Next> NonTableFieldCollector<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): NonTableFieldExtractor,
[src]
Next: WundergraphValue,
(A, B, C, D, E, F, G, H, I, J, K, L, M): NonTableFieldExtractor,
type Out = <(A, B, C, D, E, F, G, H, I, J, K, L, M) as NonTableFieldExtractor>::Out
const FIELD_COUNT: usize
[src]
fn map<Func: Fn(usize) -> Ret, Ret>(
local_index: usize,
callback: Func
) -> Option<Ret>
[src]
local_index: usize,
callback: Func
) -> Option<Ret>
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>>,
[src]
(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
const FIELD_COUNT: usize
[src]
fn map<Func: Fn(usize) -> Ret, Ret>(
local_index: usize,
callback: Func
) -> Option<Ret>
[src]
local_index: usize,
callback: Func
) -> Option<Ret>
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, Next> NonTableFieldCollector<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): NonTableFieldExtractor,
[src]
Next: WundergraphValue,
(A, B, C, D, E, F, G, H, I, J, K, L, M, N): NonTableFieldExtractor,
type Out = <(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as NonTableFieldExtractor>::Out
const FIELD_COUNT: usize
[src]
fn map<Func: Fn(usize) -> Ret, Ret>(
local_index: usize,
callback: Func
) -> Option<Ret>
[src]
local_index: usize,
callback: Func
) -> Option<Ret>
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>>,
[src]
(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
const FIELD_COUNT: usize
[src]
fn map<Func: Fn(usize) -> Ret, Ret>(
local_index: usize,
callback: Func
) -> Option<Ret>
[src]
local_index: usize,
callback: Func
) -> Option<Ret>
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Next> NonTableFieldCollector<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): NonTableFieldExtractor,
[src]
Next: WundergraphValue,
(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O): NonTableFieldExtractor,
type Out = <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as NonTableFieldExtractor>::Out
const FIELD_COUNT: usize
[src]
fn map<Func: Fn(usize) -> Ret, Ret>(
local_index: usize,
callback: Func
) -> Option<Ret>
[src]
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> 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>>,
[src]
(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
const FIELD_COUNT: usize
[src]
fn map<Func: Fn(usize) -> Ret, Ret>(
local_index: usize,
callback: Func
) -> Option<Ret>
[src]
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> NonTableFieldCollector<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): NonTableFieldExtractor,
[src]
Next: WundergraphValue,
(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P): NonTableFieldExtractor,
type Out = <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as NonTableFieldExtractor>::Out
const FIELD_COUNT: usize
[src]
fn map<Func: Fn(usize) -> Ret, Ret>(
local_index: usize,
callback: Func
) -> Option<Ret>
[src]
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> 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>>,
[src]
(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
const FIELD_COUNT: usize
[src]
fn map<Func: Fn(usize) -> Ret, Ret>(
local_index: usize,
callback: Func
) -> Option<Ret>
[src]
local_index: usize,
callback: Func
) -> Option<Ret>