Struct acute_ecs::filter::ArchetypeFilterData

pub struct ArchetypeFilterData<'a> {
    pub component_types: &'a ComponentTypes,
    pub tag_types: &'a TagTypes,
}

Input data for archetype filters.

Fields

component_types: &'a ComponentTypes

The component types in each archetype.

tag_types: &'a TagTypes

The tag types in each archetype.

Trait Implementations

impl<'a> Clone for ArchetypeFilterData<'a>

fn clone(&self) -> ArchetypeFilterData<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Copy for ArchetypeFilterData<'a>

impl<'a, A, B, C> Filter<ArchetypeFilterData<'a>> for (A, B, C) where
    A: Tag,
    B: Tag,
    C: Tag, 

type Iter = SliceVecIter<'a, TagTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <(A, B, C) as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<(A, B, C) as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> Filter<ArchetypeFilterData<'a>> for ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component,
    G: Component,
    H: Component,
    I: Component,
    J: Component,
    K: Component,
    L: Component,
    M: Component,
    N: Component,
    O: Component,
    P: Component,
    Q: Component,
    R: Component,
    S: Component,
    T: Component, 

type Iter = SliceVecIter<'a, ComponentTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)> as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)> as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> Filter<ArchetypeFilterData<'a>> for ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component,
    G: Component,
    H: Component,
    I: Component,
    J: Component,
    K: Component,
    L: Component,
    M: Component,
    N: Component,
    O: Component,
    P: Component,
    Q: Component, 

type Iter = SliceVecIter<'a, ComponentTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)> as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)> as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> Filter<ArchetypeFilterData<'a>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) where
    A: Tag,
    B: Tag,
    C: Tag,
    D: Tag,
    E: Tag,
    F: Tag,
    G: Tag,
    H: Tag,
    I: Tag,
    J: Tag,
    K: Tag,
    L: Tag,
    M: Tag,
    N: Tag,
    O: Tag,
    P: Tag,
    Q: Tag, 

type Iter = SliceVecIter<'a, TagTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D> Filter<ArchetypeFilterData<'a>> for (A, B, C, D) where
    A: Tag,
    B: Tag,
    C: Tag,
    D: Tag, 

type Iter = SliceVecIter<'a, TagTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <(A, B, C, D) as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<(A, B, C, D) as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Filter<ArchetypeFilterData<'a>> for ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component,
    G: Component,
    H: Component,
    I: Component,
    J: Component,
    K: Component,
    L: Component,
    M: Component,
    N: Component,
    O: Component,
    P: Component, 

type Iter = SliceVecIter<'a, ComponentTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)> as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)> as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D, E, F, G, H, I> Filter<ArchetypeFilterData<'a>> for (A, B, C, D, E, F, G, H, I) where
    A: Tag,
    B: Tag,
    C: Tag,
    D: Tag,
    E: Tag,
    F: Tag,
    G: Tag,
    H: Tag,
    I: Tag, 

type Iter = SliceVecIter<'a, TagTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <(A, B, C, D, E, F, G, H, I) as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<(A, B, C, D, E, F, G, H, I) as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W> Filter<ArchetypeFilterData<'a>> for ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component,
    G: Component,
    H: Component,
    I: Component,
    J: Component,
    K: Component,
    L: Component,
    M: Component,
    N: Component,
    O: Component,
    P: Component,
    Q: Component,
    R: Component,
    S: Component,
    T: Component,
    U: Component,
    V: Component,
    W: Component, 

type Iter = SliceVecIter<'a, ComponentTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)> as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)> as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N> Filter<ArchetypeFilterData<'a>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    A: Tag,
    B: Tag,
    C: Tag,
    D: Tag,
    E: Tag,
    F: Tag,
    G: Tag,
    H: Tag,
    I: Tag,
    J: Tag,
    K: Tag,
    L: Tag,
    M: Tag,
    N: Tag, 

