Trait bevy::ecs::EntityFilter

pub trait EntityFilter {
    pub const DANGLING: Self;

    pub unsafe fn matches_entity(&self, _offset: usize) -> bool;
}

Associated Constants

pub const DANGLING: Self

Loading content...

Required methods

pub unsafe fn matches_entity(&self, _offset: usize) -> bool

Safety

This might access archetype data in an unsafe manner. In general filters should be read-only and they should only access the data they have claimed in access().

Loading content...

Implementations on Foreign Types

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

pub const DANGLING: (A, B, C, D, E, F, G, H, I, J, K)

pub unsafe fn matches_entity(&self, offset: usize) -> bool

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

pub const DANGLING: (A, B, C, D, E)

pub unsafe fn matches_entity(&self, offset: usize) -> bool

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

pub const DANGLING: (A, B, C, D, E, F, G, H, I, J, K, L)

pub unsafe fn matches_entity(&self, offset: usize) -> bool

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

pub const DANGLING: (A, B, C, D, E, F, G, H, I)

pub unsafe fn matches_entity(&self, offset: usize) -> bool

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

pub const DANGLING: (A, B, C, D, E, F, G)

pub unsafe fn matches_entity(&self, offset: usize) -> bool

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

pub const DANGLING: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)

pub unsafe fn matches_entity(&self, offset: usize) -> bool

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

pub const DANGLING: (A,)

pub unsafe fn matches_entity(&self, offset: usize) -> bool

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

pub const DANGLING: (A, B, C, D, E, F, G, H, I, J)

pub unsafe fn matches_entity(&self, offset: usize) -> bool

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

pub const DANGLING: (A, B, C, D, E, F)

pub unsafe fn matches_entity(&self, offset: usize) -> bool

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

pub const DANGLING: (A, B, C, D)

pub unsafe fn matches_entity(&self, offset: usize) -> bool

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

pub const DANGLING: (A, B, C)

pub unsafe fn matches_entity(&self, offset: usize) -> bool

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

pub const DANGLING: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)

pub unsafe fn matches_entity(&self, offset: usize) -> bool

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

pub const DANGLING: (A, B)

pub unsafe fn matches_entity(&self, offset: usize) -> bool

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

pub const DANGLING: (A, B, C, D, E, F, G, H)

pub unsafe fn matches_entity(&self, offset: usize) -> bool

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

