Trait 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

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl ResQuery for ()

type Fetch = ()

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

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> 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<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> 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> 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> 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<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, 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, 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> 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, 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<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, 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, 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<T> ResQuery for Option<&T>

where T: 'static,

type Fetch = Option<ResRead<T>>

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

where T: 'static,

type Fetch = ResRead<T>

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

impl<T> ResQuery for &mut T

where T: 'static,

type Fetch = ResWrite<T>

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

Implementors

impl ResQuery for WorldRef

type Fetch = RefRead<World>

impl<T> ResQuery for Comp<T>

type Fetch = ()