type Iter = SliceVecIter<'a, TagTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D, E, F, G, H, I, J, K> Filter<ArchetypeFilterData<'a>> for (A, B, C, D, E, F, G, H, I, J, K) where
    A: Tag,
    B: Tag,
    C: Tag,
    D: Tag,
    E: Tag,
    F: Tag,
    G: Tag,
    H: Tag,
    I: Tag,
    J: Tag,
    K: Tag, 

type Iter = SliceVecIter<'a, TagTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <(A, B, C, D, E, F, G, H, I, J, K) as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<(A, B, C, D, E, F, G, H, I, J, K) as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D, E> Filter<ArchetypeFilterData<'a>> for (A, B, C, D, E) where
    A: Tag,
    B: Tag,
    C: Tag,
    D: Tag,
    E: Tag, 

type Iter = SliceVecIter<'a, TagTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <(A, B, C, D, E) as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<(A, B, C, D, E) as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L> Filter<ArchetypeFilterData<'a>> for ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L)> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component,
    G: Component,
    H: Component,
    I: Component,
    J: Component,
    K: Component,
    L: Component, 

type Iter = SliceVecIter<'a, ComponentTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L)> as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L)> as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D, E, F, G, H, I> Filter<ArchetypeFilterData<'a>> for ComponentTupleFilter<(A, B, C, D, E, F, G, H, I)> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component,
    G: Component,
    H: Component,
    I: Component, 

type Iter = SliceVecIter<'a, ComponentTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <ComponentTupleFilter<(A, B, C, D, E, F, G, H, I)> as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<ComponentTupleFilter<(A, B, C, D, E, F, G, H, I)> as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U> Filter<ArchetypeFilterData<'a>> for ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component,
    G: Component,
    H: Component,
    I: Component,
    J: Component,
    K: Component,
    L: Component,
    M: Component,
    N: Component,
    O: Component,
    P: Component,
    Q: Component,
    R: Component,
    S: Component,
    T: Component,
    U: Component, 

type Iter = SliceVecIter<'a, ComponentTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)> as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)> as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X> Filter<ArchetypeFilterData<'a>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X) where
    A: Tag,
    B: Tag,
    C: Tag,
    D: Tag,
    E: Tag,
    F: Tag,
    G: Tag,
    H: Tag,
    I: Tag,
    J: Tag,
    K: Tag,
    L: Tag,
    M: Tag,
    N: Tag,
    O: Tag,
    P: Tag,
    Q: Tag,
    R: Tag,
    S: Tag,
    T: Tag,
    U: Tag,
    V: Tag,
    W: Tag,
    X: Tag, 

type Iter = SliceVecIter<'a, TagTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X) as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X) as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A> Filter<ArchetypeFilterData<'a>> for ComponentTupleFilter<(A,)> where
    A: Component, 

type Iter = SliceVecIter<'a, ComponentTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <ComponentTupleFilter<(A,)> as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<ComponentTupleFilter<(A,)> as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U> Filter<ArchetypeFilterData<'a>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) where
    A: Tag,
    B: Tag,
    C: Tag,
    D: Tag,
    E: Tag,
    F: Tag,
    G: Tag,
    H: Tag,
    I: Tag,
    J: Tag,
    K: Tag,
    L: Tag,
    M: Tag,
    N: Tag,
    O: Tag,
    P: Tag,
    Q: Tag,
    R: Tag,
    S: Tag,
    T: Tag,
    U: Tag, 

type Iter = SliceVecIter<'a, TagTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A> Filter<ArchetypeFilterData<'a>> for (A,) where
    A: Tag, 

type Iter = SliceVecIter<'a, TagTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <(A,) as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<(A,) as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a> Filter<ArchetypeFilterData<'a>> for ComponentTupleFilter<()>

