Trait oxygengine::core::ecs::ResQuery

pub trait ResQuery {
    type Fetch: ResAccess;
    fn fetch(universe: &Universe) -> Self::Fetch;
}

Associated Types

type Fetch: ResAccess

Required methods

fn fetch(universe: &Universe) -> Self::Fetch

Implementations on Foreign Types

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

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

pub fn fetch(
    universe: &Universe
) -> <(A, B, C, D, E, F, G, H, I, J, K, L) as ResQuery>::Fetch

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

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

pub fn fetch(
    universe: &Universe
) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as ResQuery>::Fetch

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

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

pub fn fetch(universe: &Universe) -> <(A, B) as ResQuery>::Fetch

impl<'_, T> ResQuery for &'_ T where
    T: 'static, 

type Fetch = ResRead<T>

pub fn fetch(universe: &Universe) -> <&'_ T as ResQuery>::Fetch

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

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

pub fn fetch(universe: &Universe) -> <(A, B, C, D) as ResQuery>::Fetch

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

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

pub fn fetch(universe: &Universe) -> <(A, B, C, D, E) as ResQuery>::Fetch

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

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

pub fn fetch(universe: &Universe) -> <(A, B, C) as ResQuery>::Fetch

impl<'_, T> ResQuery for &'_ mut T where
    T: 'static, 

type Fetch = ResWrite<T>

pub fn fetch(universe: &Universe) -> <&'_ mut T as ResQuery>::Fetch

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

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

pub fn fetch(
    universe: &Universe
) -> <(A, B, C, D, E, F, G, H) as ResQuery>::Fetch

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

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

pub fn fetch(
    universe: &Universe
) -> <(A, B, C, D, E, F, G, H, I, J) as ResQuery>::Fetch

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

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

pub fn fetch(
    universe: &Universe
) -> <(A, B, C, D, E, F, G, H, I, J, K) as ResQuery>::Fetch

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

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

pub fn fetch(universe: &Universe) -> <(A,) as ResQuery>::Fetch

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

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

pub fn fetch(universe: &Universe) -> <(A, B, C, D, E, F, G) as ResQuery>::Fetch

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

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

pub fn fetch(
    universe: &Universe
) -> <(A, B, C, D, E, F, G, H, I) as ResQuery>::Fetch

impl<'_, T> ResQuery for Option<&'_ mut T> where
    T: 'static, 

type Fetch = Option<ResWrite<T>>

pub fn fetch(universe: &Universe) -> <Option<&'_ mut T> as ResQuery>::Fetch

impl<'_, T> ResQuery for Option<&'_ T> where
    T: 'static, 

type Fetch = Option<ResRead<T>>

pub fn fetch(universe: &Universe) -> <Option<&'_ T> as ResQuery>::Fetch

impl ResQuery for ()

type Fetch = ()

pub fn fetch(&Universe) -> <() as ResQuery>::Fetch

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

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

pub fn fetch(universe: &Universe) -> <(A, B, C, D, E, F) as ResQuery>::Fetch

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

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

pub fn fetch(
    universe: &Universe
) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as ResQuery>::Fetch

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

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

pub fn fetch(
    universe: &Universe
) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M) as ResQuery>::Fetch

Implementors

impl ResQuery for WorldMut

type Fetch = RefWrite<World>

impl ResQuery for WorldRef

type Fetch = RefRead<World>

impl<T> ResQuery for Comp<T>

type Fetch = ()