Trait oxygengine::prelude::ResQuery

pub trait ResQuery {
    type Fetch: ResAccess;

    // Required method
    fn fetch(universe: &Universe) -> Self::Fetch;
}

Required Associated Types

type Fetch: ResAccess

Required Methods

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

Implementations on Foreign Types

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

type Fetch = ResWrite<T>

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

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

type Fetch = Option<ResWrite<T>>

fn fetch(universe: &Universe) -> <Option<&mut T> 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)

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> 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)

fn fetch( universe: &Universe ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M) 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)

fn fetch(universe: &Universe) -> <(A, B, C, D, E) 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)

fn fetch(universe: &Universe) -> <(A, B, C, D, E, F, G, H) 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)

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

impl ResQuery for ()

type Fetch = ()

fn fetch(_: &Universe) -> <() 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)

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, 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)

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)

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

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)

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

impl<T> ResQuery for &Twhere T: 'static,

type Fetch = ResRead<T>

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)

fn fetch(universe: &Universe) -> <(A, B, C, D) 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)

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> 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)

fn fetch( universe: &Universe ) -> <(A, B, C, D, E, F, G, H, I, J, K) 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)

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

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

type Fetch = Option<ResRead<T>>

fn fetch(universe: &Universe) -> <Option<&T> 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)

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

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

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

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

Implementors

impl ResQuery for WorldRef

type Fetch = RefRead<World>

impl<T> ResQuery for Comp<T>

type Fetch = ()