type Iter = SliceVecIter<'a, ComponentTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <ComponentTupleFilter<()> as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<ComponentTupleFilter<()> as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M> Filter<ArchetypeFilterData<'a>> for ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M)> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component,
    G: Component,
    H: Component,
    I: Component,
    J: Component,
    K: Component,
    L: Component,
    M: Component, 

type Iter = SliceVecIter<'a, ComponentTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M)> as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M)> as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C> Filter<ArchetypeFilterData<'a>> for ComponentTupleFilter<(A, B, C)> where
    A: Component,
    B: Component,
    C: Component, 

type Iter = SliceVecIter<'a, ComponentTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <ComponentTupleFilter<(A, B, C)> as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<ComponentTupleFilter<(A, B, C)> as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R> Filter<ArchetypeFilterData<'a>> for ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component,
    G: Component,
    H: Component,
    I: Component,
    J: Component,
    K: Component,
    L: Component,
    M: Component,
    N: Component,
    O: Component,
    P: Component,
    Q: Component,
    R: Component, 

type Iter = SliceVecIter<'a, ComponentTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)> as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)> as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D, E, F, G, H, I, J, K> Filter<ArchetypeFilterData<'a>> for ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K)> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component,
    G: Component,
    H: Component,
    I: Component,
    J: Component,
    K: Component, 

type Iter = SliceVecIter<'a, ComponentTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K)> as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K)> as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D, E, F> Filter<ArchetypeFilterData<'a>> for (A, B, C, D, E, F) where
    A: Tag,
    B: Tag,
    C: Tag,
    D: Tag,
    E: Tag,
    F: Tag, 

type Iter = SliceVecIter<'a, TagTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <(A, B, C, D, E, F) as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<(A, B, C, D, E, F) as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D, E, F, G, H, I, J> Filter<ArchetypeFilterData<'a>> for ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J)> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component,
    G: Component,
    H: Component,
    I: Component,
    J: Component, 

type Iter = SliceVecIter<'a, ComponentTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J)> as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J)> as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y> Filter<ArchetypeFilterData<'a>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y) where
    A: Tag,
    B: Tag,
    C: Tag,
    D: Tag,
    E: Tag,
    F: Tag,
    G: Tag,
    H: Tag,
    I: Tag,
    J: Tag,
    K: Tag,
    L: Tag,
    M: Tag,
    N: Tag,
    O: Tag,
    P: Tag,
    Q: Tag,
    R: Tag,
    S: Tag,
    T: Tag,
    U: Tag,
    V: Tag,
    W: Tag,
    X: Tag,
    Y: Tag, 

type Iter = SliceVecIter<'a, TagTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y) as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y) as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D> Filter<ArchetypeFilterData<'a>> for ComponentTupleFilter<(A, B, C, D)> where
    A: Component,
    B: Component,
    C: Component,
    D: Component, 

type Iter = SliceVecIter<'a, ComponentTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <ComponentTupleFilter<(A, B, C, D)> as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<ComponentTupleFilter<(A, B, C, D)> as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, T> Filter<ArchetypeFilterData<'a>> for ComponentFilter<T> where
    T: Component, 

type Iter = SliceVecIter<'a, ComponentTypeId>

fn init(&self)

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <ComponentFilter<T> as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<ComponentFilter<T> as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L> Filter<ArchetypeFilterData<'a>> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    A: Tag,
    B: Tag,
    C: Tag,
    D: Tag,
    E: Tag,
    F: Tag,
    G: Tag,
    H: Tag,
    I: Tag,
    J: Tag,
    K: Tag,
    L: Tag, 

type Iter = SliceVecIter<'a, TagTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <(A, B, C, D, E, F, G, H, I, J, K, L) as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<(A, B, C, D, E, F, G, H, I, J, K, L) as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> Filter<ArchetypeFilterData<'a>> for ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component,
    G: Component,
    H: Component,
    I: Component,
    J: Component,
    K: Component,
    L: Component,
    M: Component,
    N: Component,
    O: Component, 

