Trait oxygengine_core::ecs::pipeline::Query

pub trait Query { }

A collection of component types to fetch from a World

Implementations on Foreign Types

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

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

impl Query for ()

type Fetch = ()

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

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

impl<T> Query for Option<T> where
    T: Query, 

type Fetch = TryFetch<<T as Query>::Fetch>

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

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

impl<A> Query for (A,) where
    A: Query, 

type Fetch = (<A as Query>::Fetch,)

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

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

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

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

impl<B, A> Query for (B, A) where
    B: Query,
    A: Query, 

type Fetch = (<B as Query>::Fetch, <A as Query>::Fetch)

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

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

impl<'a, T> Query for &'a T where
    T: Component, 

type Fetch = FetchRead<T>

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

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

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

type Fetch = (<E as Query>::Fetch, <D as Query>::Fetch, <C as Query>::Fetch, <B as Query>::Fetch, <A as Query>::Fetch)

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

type Fetch = (<F as Query>::Fetch, <E as Query>::Fetch, <D as Query>::Fetch, <C as Query>::Fetch, <B as Query>::Fetch, <A as Query>::Fetch)

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

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

impl<'a, T> Query for &'a mut T where
    T: Component, 

type Fetch = FetchWrite<T>

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

type Fetch = (<D as Query>::Fetch, <C as Query>::Fetch, <B as Query>::Fetch, <A as Query>::Fetch)

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

type Fetch = (<C as Query>::Fetch, <B as Query>::Fetch, <A as Query>::Fetch)

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

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

Implementors

impl<L, R> Query for Or<L, R> where
    L: Query,
    R: Query, 

type Fetch = FetchOr<<L as Query>::Fetch, <R as Query>::Fetch>

impl<Q> Query for Satisfies<Q> where
    Q: Query, 

type Fetch = FetchSatisfies<<Q as Query>::Fetch>

impl<T, Q> Query for With<T, Q> where
    T: Component,
    Q: Query, 

type Fetch = FetchWith<T, <Q as Query>::Fetch>

impl<T, Q> Query for Without<T, Q> where
    T: Component,
    Q: Query, 

type Fetch = FetchWithout<T, <Q as Query>::Fetch>