pub const DANGLING: (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

pub unsafe fn matches_entity(&self, offset: usize) -> bool

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

pub const DANGLING: (A, B, C, D, E, F, G, H, I, J, K, L, M)

pub unsafe fn matches_entity(&self, offset: usize) -> bool

Loading content...

Implementors

impl<A> EntityFilter for Or<(Option<A>,)> where
    A: EntityFilter, 

pub const DANGLING: Or<(Option<A>,)>

pub unsafe fn matches_entity(&self, offset: usize) -> bool

impl<A, B> EntityFilter for Or<(Option<A>, Option<B>)> where
    B: EntityFilter,
    A: EntityFilter, 

pub const DANGLING: Or<(Option<A>, Option<B>)>

pub unsafe fn matches_entity(&self, offset: usize) -> bool

impl<A, B, C> EntityFilter for Or<(Option<A>, Option<B>, Option<C>)> where
    C: EntityFilter,
    B: EntityFilter,
    A: EntityFilter, 

pub const DANGLING: Or<(Option<A>, Option<B>, Option<C>)>

pub unsafe fn matches_entity(&self, offset: usize) -> bool

impl<A, B, C, D> EntityFilter for Or<(Option<A>, Option<B>, Option<C>, Option<D>)> where
    C: EntityFilter,
    B: EntityFilter,
    A: EntityFilter,
    D: EntityFilter, 

pub const DANGLING: Or<(Option<A>, Option<B>, Option<C>, Option<D>)>

pub unsafe fn matches_entity(&self, offset: usize) -> bool

impl<A, B, C, D, E> EntityFilter for Or<(Option<A>, Option<B>, Option<C>, Option<D>, Option<E>)> where
    C: EntityFilter,
    E: EntityFilter,
    B: EntityFilter,
    A: EntityFilter,
    D: EntityFilter, 

pub const DANGLING: Or<(Option<A>, Option<B>, Option<C>, Option<D>, Option<E>)>

pub unsafe fn matches_entity(&self, offset: usize) -> bool

impl<A, B, C, D, E, F> EntityFilter for Or<(Option<A>, Option<B>, Option<C>, Option<D>, Option<E>, Option<F>)> where
    C: EntityFilter,
    E: EntityFilter,
    B: EntityFilter,
    A: EntityFilter,
    D: EntityFilter,
    F: EntityFilter, 

pub const DANGLING: Or<(Option<A>, Option<B>, Option<C>, Option<D>, Option<E>, Option<F>)>

pub unsafe fn matches_entity(&self, offset: usize) -> bool

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

pub const DANGLING: Or<(Option<A>, Option<B>, Option<C>, Option<D>, Option<E>, Option<F>, Option<G>)>

pub unsafe fn matches_entity(&self, offset: usize) -> bool

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

pub const DANGLING: Or<(Option<A>, Option<B>, Option<C>, Option<D>, Option<E>, Option<F>, Option<G>, Option<H>)>

pub unsafe fn matches_entity(&self, offset: usize) -> bool

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

pub const DANGLING: Or<(Option<A>, Option<B>, Option<C>, Option<D>, Option<E>, Option<F>, Option<G>, Option<H>, Option<I>)>

pub unsafe fn matches_entity(&self, offset: usize) -> bool

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

pub const DANGLING: Or<(Option<A>, Option<B>, Option<C>, Option<D>, Option<E>, Option<F>, Option<G>, Option<H>, Option<I>, Option<J>)>

pub unsafe fn matches_entity(&self, offset: usize) -> bool

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

pub const DANGLING: Or<(Option<A>, Option<B>, Option<C>, Option<D>, Option<E>, Option<F>, Option<G>, Option<H>, Option<I>, Option<J>, Option<K>)>

pub unsafe fn matches_entity(&self, offset: usize) -> bool

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

pub const DANGLING: Or<(Option<A>, Option<B>, Option<C>, Option<D>, Option<E>, Option<F>, Option<G>, Option<H>, Option<I>, Option<J>, Option<K>, Option<L>)>

pub unsafe fn matches_entity(&self, offset: usize) -> bool

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

pub const DANGLING: Or<(Option<A>, Option<B>, Option<C>, Option<D>, Option<E>, Option<F>, Option<G>, Option<H>, Option<I>, Option<J>, Option<K>, Option<L>, Option<M>)>

pub unsafe fn matches_entity(&self, offset: usize) -> bool

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

pub const DANGLING: Or<(Option<A>, Option<B>, Option<C>, Option<D>, Option<E>, Option<F>, Option<G>, Option<H>, Option<I>, Option<J>, Option<K>, Option<L>, Option<M>, Option<N>)>

pub unsafe fn matches_entity(&self, offset: usize) -> bool

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

pub const DANGLING: Or<(Option<A>, Option<B>, Option<C>, Option<D>, Option<E>, Option<F>, Option<G>, Option<H>, Option<I>, Option<J>, Option<K>, Option<L>, Option<M>, Option<N>, Option<O>)>

pub unsafe fn matches_entity(&self, offset: usize) -> bool

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

pub const DANGLING: Or<(Option<A>, Option<B>, Option<C>, Option<D>, Option<E>, Option<F>, Option<G>, Option<H>, Option<I>, Option<J>, Option<K>, Option<L>, Option<M>, Option<N>, Option<O>, Option<P>)>

pub unsafe fn matches_entity(&self, offset: usize) -> bool

impl<T> EntityFilter for Added<T> where
    T: Component, 

pub const DANGLING: Added<T>

pub unsafe fn matches_entity(&self, offset: usize) -> bool

impl<T> EntityFilter for Changed<T> where
    T: Component, 

pub const DANGLING: Changed<T>

pub unsafe fn matches_entity(&self, offset: usize) -> bool

impl<T> EntityFilter for Mutated<T> where
    T: Component, 

pub const DANGLING: Mutated<T>

pub unsafe fn matches_entity(&self, offset: usize) -> bool

Loading content...