type Iter = SliceVecIter<'a, ComponentTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)> as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)> as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S> Filter<ArchetypeFilterData<'a>> for ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component,
    G: Component,
    H: Component,
    I: Component,
    J: Component,
    K: Component,
    L: Component,
    M: Component,
    N: Component,
    O: Component,
    P: Component,
    Q: Component,
    R: Component,
    S: Component, 

type Iter = SliceVecIter<'a, ComponentTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)> as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)> as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> Filter<ArchetypeFilterData<'a>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) where
    A: Tag,
    B: Tag,
    C: Tag,
    D: Tag,
    E: Tag,
    F: Tag,
    G: Tag,
    H: Tag,
    I: Tag,
    J: Tag,
    K: Tag,
    L: Tag,
    M: Tag,
    N: Tag,
    O: Tag,
    P: Tag,
    Q: Tag,
    R: Tag,
    S: Tag,
    T: Tag, 

type Iter = SliceVecIter<'a, TagTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D, E> Filter<ArchetypeFilterData<'a>> for ComponentTupleFilter<(A, B, C, D, E)> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component, 

type Iter = SliceVecIter<'a, ComponentTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <ComponentTupleFilter<(A, B, C, D, E)> as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<ComponentTupleFilter<(A, B, C, D, E)> as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V> Filter<ArchetypeFilterData<'a>> for ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component,
    G: Component,
    H: Component,
    I: Component,
    J: Component,
    K: Component,
    L: Component,
    M: Component,
    N: Component,
    O: Component,
    P: Component,
    Q: Component,
    R: Component,
    S: Component,
    T: Component,
    U: Component,
    V: Component, 

type Iter = SliceVecIter<'a, ComponentTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)> as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)> as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W> Filter<ArchetypeFilterData<'a>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W) where
    A: Tag,
    B: Tag,
    C: Tag,
    D: Tag,
    E: Tag,
    F: Tag,
    G: Tag,
    H: Tag,
    I: Tag,
    J: Tag,
    K: Tag,
    L: Tag,
    M: Tag,
    N: Tag,
    O: Tag,
    P: Tag,
    Q: Tag,
    R: Tag,
    S: Tag,
    T: Tag,
    U: Tag,
    V: Tag,
    W: Tag, 

type Iter = SliceVecIter<'a, TagTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W) as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W) as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D, E, F, G, H, I, J> Filter<ArchetypeFilterData<'a>> for (A, B, C, D, E, F, G, H, I, J) where
    A: Tag,
    B: Tag,
    C: Tag,
    D: Tag,
    E: Tag,
    F: Tag,
    G: Tag,
    H: Tag,
    I: Tag,
    J: Tag, 

type Iter = SliceVecIter<'a, TagTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <(A, B, C, D, E, F, G, H, I, J) as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<(A, B, C, D, E, F, G, H, I, J) as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y> Filter<ArchetypeFilterData<'a>> for ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component,
    G: Component,
    H: Component,
    I: Component,
    J: Component,
    K: Component,
    L: Component,
    M: Component,
    N: Component,
    O: Component,
    P: Component,
    Q: Component,
    R: Component,
    S: Component,
    T: Component,
    U: Component,
    V: Component,
    W: Component,
    X: Component,
    Y: Component, 

type Iter = SliceVecIter<'a, ComponentTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)> as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)> as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a> Filter<ArchetypeFilterData<'a>> for Passthrough

type Iter = Take<Repeat<()>>

fn init(&self)

fn collect(
    &self,
    arch: ArchetypeFilterData<'a>
) -> <Passthrough as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    &<<Passthrough as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M> Filter<ArchetypeFilterData<'a>> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    A: Tag,
    B: Tag,
    C: Tag,
    D: Tag,
    E: Tag,
    F: Tag,
    G: Tag,
    H: Tag,
    I: Tag,
    J: Tag,
    K: Tag,
    L: Tag,
    M: Tag, 

