[−]Trait acute_ecs::filter::Filter

pub trait Filter<T>: Send + Sync where
    T: Copy, {
    type Iter: Send + Sync + Iterator;
    fn collect(&self, source: T) -> Self::Iter;
    fn is_match(&self, item: &<Self::Iter as Iterator>::Item) -> Option<bool>;

    fn init(&self) { ... }
    fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>ⓘNotable traits for FilterIter<'a, F, T>
impl<'a, F, T> Iterator for FilterIter<'a, F, T> where
    F: Filter<T>,
    T: Copy,     type Item = bool; { ... }
}

A streaming iterator of bools.

Associated Types

`type Iter: Send + Sync + Iterator`

Loading content...

Required methods

`fn collect(&self, source: T) -> Self::Iter`

Pulls iterator data out of the source.

`fn is_match(&self, item: &<Self::Iter as Iterator>::Item) -> Option<bool>`

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

Loading content...

Provided methods

`fn init(&self)`

`fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>ⓘNotable traits for FilterIter<'a, F, T> impl<'a, F, T> Iterator for FilterIter<'a, F, T> where F: Filter<T>, T: Copy, type Item = bool;`

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

Loading content...

Implementations on Foreign Types

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

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

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

`type Iter = Zip<(Iter<'a, A>, Iter<'a, B>, Iter<'a, C>)>`

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

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

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

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

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`

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

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<ChunksetFilterData<'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 = Zip<(Iter<'a, A>, Iter<'a, B>, Iter<'a, C>, Iter<'a, D>, Iter<'a, E>, Iter<'a, F>, Iter<'a, G>, Iter<'a, H>, Iter<'a, I>, Iter<'a, J>, Iter<'a, K>, Iter<'a, L>, Iter<'a, M>, Iter<'a, N>, Iter<'a, O>, Iter<'a, P>, Iter<'a, Q>, Iter<'a, R>, Iter<'a, S>, Iter<'a, T>, Iter<'a, U>, Iter<'a, V>)>`

`fn collect( &self, source: ChunksetFilterData<'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<ChunksetFilterData<'a>>>::Iter`

