[][src]Trait bevy_ecs::HecsQuery

pub trait HecsQuery { }

A collection of component types to fetch from a World

Implementations on Foreign Types

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

type 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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    G: Query
[src]

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<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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    G: Query,
    H: Query,
    I: Query,
    J: Query,
    K: Query,
    L: Query,
    M: Query,
    N: Query,
    O: Query
[src]

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<J, I, H, G, F, E, D, C, B, A> Query for (J, I, H, G, F, E, D, C, B, A) where
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    G: Query,
    H: Query,
    I: Query,
    J: Query
[src]

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 Query for ()[src]

type Fetch = ()

impl<T> Query for Option<T> where
    T: Query
[src]

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

impl<A> Query for (A,) where
    A: Query
[src]

type Fetch = (<A as Query>::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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    G: Query,
    H: Query,
    I: Query,
    J: Query,
    K: Query,
    L: Query
[src]

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<'a, T> Query for &'a T where
    T: Component
[src]

type Fetch = FetchRead<T>

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    G: Query,
    H: Query,
    I: Query,
    J: Query,
    K: Query,
    L: Query,
    M: Query
[src]

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)

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

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<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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    G: Query,
    H: Query,
    I: Query,
    J: Query,
    K: Query,
    L: Query,
    M: Query,
    N: Query
[src]

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<I, H, G, F, E, D, C, B, A> Query for (I, H, G, F, E, D, C, B, A) where
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    G: Query,
    H: Query,
    I: Query
[src]

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<C, B, A> Query for (C, B, A) where
    A: Query,
    B: Query,
    C: Query
[src]

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

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

type 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
[src]

type Fetch = FetchMut<T>

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

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<B, A> Query for (B, A) where
    A: Query,
    B: Query
[src]

type Fetch = (<B as Query>::Fetch, <A 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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    G: Query,
    H: Query,
    I: Query,
    J: Query,
    K: Query
[src]

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)

Loading content...

Implementors

impl Query for Entity[src]

type Fetch = EntityFetch

impl<'a, T> Query for Added<'a, T> where
    T: Component
[src]

type Fetch = FetchAdded<T>

impl<'a, T> Query for Changed<'a, T> where
    T: Component
[src]

type Fetch = FetchChanged<T>

impl<'a, T> Query for Mut<'a, T> where
    T: Component
[src]

type Fetch = FetchMut<T>

impl<'a, T> Query for Mutated<'a, T> where
    T: Component
[src]

type Fetch = FetchMutated<T>

impl<Q1, Q2> Query for Or<(Q1, Q2)> where
    Q1: Query,
    Q2: Query
[src]

type Fetch = FetchOr<(<Q1 as Query>::Fetch, <Q2 as Query>::Fetch)>

impl<Q1, Q2, Q3> Query for Or<(Q1, Q2, Q3)> where
    Q1: Query,
    Q2: Query,
    Q3: Query
[src]

type Fetch = FetchOr<(<Q1 as Query>::Fetch, <Q2 as Query>::Fetch, <Q3 as Query>::Fetch)>

impl<Q1, Q2, Q3, Q4> Query for Or<(Q1, Q2, Q3, Q4)> where
    Q1: Query,
    Q2: Query,
    Q3: Query,
    Q4: Query
[src]

type Fetch = FetchOr<(<Q1 as Query>::Fetch, <Q2 as Query>::Fetch, <Q3 as Query>::Fetch, <Q4 as Query>::Fetch)>

impl<Q1, Q2, Q3, Q4, Q5> Query for Or<(Q1, Q2, Q3, Q4, Q5)> where
    Q1: Query,
    Q2: Query,
    Q3: Query,
    Q4: Query,
    Q5: Query
[src]

type Fetch = FetchOr<(<Q1 as Query>::Fetch, <Q2 as Query>::Fetch, <Q3 as Query>::Fetch, <Q4 as Query>::Fetch, <Q5 as Query>::Fetch)>

impl<Q1, Q2, Q3, Q4, Q5, Q6> Query for Or<(Q1, Q2, Q3, Q4, Q5, Q6)> where
    Q1: Query,
    Q2: Query,
    Q3: Query,
    Q4: Query,
    Q5: Query,
    Q6: Query
[src]

type Fetch = FetchOr<(<Q1 as Query>::Fetch, <Q2 as Query>::Fetch, <Q3 as Query>::Fetch, <Q4 as Query>::Fetch, <Q5 as Query>::Fetch, <Q6 as Query>::Fetch)>

impl<Q1, Q2, Q3, Q4, Q5, Q6, Q7> Query for Or<(Q1, Q2, Q3, Q4, Q5, Q6, Q7)> where
    Q1: Query,
    Q2: Query,
    Q3: Query,
    Q4: Query,
    Q5: Query,
    Q6: Query,
    Q7: Query
[src]

type Fetch = FetchOr<(<Q1 as Query>::Fetch, <Q2 as Query>::Fetch, <Q3 as Query>::Fetch, <Q4 as Query>::Fetch, <Q5 as Query>::Fetch, <Q6 as Query>::Fetch, <Q7 as Query>::Fetch)>

impl<Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8> Query for Or<(Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8)> where
    Q1: Query,
    Q2: Query,
    Q3: Query,
    Q4: Query,
    Q5: Query,
    Q6: Query,
    Q7: Query,
    Q8: Query
[src]

type Fetch = FetchOr<(<Q1 as Query>::Fetch, <Q2 as Query>::Fetch, <Q3 as Query>::Fetch, <Q4 as Query>::Fetch, <Q5 as Query>::Fetch, <Q6 as Query>::Fetch, <Q7 as Query>::Fetch, <Q8 as Query>::Fetch)>

impl<Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8, Q9> Query for Or<(Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8, Q9)> where
    Q1: Query,
    Q2: Query,
    Q3: Query,
    Q4: Query,
    Q5: Query,
    Q6: Query,
    Q7: Query,
    Q8: Query,
    Q9: Query
[src]

type Fetch = FetchOr<(<Q1 as Query>::Fetch, <Q2 as Query>::Fetch, <Q3 as Query>::Fetch, <Q4 as Query>::Fetch, <Q5 as Query>::Fetch, <Q6 as Query>::Fetch, <Q7 as Query>::Fetch, <Q8 as Query>::Fetch, <Q9 as Query>::Fetch)>

impl<Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8, Q9, Q10> Query for Or<(Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8, Q9, Q10)> where
    Q1: Query,
    Q10: Query,
    Q2: Query,
    Q3: Query,
    Q4: Query,
    Q5: Query,
    Q6: Query,
    Q7: Query,
    Q8: Query,
    Q9: Query
[src]

type Fetch = FetchOr<(<Q1 as Query>::Fetch, <Q2 as Query>::Fetch, <Q3 as Query>::Fetch, <Q4 as Query>::Fetch, <Q5 as Query>::Fetch, <Q6 as Query>::Fetch, <Q7 as Query>::Fetch, <Q8 as Query>::Fetch, <Q9 as Query>::Fetch, <Q10 as Query>::Fetch)>

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

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

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

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

Loading content...