type Iter = SliceVecIter<'a, TagTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M) as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<(A, B, C, D, E, F, G, H, I, J, K, L, M) as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V> Filter<ArchetypeFilterData<'a>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) where
    A: Tag,
    B: Tag,
    C: Tag,
    D: Tag,
    E: Tag,
    F: Tag,
    G: Tag,
    H: Tag,
    I: Tag,
    J: Tag,
    K: Tag,
    L: Tag,
    M: Tag,
    N: Tag,
    O: Tag,
    P: Tag,
    Q: Tag,
    R: Tag,
    S: Tag,
    T: Tag,
    U: Tag,
    V: Tag, 

type Iter = SliceVecIter<'a, TagTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D, E, F, G> Filter<ArchetypeFilterData<'a>> for (A, B, C, D, E, F, G) where
    A: Tag,
    B: Tag,
    C: Tag,
    D: Tag,
    E: Tag,
    F: Tag,
    G: Tag, 

type Iter = SliceVecIter<'a, TagTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <(A, B, C, D, E, F, G) as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<(A, B, C, D, E, F, G) as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B> Filter<ArchetypeFilterData<'a>> for (A, B) where
    A: Tag,
    B: Tag, 

type Iter = SliceVecIter<'a, TagTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <(A, B) as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<(A, B) as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D, E, F, G, H> Filter<ArchetypeFilterData<'a>> for ComponentTupleFilter<(A, B, C, D, E, F, G, H)> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component,
    G: Component,
    H: Component, 

type Iter = SliceVecIter<'a, ComponentTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <ComponentTupleFilter<(A, B, C, D, E, F, G, H)> as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<ComponentTupleFilter<(A, B, C, D, E, F, G, H)> as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D, E, F, G, H> Filter<ArchetypeFilterData<'a>> for (A, B, C, D, E, F, G, H) where
    A: Tag,
    B: Tag,
    C: Tag,
    D: Tag,
    E: Tag,
    F: Tag,
    G: Tag,
    H: Tag, 

type Iter = SliceVecIter<'a, TagTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <(A, B, C, D, E, F, G, H) as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<(A, B, C, D, E, F, G, H) as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R> Filter<ArchetypeFilterData<'a>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) where
    A: Tag,
    B: Tag,
    C: Tag,
    D: Tag,
    E: Tag,
    F: Tag,
    G: Tag,
    H: Tag,
    I: Tag,
    J: Tag,
    K: Tag,
    L: Tag,
    M: Tag,
    N: Tag,
    O: Tag,
    P: Tag,
    Q: Tag,
    R: Tag, 

type Iter = SliceVecIter<'a, TagTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, T> Filter<ArchetypeFilterData<'a>> for TagFilter<T> where
    T: Tag, 

type Iter = SliceVecIter<'a, TagTypeId>

fn init(&self)

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <TagFilter<T> as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<TagFilter<T> as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

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

type Iter = SliceVecIter<'a, TagTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a> Filter<ArchetypeFilterData<'a>> for ()

type Iter = SliceVecIter<'a, TagTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <() as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<() as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N> Filter<ArchetypeFilterData<'a>> for ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N)> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component,
    G: Component,
    H: Component,
    I: Component,
    J: Component,
    K: Component,
    L: Component,
    M: Component,
    N: Component, 

type Iter = SliceVecIter<'a, ComponentTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N)> as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N)> as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D, E, F, G> Filter<ArchetypeFilterData<'a>> for ComponentTupleFilter<(A, B, C, D, E, F, G)> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component,
    G: Component, 

type Iter = SliceVecIter<'a, ComponentTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <ComponentTupleFilter<(A, B, C, D, E, F, G)> as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<ComponentTupleFilter<(A, B, C, D, E, F, G)> as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a> Filter<ArchetypeFilterData<'a>> for Any

type Iter = Take<Repeat<()>>