`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<ChunksetFilterData<'a>>>::Iter as Iterator>::Item ) -> Option<bool>`

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<ChunksetFilterData<'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 = Zip<(Iter<'a, A>, Iter<'a, B>, Iter<'a, C>, Iter<'a, D>, Iter<'a, E>, Iter<'a, F>, Iter<'a, G>, Iter<'a, H>, Iter<'a, I>, Iter<'a, J>, Iter<'a, K>, Iter<'a, L>, Iter<'a, M>, Iter<'a, N>, Iter<'a, O>, Iter<'a, P>, Iter<'a, Q>, Iter<'a, R>, Iter<'a, S>, Iter<'a, T>, Iter<'a, U>, Iter<'a, V>, Iter<'a, W>)>`

`fn collect( &self, source: ChunksetFilterData<'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<ChunksetFilterData<'a>>>::Iter`

`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<ChunksetFilterData<'a>>>::Iter as Iterator>::Item ) -> Option<bool>`

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`

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

`impl<'a> Filter<ChunksetFilterData<'a>> for ()`

`type Iter = Take<Repeat<()>>`

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

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

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

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

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

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

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

`type Iter = Zip<(Iter<'a, A>,)>`

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

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

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

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

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

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

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<ChunksetFilterData<'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 = Zip<(Iter<'a, A>, Iter<'a, B>, Iter<'a, C>, Iter<'a, D>, Iter<'a, E>, Iter<'a, F>, Iter<'a, G>, Iter<'a, H>, Iter<'a, I>, Iter<'a, J>, Iter<'a, K>, Iter<'a, L>, Iter<'a, M>, Iter<'a, N>, Iter<'a, O>, Iter<'a, P>, Iter<'a, Q>, Iter<'a, R>, Iter<'a, S>, Iter<'a, T>, Iter<'a, U>, Iter<'a, V>, Iter<'a, W>, Iter<'a, X>, Iter<'a, Y>, Iter<'a, Z>)>`

`fn collect( &self, source: ChunksetFilterData<'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<ChunksetFilterData<'a>>>::Iter`

`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<ChunksetFilterData<'a>>>::Iter as Iterator>::Item ) -> Option<bool>`

`impl<'a, A, B, C, D, E, F, G> Filter<ChunksetFilterData<'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 = Zip<(Iter<'a, A>, Iter<'a, B>, Iter<'a, C>, Iter<'a, D>, Iter<'a, E>, Iter<'a, F>, Iter<'a, G>)>`

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

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

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

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

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

`type Iter = Zip<(Iter<'a, A>, Iter<'a, B>)>`

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

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

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

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

`impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Filter<ChunksetFilterData<'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 = Zip<(Iter<'a, A>, Iter<'a, B>, Iter<'a, C>, Iter<'a, D>, Iter<'a, E>, Iter<'a, F>, Iter<'a, G>, Iter<'a, H>, Iter<'a, I>, Iter<'a, J>, Iter<'a, K>, Iter<'a, L>, Iter<'a, M>, Iter<'a, N>, Iter<'a, O>, Iter<'a, P>)>`

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

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

`impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> Filter<ChunksetFilterData<'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 = Zip<(Iter<'a, A>, Iter<'a, B>, Iter<'a, C>, Iter<'a, D>, Iter<'a, E>, Iter<'a, F>, Iter<'a, G>, Iter<'a, H>, Iter<'a, I>, Iter<'a, J>, Iter<'a, K>, Iter<'a, L>, Iter<'a, M>, Iter<'a, N>, Iter<'a, O>)>`

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

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

`impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> Filter<ChunksetFilterData<'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 = Zip<(Iter<'a, A>, Iter<'a, B>, Iter<'a, C>, Iter<'a, D>, Iter<'a, E>, Iter<'a, F>, Iter<'a, G>, Iter<'a, H>, Iter<'a, I>, Iter<'a, J>, Iter<'a, K>, Iter<'a, L>, Iter<'a, M>, Iter<'a, N>, Iter<'a, O>, Iter<'a, P>, Iter<'a, Q>)>`

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

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

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U> Filter<ChunksetFilterData<'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 = Zip<(Iter<'a, A>, Iter<'a, B>, Iter<'a, C>, Iter<'a, D>, Iter<'a, E>, Iter<'a, F>, Iter<'a, G>, Iter<'a, H>, Iter<'a, I>, Iter<'a, J>, Iter<'a, K>, Iter<'a, L>, Iter<'a, M>, Iter<'a, N>, Iter<'a, O>, Iter<'a, P>, Iter<'a, Q>, Iter<'a, R>, Iter<'a, S>, Iter<'a, T>, Iter<'a, U>)>`

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

`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<ChunksetFilterData<'a>>>::Iter as Iterator>::Item ) -> Option<bool>`

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`

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

`impl<'a, A, B, C, D, E, F, G, H, I, J, K> Filter<ChunksetFilterData<'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 = Zip<(Iter<'a, A>, Iter<'a, B>, Iter<'a, C>, Iter<'a, D>, Iter<'a, E>, Iter<'a, F>, Iter<'a, G>, Iter<'a, H>, Iter<'a, I>, Iter<'a, J>, Iter<'a, K>)>`

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

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

`impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S> Filter<ChunksetFilterData<'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 = Zip<(Iter<'a, A>, Iter<'a, B>, Iter<'a, C>, Iter<'a, D>, Iter<'a, E>, Iter<'a, F>, Iter<'a, G>, Iter<'a, H>, Iter<'a, I>, Iter<'a, J>, Iter<'a, K>, Iter<'a, L>, Iter<'a, M>, Iter<'a, N>, Iter<'a, O>, Iter<'a, P>, Iter<'a, Q>, Iter<'a, R>, Iter<'a, S>)>`

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

`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<ChunksetFilterData<'a>>>::Iter as Iterator>::Item ) -> Option<bool>`

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`

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

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

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

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`

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

`impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N> Filter<ChunksetFilterData<'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 = Zip<(Iter<'a, A>, Iter<'a, B>, Iter<'a, C>, Iter<'a, D>, Iter<'a, E>, Iter<'a, F>, Iter<'a, G>, Iter<'a, H>, Iter<'a, I>, Iter<'a, J>, Iter<'a, K>, Iter<'a, L>, Iter<'a, M>, Iter<'a, N>)>`

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

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

`impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> Filter<ChunksetFilterData<'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 = Zip<(Iter<'a, A>, Iter<'a, B>, Iter<'a, C>, Iter<'a, D>, Iter<'a, E>, Iter<'a, F>, Iter<'a, G>, Iter<'a, H>, Iter<'a, I>, Iter<'a, J>, Iter<'a, K>, Iter<'a, L>, Iter<'a, M>, Iter<'a, N>, Iter<'a, O>, Iter<'a, P>, Iter<'a, Q>, Iter<'a, R>, Iter<'a, S>, Iter<'a, T>)>`

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

`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<ChunksetFilterData<'a>>>::Iter as Iterator>::Item ) -> Option<bool>`

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<ChunksetFilterData<'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 = Zip<(Iter<'a, A>, Iter<'a, B>, Iter<'a, C>, Iter<'a, D>, Iter<'a, E>, Iter<'a, F>, Iter<'a, G>, Iter<'a, H>, Iter<'a, I>, Iter<'a, J>, Iter<'a, K>, Iter<'a, L>, Iter<'a, M>, Iter<'a, N>, Iter<'a, O>, Iter<'a, P>, Iter<'a, Q>, Iter<'a, R>, Iter<'a, S>, Iter<'a, T>, Iter<'a, U>, Iter<'a, V>, Iter<'a, W>, Iter<'a, X>)>`

`fn collect( &self, source: ChunksetFilterData<'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<ChunksetFilterData<'a>>>::Iter`

`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<ChunksetFilterData<'a>>>::Iter as Iterator>::Item ) -> Option<bool>`

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

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

`impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R> Filter<ChunksetFilterData<'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 = Zip<(Iter<'a, A>, Iter<'a, B>, Iter<'a, C>, Iter<'a, D>, Iter<'a, E>, Iter<'a, F>, Iter<'a, G>, Iter<'a, H>, Iter<'a, I>, Iter<'a, J>, Iter<'a, K>, Iter<'a, L>, Iter<'a, M>, Iter<'a, N>, Iter<'a, O>, Iter<'a, P>, Iter<'a, Q>, Iter<'a, R>)>`

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

`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<ChunksetFilterData<'a>>>::Iter as Iterator>::Item ) -> Option<bool>`

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

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

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

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

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

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

`impl<'a, A, B, C, D, E, F, G, H, I> Filter<ChunksetFilterData<'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 = Zip<(Iter<'a, A>, Iter<'a, B>, Iter<'a, C>, Iter<'a, D>, Iter<'a, E>, Iter<'a, F>, Iter<'a, G>, Iter<'a, H>, Iter<'a, I>)>`

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

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

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`

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

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

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

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

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

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

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

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

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

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

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

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

`type Iter = SliceVecIter<'a, TagTypeId>`

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

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

`impl<'a, A, B, C, D, E, F, G, H, I, J, K, L> Filter<ChunksetFilterData<'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 = Zip<(Iter<'a, A>, Iter<'a, B>, Iter<'a, C>, Iter<'a, D>, Iter<'a, E>, Iter<'a, F>, Iter<'a, G>, Iter<'a, H>, Iter<'a, I>, Iter<'a, J>, Iter<'a, K>, Iter<'a, L>)>`

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

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

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

`type Iter = Zip<(Iter<'a, A>, Iter<'a, B>, Iter<'a, C>, Iter<'a, D>)>`

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

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

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<ChunksetFilterData<'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 = Zip<(Iter<'a, A>, Iter<'a, B>, Iter<'a, C>, Iter<'a, D>, Iter<'a, E>, Iter<'a, F>, Iter<'a, G>, Iter<'a, H>, Iter<'a, I>, Iter<'a, J>, Iter<'a, K>, Iter<'a, L>, Iter<'a, M>, Iter<'a, N>, Iter<'a, O>, Iter<'a, P>, Iter<'a, Q>, Iter<'a, R>, Iter<'a, S>, Iter<'a, T>, Iter<'a, U>, Iter<'a, V>, Iter<'a, W>, Iter<'a, X>, Iter<'a, Y>)>`

`fn collect( &self, source: ChunksetFilterData<'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<ChunksetFilterData<'a>>>::Iter`

`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<ChunksetFilterData<'a>>>::Iter as Iterator>::Item ) -> Option<bool>`

`impl<'a, A, B, C, D, E, F, G, H> Filter<ChunksetFilterData<'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 = Zip<(Iter<'a, A>, Iter<'a, B>, Iter<'a, C>, Iter<'a, D>, Iter<'a, E>, Iter<'a, F>, Iter<'a, G>, Iter<'a, H>)>`

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

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

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

`type Iter = Zip<(Iter<'a, A>, Iter<'a, B>, Iter<'a, C>, Iter<'a, D>, Iter<'a, E>)>`

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

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

`impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M> Filter<ChunksetFilterData<'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 = Zip<(Iter<'a, A>, Iter<'a, B>, Iter<'a, C>, Iter<'a, D>, Iter<'a, E>, Iter<'a, F>, Iter<'a, G>, Iter<'a, H>, Iter<'a, I>, Iter<'a, J>, Iter<'a, K>, Iter<'a, L>, Iter<'a, M>)>`

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

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

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

`type Iter = Zip<(Iter<'a, A>, Iter<'a, B>, Iter<'a, C>, Iter<'a, D>, Iter<'a, E>, Iter<'a, F>)>`

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

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

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

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

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

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

`impl<'a, A, B, C, D, E, F, G, H, I, J> Filter<ChunksetFilterData<'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 = Zip<(Iter<'a, A>, Iter<'a, B>, Iter<'a, C>, Iter<'a, D>, Iter<'a, E>, Iter<'a, F>, Iter<'a, G>, Iter<'a, H>, Iter<'a, I>, Iter<'a, J>)>`

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

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

Loading content...

Implementors

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

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

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

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

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

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

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

`type Iter = SliceVecIter<'a, ComponentTypeId>`

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

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

`impl<'a> Filter<ChunkFilterData<'a>> for Any`

`type Iter = Take<Repeat<()>>`

`fn init(&self)`

`fn collect( &self, chunk: ChunkFilterData<'a> ) -> <Any as Filter<ChunkFilterData<'a>>>::Iter`

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

`impl<'a> Filter<ChunkFilterData<'a>> for Passthrough`

`type Iter = Take<Repeat<()>>`

`fn init(&self)`

`fn collect( &self, chunk: ChunkFilterData<'a> ) -> <Passthrough as Filter<ChunkFilterData<'a>>>::Iter`

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

`impl<'a> Filter<ChunksetFilterData<'a>> for Any`

`type Iter = Take<Repeat<()>>`

`fn init(&self)`

`fn collect( &self, sets: ChunksetFilterData<'a> ) -> <Any as Filter<ChunksetFilterData<'a>>>::Iter`

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

`impl<'a> Filter<ChunksetFilterData<'a>> for Passthrough`

`type Iter = Take<Repeat<()>>`

`fn init(&self)`

`fn collect( &self, sets: ChunksetFilterData<'a> ) -> <Passthrough as Filter<ChunksetFilterData<'a>>>::Iter`

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

`impl<'a, 'b, T> Filter<ChunksetFilterData<'a>> for TagValueFilter<'b, T> where T: Tag,`

`type Iter = Iter<'a, T>`

`fn init(&self)`

`fn collect( &self, source: ChunksetFilterData<'a> ) -> <TagValueFilter<'b, T> as Filter<ChunksetFilterData<'a>>>::Iter`

`fn is_match( &self, item: &<<TagValueFilter<'b, T> as Filter<ChunksetFilterData<'a>>>::Iter as Iterator>::Item ) -> Option<bool>`

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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`

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

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`

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

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`

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

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`

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

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`

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

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`

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

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`

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

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`

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

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`

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

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`

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

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`

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

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

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

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

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

`impl<'a, T> Filter<ChunkFilterData<'a>> for ComponentChangedFilter<T> where T: Component,`

`type Iter = ComponentChangedState<'a, ComponentStorage>`

`fn init(&self)`

`fn collect( &self, source: ChunkFilterData<'a> ) -> <ComponentChangedFilter<T> as Filter<ChunkFilterData<'a>>>::Iter`

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

`impl<'a, T, A, B> Filter<T> for And<(A, B)> where A: Filter<T>, B: Filter<T>, T: Copy,`

`type Iter = FissileZip<<A as Filter<T>>::Iter, >::Iter>`

`fn init(&self)`

`fn collect(&self, source: T) -> <And<(A, B)> as Filter<T>>::Iter`

`fn is_match( &self, item: &<<And<(A, B)> as Filter<T>>::Iter as Iterator>::Item ) -> Option<bool>`

`impl<'a, T, A, B> Filter<T> for Or<(A, B)> where A: Filter<T>, B: Filter<T>, T: Copy,`

`type Iter = FissileZip<<A as Filter<T>>::Iter, >::Iter>`

`fn init(&self)`

`fn collect(&self, source: T) -> <Or<(A, B)> as Filter<T>>::Iter`

`fn is_match( &self, item: &<<Or<(A, B)> as Filter<T>>::Iter as Iterator>::Item ) -> Option<bool>`

`impl<'a, T, A, B, C> Filter<T> for And<(A, B, C)> where A: Filter<T>, B: Filter<T>, C: Filter<T>, T: Copy,`

`type Iter = FissileZip<<A as Filter<T>>::Iter, FissileZip<>::Iter, <C as Filter<T>>::Iter>>`

`fn init(&self)`

`fn collect(&self, source: T) -> <And<(A, B, C)> as Filter<T>>::Iter`

`fn is_match( &self, item: &<<And<(A, B, C)> as Filter<T>>::Iter as Iterator>::Item ) -> Option<bool>`

`impl<'a, T, A, B, C> Filter<T> for Or<(A, B, C)> where A: Filter<T>, B: Filter<T>, C: Filter<T>, T: Copy,`

`type Iter = FissileZip<<A as Filter<T>>::Iter, FissileZip<>::Iter, <C as Filter<T>>::Iter>>`

`fn init(&self)`

`fn collect(&self, source: T) -> <Or<(A, B, C)> as Filter<T>>::Iter`

`fn is_match( &self, item: &<<Or<(A, B, C)> as Filter<T>>::Iter as Iterator>::Item ) -> Option<bool>`

`impl<'a, T, A, B, C, D> Filter<T> for And<(A, B, C, D)> where A: Filter<T>, B: Filter<T>, C: Filter<T>, D: Filter<T>, T: Copy,`

`type Iter = FissileZip<<A as Filter<T>>::Iter, FissileZip<>::Iter, FissileZip<<C as Filter<T>>::Iter, <D as Filter<T>>::Iter>>>`

`fn init(&self)`

`fn collect(&self, source: T) -> <And<(A, B, C, D)> as Filter<T>>::Iter`

`fn is_match( &self, item: &<<And<(A, B, C, D)> as Filter<T>>::Iter as Iterator>::Item ) -> Option<bool>`

`impl<'a, T, A, B, C, D> Filter<T> for Or<(A, B, C, D)> where A: Filter<T>, B: Filter<T>, C: Filter<T>, D: Filter<T>, T: Copy,`

`type Iter = FissileZip<<A as Filter<T>>::Iter, FissileZip<>::Iter, FissileZip<<C as Filter<T>>::Iter, <D as Filter<T>>::Iter>>>`

`fn init(&self)`

`fn collect(&self, source: T) -> <Or<(A, B, C, D)> as Filter<T>>::Iter`

`fn is_match( &self, item: &<<Or<(A, B, C, D)> as Filter<T>>::Iter as Iterator>::Item ) -> Option<bool>`

`impl<'a, T, A, B, C, D, E> Filter<T> for And<(A, B, C, D, E)> where A: Filter<T>, B: Filter<T>, C: Filter<T>, D: Filter<T>, E: Filter<T>, T: Copy,`

`type Iter = FissileZip<<A as Filter<T>>::Iter, FissileZip<>::Iter, FissileZip<<C as Filter<T>>::Iter, FissileZip<<D as Filter<T>>::Iter, <E as Filter<T>>::Iter>>>>`

`fn init(&self)`

`fn collect(&self, source: T) -> <And<(A, B, C, D, E)> as Filter<T>>::Iter`

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

`impl<'a, T, A, B, C, D, E> Filter<T> for Or<(A, B, C, D, E)> where A: Filter<T>, B: Filter<T>, C: Filter<T>, D: Filter<T>, E: Filter<T>, T: Copy,`

`type Iter = FissileZip<<A as Filter<T>>::Iter, FissileZip<>::Iter, FissileZip<<C as Filter<T>>::Iter, FissileZip<<D as Filter<T>>::Iter, <E as Filter<T>>::Iter>>>>`

`fn init(&self)`

`fn collect(&self, source: T) -> <Or<(A, B, C, D, E)> as Filter<T>>::Iter`

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

`impl<'a, T, A, B, C, D, E, F> Filter<T> for And<(A, B, C, D, E, F)> where A: Filter<T>, B: Filter<T>, C: Filter<T>, D: Filter<T>, E: Filter<T>, F: Filter<T>, T: Copy,`

`type Iter = FissileZip<<A as Filter<T>>::Iter, FissileZip<>::Iter, FissileZip<<C as Filter<T>>::Iter, FissileZip<<D as Filter<T>>::Iter, FissileZip<<E as Filter<T>>::Iter, <F as Filter<T>>::Iter>>>>>`

`fn init(&self)`

`fn collect(&self, source: T) -> <And<(A, B, C, D, E, F)> as Filter<T>>::Iter`

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

`impl<'a, T, A, B, C, D, E, F> Filter<T> for Or<(A, B, C, D, E, F)> where A: Filter<T>, B: Filter<T>, C: Filter<T>, D: Filter<T>, E: Filter<T>, F: Filter<T>, T: Copy,`

`type Iter = FissileZip<<A as Filter<T>>::Iter, FissileZip<>::Iter, FissileZip<<C as Filter<T>>::Iter, FissileZip<<D as Filter<T>>::Iter, FissileZip<<E as Filter<T>>::Iter, <F as Filter<T>>::Iter>>>>>`

`fn init(&self)`

`fn collect(&self, source: T) -> <Or<(A, B, C, D, E, F)> as Filter<T>>::Iter`

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

`impl<'a, T, A, B, C, D, E, F, G> Filter<T> for And<(A, B, C, D, E, F, G)> where A: Filter<T>, B: Filter<T>, C: Filter<T>, D: Filter<T>, E: Filter<T>, F: Filter<T>, G: Filter<T>, T: Copy,`

`type Iter = FissileZip<<A as Filter<T>>::Iter, FissileZip<>::Iter, FissileZip<<C as Filter<T>>::Iter, FissileZip<<D as Filter<T>>::Iter, FissileZip<<E as Filter<T>>::Iter, FissileZip<<F as Filter<T>>::Iter, <G as Filter<T>>::Iter>>>>>>`

`fn init(&self)`

`fn collect(&self, source: T) -> <And<(A, B, C, D, E, F, G)> as Filter<T>>::Iter`

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

`impl<'a, T, A, B, C, D, E, F, G> Filter<T> for Or<(A, B, C, D, E, F, G)> where A: Filter<T>, B: Filter<T>, C: Filter<T>, D: Filter<T>, E: Filter<T>, F: Filter<T>, G: Filter<T>, T: Copy,`

`type Iter = FissileZip<<A as Filter<T>>::Iter, FissileZip<>::Iter, FissileZip<<C as Filter<T>>::Iter, FissileZip<<D as Filter<T>>::Iter, FissileZip<<E as Filter<T>>::Iter, FissileZip<<F as Filter<T>>::Iter, <G as Filter<T>>::Iter>>>>>>`

`fn init(&self)`

`fn collect(&self, source: T) -> <Or<(A, B, C, D, E, F, G)> as Filter<T>>::Iter`

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

`impl<'a, T, A, B, C, D, E, F, G, H> Filter<T> for And<(A, B, C, D, E, F, G, H)> where A: Filter<T>, B: Filter<T>, C: Filter<T>, D: Filter<T>, E: Filter<T>, F: Filter<T>, G: Filter<T>, H: Filter<T>, T: Copy,`

`type Iter = FissileZip<<A as Filter<T>>::Iter, FissileZip<>::Iter, FissileZip<<C as Filter<T>>::Iter, FissileZip<<D as Filter<T>>::Iter, FissileZip<<E as Filter<T>>::Iter, FissileZip<<F as Filter<T>>::Iter, FissileZip<<G as Filter<T>>::Iter, <H as Filter<T>>::Iter>>>>>>>`

`fn init(&self)`

`fn collect( &self, source: T ) -> <And<(A, B, C, D, E, F, G, H)> as Filter<T>>::Iter`

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

`impl<'a, T, A, B, C, D, E, F, G, H> Filter<T> for Or<(A, B, C, D, E, F, G, H)> where A: Filter<T>, B: Filter<T>, C: Filter<T>, D: Filter<T>, E: Filter<T>, F: Filter<T>, G: Filter<T>, H: Filter<T>, T: Copy,`

`type Iter = FissileZip<<A as Filter<T>>::Iter, FissileZip<>::Iter, FissileZip<<C as Filter<T>>::Iter, FissileZip<<D as Filter<T>>::Iter, FissileZip<<E as Filter<T>>::Iter, FissileZip<<F as Filter<T>>::Iter, FissileZip<<G as Filter<T>>::Iter, <H as Filter<T>>::Iter>>>>>>>`

`fn init(&self)`

`fn collect( &self, source: T ) -> <Or<(A, B, C, D, E, F, G, H)> as Filter<T>>::Iter`

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

`impl<'a, T, A, B, C, D, E, F, G, H, I> Filter<T> for And<(A, B, C, D, E, F, G, H, I)> where A: Filter<T>, B: Filter<T>, C: Filter<T>, D: Filter<T>, E: Filter<T>, F: Filter<T>, G: Filter<T>, H: Filter<T>, I: Filter<T>, T: Copy,`

`type Iter = FissileZip<<A as Filter<T>>::Iter, FissileZip<>::Iter, FissileZip<<C as Filter<T>>::Iter, FissileZip<<D as Filter<T>>::Iter, FissileZip<<E as Filter<T>>::Iter, FissileZip<<F as Filter<T>>::Iter, FissileZip<<G as Filter<T>>::Iter, FissileZip<<H as Filter<T>>::Iter, >::Iter>>>>>>>>`

`fn init(&self)`

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

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

`impl<'a, T, A, B, C, D, E, F, G, H, I> Filter<T> for Or<(A, B, C, D, E, F, G, H, I)> where A: Filter<T>, B: Filter<T>, C: Filter<T>, D: Filter<T>, E: Filter<T>, F: Filter<T>, G: Filter<T>, H: Filter<T>, I: Filter<T>, T: Copy,`

`type Iter = FissileZip<<A as Filter<T>>::Iter, FissileZip<>::Iter, FissileZip<<C as Filter<T>>::Iter, FissileZip<<D as Filter<T>>::Iter, FissileZip<<E as Filter<T>>::Iter, FissileZip<<F as Filter<T>>::Iter, FissileZip<<G as Filter<T>>::Iter, FissileZip<<H as Filter<T>>::Iter, >::Iter>>>>>>>>`

`fn init(&self)`

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

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

`impl<'a, T, A, B, C, D, E, F, G, H, I, J> Filter<T> for And<(A, B, C, D, E, F, G, H, I, J)> where A: Filter<T>, B: Filter<T>, C: Filter<T>, D: Filter<T>, E: Filter<T>, F: Filter<T>, G: Filter<T>, H: Filter<T>, I: Filter<T>, J: Filter<T>, T: Copy,`

`type Iter = FissileZip<<A as Filter<T>>::Iter, FissileZip<>::Iter, FissileZip<<C as Filter<T>>::Iter, FissileZip<<D as Filter<T>>::Iter, FissileZip<<E as Filter<T>>::Iter, FissileZip<<F as Filter<T>>::Iter, FissileZip<<G as Filter<T>>::Iter, FissileZip<<H as Filter<T>>::Iter, FissileZip<>::Iter, <J as Filter<T>>::Iter>>>>>>>>>`

`fn init(&self)`

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

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

`impl<'a, T, A, B, C, D, E, F, G, H, I, J> Filter<T> for Or<(A, B, C, D, E, F, G, H, I, J)> where A: Filter<T>, B: Filter<T>, C: Filter<T>, D: Filter<T>, E: Filter<T>, F: Filter<T>, G: Filter<T>, H: Filter<T>, I: Filter<T>, J: Filter<T>, T: Copy,`

`type Iter = FissileZip<<A as Filter<T>>::Iter, FissileZip<>::Iter, FissileZip<<C as Filter<T>>::Iter, FissileZip<<D as Filter<T>>::Iter, FissileZip<<E as Filter<T>>::Iter, FissileZip<<F as Filter<T>>::Iter, FissileZip<<G as Filter<T>>::Iter, FissileZip<<H as Filter<T>>::Iter, FissileZip<>::Iter, <J as Filter<T>>::Iter>>>>>>>>>`

`fn init(&self)`

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

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

`impl<'a, T, A, B, C, D, E, F, G, H, I, J, K> Filter<T> for And<(A, B, C, D, E, F, G, H, I, J, K)> where A: Filter<T>, B: Filter<T>, C: Filter<T>, D: Filter<T>, E: Filter<T>, F: Filter<T>, G: Filter<T>, H: Filter<T>, I: Filter<T>, J: Filter<T>, K: Filter<T>, T: Copy,`

`type Iter = FissileZip<<A as Filter<T>>::Iter, FissileZip<>::Iter, FissileZip<<C as Filter<T>>::Iter, FissileZip<<D as Filter<T>>::Iter, FissileZip<<E as Filter<T>>::Iter, FissileZip<<F as Filter<T>>::Iter, FissileZip<<G as Filter<T>>::Iter, FissileZip<<H as Filter<T>>::Iter, FissileZip<>::Iter, FissileZip<<J as Filter<T>>::Iter, <K as Filter<T>>::Iter>>>>>>>>>>`

`fn init(&self)`

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

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

`impl<'a, T, A, B, C, D, E, F, G, H, I, J, K> Filter<T> for Or<(A, B, C, D, E, F, G, H, I, J, K)> where A: Filter<T>, B: Filter<T>, C: Filter<T>, D: Filter<T>, E: Filter<T>, F: Filter<T>, G: Filter<T>, H: Filter<T>, I: Filter<T>, J: Filter<T>, K: Filter<T>, T: Copy,`

`type Iter = FissileZip<<A as Filter<T>>::Iter, FissileZip<>::Iter, FissileZip<<C as Filter<T>>::Iter, FissileZip<<D as Filter<T>>::Iter, FissileZip<<E as Filter<T>>::Iter, FissileZip<<F as Filter<T>>::Iter, FissileZip<<G as Filter<T>>::Iter, FissileZip<<H as Filter<T>>::Iter, FissileZip<>::Iter, FissileZip<<J as Filter<T>>::Iter, <K as Filter<T>>::Iter>>>>>>>>>>`

`fn init(&self)`

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

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

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

`type Iter = FissileZip<<A as Filter<T>>::Iter, FissileZip<>::Iter, FissileZip<<C as Filter<T>>::Iter, FissileZip<<D as Filter<T>>::Iter, FissileZip<<E as Filter<T>>::Iter, FissileZip<<F as Filter<T>>::Iter, FissileZip<<G as Filter<T>>::Iter, FissileZip<<H as Filter<T>>::Iter, FissileZip<>::Iter, FissileZip<<J as Filter<T>>::Iter, FissileZip<<K as Filter<T>>::Iter, <L as Filter<T>>::Iter>>>>>>>>>>>`

`fn init(&self)`

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

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

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

`type Iter = FissileZip<<A as Filter<T>>::Iter, FissileZip<>::Iter, FissileZip<<C as Filter<T>>::Iter, FissileZip<<D as Filter<T>>::Iter, FissileZip<<E as Filter<T>>::Iter, FissileZip<<F as Filter<T>>::Iter, FissileZip<<G as Filter<T>>::Iter, FissileZip<<H as Filter<T>>::Iter, FissileZip<>::Iter, FissileZip<<J as Filter<T>>::Iter, FissileZip<<K as Filter<T>>::Iter, <L as Filter<T>>::Iter>>>>>>>>>>>`

`fn init(&self)`

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

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

`impl<'a, T, F> Filter<T> for And<(F,)> where F: Filter<T>, T: Copy,`

`type Iter = <F as Filter<T>>::Iter`

`fn init(&self)`

`fn collect(&self, source: T) -> <And<(F,)> as Filter<T>>::Iter`

`fn is_match( &self, item: &<<And<(F,)> as Filter<T>>::Iter as Iterator>::Item ) -> Option<bool>`

`impl<'a, T, F> Filter<T> for Not<F> where F: Filter<T>, T: Copy,`

`type Iter = <F as Filter<T>>::Iter`

`fn init(&self)`

`fn collect(&self, source: T) -> <Not<F> as Filter<T>>::Iter`

`fn is_match( &self, item: &<<Not<F> as Filter<T>>::Iter as Iterator>::Item ) -> Option<bool>`

Loading content...

[−]Trait acute_ecs::filter::Filter

Notable traits for FilterIter<'a, F, T>

Associated Types

type Iter: Send + Sync + Iterator

Required methods

fn collect(&self, source: T) -> Self::Iter

fn is_match(&self, item: &<Self::Iter as Iterator>::Item) -> Option<bool>

Provided methods

fn init(&self)

fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>ⓘNotable traits for FilterIter<'a, F, T>impl<'a, F, T> Iterator for FilterIter<'a, F, T> where F: Filter<T>, T: Copy, type Item = bool;

Notable traits for FilterIter<'a, F, T>

Implementations on Foreign Types

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

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

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

type Iter = Zip<(Iter<'a, A>, Iter<'a, B>, Iter<'a, C>)>

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

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

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

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

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

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>

fn collect( &self, source: ChunksetFilterData<'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<ChunksetFilterData<'a>>>::Iter

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<ChunksetFilterData<'a>>>::Iter as Iterator>::Item) -> Option<bool>

fn collect( &self, source: ChunksetFilterData<'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<ChunksetFilterData<'a>>>::Iter

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<ChunksetFilterData<'a>>>::Iter as Iterator>::Item) -> Option<bool>

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

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>

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

type Iter = Take<Repeat<()>>

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

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

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

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>

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

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

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

type Iter = Zip<(Iter<'a, A>,)>

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

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

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

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

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

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>

fn collect( &self, source: ChunksetFilterData<'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<ChunksetFilterData<'a>>>::Iter

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<ChunksetFilterData<'a>>>::Iter as Iterator>::Item) -> Option<bool>

impl<'a, A, B, C, D, E, F, G> Filter<ChunksetFilterData<'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 = Zip<(Iter<'a, A>, Iter<'a, B>, Iter<'a, C>, Iter<'a, D>, Iter<'a, E>, Iter<'a, F>, Iter<'a, G>)>

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

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

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

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>

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

type Iter = Zip<(Iter<'a, A>, Iter<'a, B>)>

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

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

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

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

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Filter<ChunksetFilterData<'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 = Zip<(Iter<'a, A>, Iter<'a, B>, Iter<'a, C>, Iter<'a, D>, Iter<'a, E>, Iter<'a, F>, Iter<'a, G>, Iter<'a, H>, Iter<'a, I>, Iter<'a, J>, Iter<'a, K>, Iter<'a, L>, Iter<'a, M>, Iter<'a, N>, Iter<'a, O>, Iter<'a, P>)>

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

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

`type Iter: Send + Sync + Iterator`

`fn collect(&self, source: T) -> Self::Iter`

`fn is_match(&self, item: &<Self::Iter as Iterator>::Item) -> Option<bool>`

`fn init(&self)`

`fn matches(&mut self, source: T) -> FilterIter<'_, Self, T>ⓘNotable traits for FilterIter<'a, F, T> impl<'a, F, T> Iterator for FilterIter<'a, F, T> where F: Filter<T>, T: Copy, type Item = bool;`

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

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

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

`type Iter = Zip<(Iter<'a, A>, Iter<'a, B>, Iter<'a, C>)>`

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

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

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

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

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

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

`fn collect( &self, source: ChunksetFilterData<'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<ChunksetFilterData<'a>>>::Iter`

`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<ChunksetFilterData<'a>>>::Iter as Iterator>::Item ) -> Option<bool>`

`fn collect( &self, source: ChunksetFilterData<'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<ChunksetFilterData<'a>>>::Iter`

`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<ChunksetFilterData<'a>>>::Iter as Iterator>::Item ) -> Option<bool>`

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

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

`impl<'a> Filter<ChunksetFilterData<'a>> for ()`

`type Iter = Take<Repeat<()>>`

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

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

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

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

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

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

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

`type Iter = Zip<(Iter<'a, A>,)>`

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

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

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

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

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

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

`fn collect( &self, source: ChunksetFilterData<'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<ChunksetFilterData<'a>>>::Iter`

`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<ChunksetFilterData<'a>>>::Iter as Iterator>::Item ) -> Option<bool>`

`impl<'a, A, B, C, D, E, F, G> Filter<ChunksetFilterData<'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 = Zip<(Iter<'a, A>, Iter<'a, B>, Iter<'a, C>, Iter<'a, D>, Iter<'a, E>, Iter<'a, F>, Iter<'a, G>)>`

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

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

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

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

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

`type Iter = Zip<(Iter<'a, A>, Iter<'a, B>)>`

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

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

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

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

`impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Filter<ChunksetFilterData<'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 = Zip<(Iter<'a, A>, Iter<'a, B>, Iter<'a, C>, Iter<'a, D>, Iter<'a, E>, Iter<'a, F>, Iter<'a, G>, Iter<'a, H>, Iter<'a, I>, Iter<'a, J>, Iter<'a, K>, Iter<'a, L>, Iter<'a, M>, Iter<'a, N>, Iter<'a, O>, Iter<'a, P>)>`

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

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

`impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> Filter<ChunksetFilterData<'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 = Zip<(Iter<'a, A>, Iter<'a, B>, Iter<'a, C>, Iter<'a, D>, Iter<'a, E>, Iter<'a, F>, Iter<'a, G>, Iter<'a, H>, Iter<'a, I>, Iter<'a, J>, Iter<'a, K>, Iter<'a, L>, Iter<'a, M>, Iter<'a, N>, Iter<'a, O>)>`

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

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

`impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> Filter<ChunksetFilterData<'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 = Zip<(Iter<'a, A>, Iter<'a, B>, Iter<'a, C>, Iter<'a, D>, Iter<'a, E>, Iter<'a, F>, Iter<'a, G>, Iter<'a, H>, Iter<'a, I>, Iter<'a, J>, Iter<'a, K>, Iter<'a, L>, Iter<'a, M>, Iter<'a, N>, Iter<'a, O>, Iter<'a, P>, Iter<'a, Q>)>`

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