fn init(&self)

fn collect(
    &self,
    arch: ArchetypeFilterData<'a>
) -> <Any as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    &<<Any as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

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

type Iter = SliceVecIter<'a, TagTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S> Filter<ArchetypeFilterData<'a>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) where
    A: Tag,
    B: Tag,
    C: Tag,
    D: Tag,
    E: Tag,
    F: Tag,
    G: Tag,
    H: Tag,
    I: Tag,
    J: Tag,
    K: Tag,
    L: Tag,
    M: Tag,
    N: Tag,
    O: Tag,
    P: Tag,
    Q: Tag,
    R: Tag,
    S: Tag, 

type Iter = SliceVecIter<'a, TagTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> Filter<ArchetypeFilterData<'a>> for ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component,
    G: Component,
    H: Component,
    I: Component,
    J: Component,
    K: Component,
    L: Component,
    M: Component,
    N: Component,
    O: Component,
    P: Component,
    Q: Component,
    R: Component,
    S: Component,
    T: Component,
    U: Component,
    V: Component,
    W: Component,
    X: Component,
    Y: Component,
    Z: Component, 

type Iter = SliceVecIter<'a, ComponentTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)> as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)> as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X> Filter<ArchetypeFilterData<'a>> for ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component,
    G: Component,
    H: Component,
    I: Component,
    J: Component,
    K: Component,
    L: Component,
    M: Component,
    N: Component,
    O: Component,
    P: Component,
    Q: Component,
    R: Component,
    S: Component,
    T: Component,
    U: Component,
    V: Component,
    W: Component,
    X: Component, 

type Iter = SliceVecIter<'a, ComponentTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)> as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<ComponentTupleFilter<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)> as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> Filter<ArchetypeFilterData<'a>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) where
    A: Tag,
    B: Tag,
    C: Tag,
    D: Tag,
    E: Tag,
    F: Tag,
    G: Tag,
    H: Tag,
    I: Tag,
    J: Tag,
    K: Tag,
    L: Tag,
    M: Tag,
    N: Tag,
    O: Tag,
    P: Tag,
    Q: Tag,
    R: Tag,
    S: Tag,
    T: Tag,
    U: Tag,
    V: Tag,
    W: Tag,
    X: Tag,
    Y: Tag,
    Z: Tag, 

type Iter = SliceVecIter<'a, TagTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B> Filter<ArchetypeFilterData<'a>> for ComponentTupleFilter<(A, B)> where
    A: Component,
    B: Component, 

type Iter = SliceVecIter<'a, ComponentTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <ComponentTupleFilter<(A, B)> as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<ComponentTupleFilter<(A, B)> as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a> Filter<ArchetypeFilterData<'a>> for ArchetypeDescription

type Iter = FissileZip<SliceVecIter<'a, TagTypeId>, SliceVecIter<'a, ComponentTypeId>>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <ArchetypeDescription as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    &<<ArchetypeDescription as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.

impl<'a, A, B, C, D, E, F> Filter<ArchetypeFilterData<'a>> for ComponentTupleFilter<(A, B, C, D, E, F)> where
    A: Component,
    B: Component,
    C: Component,
    D: Component,
    E: Component,
    F: Component, 

type Iter = SliceVecIter<'a, ComponentTypeId>

fn collect(
    &self,
    source: ArchetypeFilterData<'a>
) -> <ComponentTupleFilter<(A, B, C, D, E, F)> as Filter<ArchetypeFilterData<'a>>>::Iter

Pulls iterator data out of the source.

fn is_match(
    &self,
    item: &<<ComponentTupleFilter<(A, B, C, D, E, F)> as Filter<ArchetypeFilterData<'a>>>::Iter as Iterator>::Item
) -> Option<bool>

Determines if an element of Self::Iter matches the filter conditions.

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>

Creates an iterator which yields bools for each element in the source which indicate if the element matches the filter.