[−][src]Struct legion::filter::ChunksetFilterData

pub struct ChunksetFilterData<'a> {
    pub archetype_data: &'a ArchetypeData,
}

Input data for chunkset filters.

Fields

archetype_data: &'a ArchetypeData

The component data in an archetype.

Trait Implementations

`impl<'a> Clone for ChunksetFilterData<'a>`[src]

`fn clone(&self) -> ChunksetFilterData<'a>`[src]

`fn clone_from(&mut self, source: &Self)`1.0.0[src]

`impl<'a> Copy for ChunksetFilterData<'a>`[src]

`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,` [src]

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

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

`fn init(&self)`[src]

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

`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,` [src]

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

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

`fn init(&self)`[src]

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

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

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

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

`fn init(&self)`[src]

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

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

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

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

`fn init(&self)`[src]

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

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

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

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

`fn init(&self)`[src]

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

`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,` [src]

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

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

`fn init(&self)`[src]

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

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

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

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

`fn init(&self)`[src]

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

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

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

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

`fn init(&self)`[src]

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

`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,` [src]

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

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

`fn init(&self)`[src]

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

`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,` [src]

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

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

`fn init(&self)`[src]

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

`impl<'a> Filter<ChunksetFilterData<'a>> for ()`[src]

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

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

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

`fn init(&self)`[src]

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

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

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

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

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

`fn init(&self)`[src]

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

`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,` [src]

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

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

`fn init(&self)`[src]

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

`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,` [src]

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

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

`fn init(&self)`[src]

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

`impl<'a> Filter<ChunksetFilterData<'a>> for Passthrough`[src]

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

`fn init(&self)`[src]

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

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

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

`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,` [src]

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

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

`fn init(&self)`[src]

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

`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,` [src]

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

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

`fn init(&self)`[src]

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

`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,` [src]

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

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

`fn init(&self)`[src]

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

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

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

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

`fn init(&self)`[src]

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

`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,` [src]

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

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

`fn init(&self)`[src]

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

`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,` [src]

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

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

`fn init(&self)`[src]

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

`impl<'a> Filter<ChunksetFilterData<'a>> for Any`[src]

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

`fn init(&self)`[src]

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

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

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

`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,` [src]

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

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

`fn init(&self)`[src]

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

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

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

`fn init(&self)`[src]

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

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

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

`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,` [src]

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

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

`fn init(&self)`[src]

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

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

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

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

`fn init(&self)`[src]

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

`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,` [src]

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

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

`fn init(&self)`[src]

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

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

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

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

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

`fn init(&self)`[src]

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

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

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

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

`fn init(&self)`[src]

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

`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,` [src]

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

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

`fn init(&self)`[src]

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

Auto Trait Implementations

`impl<'a> !RefUnwindSafe for ChunksetFilterData<'a>`

`impl<'a> Send for ChunksetFilterData<'a>`

`impl<'a> Sync for ChunksetFilterData<'a>`

`impl<'a> Unpin for ChunksetFilterData<'a>`

`impl<'a> !UnwindSafe for ChunksetFilterData<'a>`

Blanket Implementations

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`fn type_id(&self) -> TypeId`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`fn borrow_mut(&mut self) -> &mut T`[src]

`impl<T> Component for T where T: 'static + Send + Sync,` [src]

`impl<T> Downcast for T where T: Any,`

`fn into_any(self: Box<T>) -> Box<dyn Any + 'static>`

`fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>`

`fn as_any(&self) -> &(dyn Any + 'static)`

`fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)`

`impl<T> DowncastSync for T where T: Send + Sync + Any,`

`fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + 'static + Sync + Send>`

`impl<T> From<T> for T`[src]

`fn from(t: T) -> T`[src]

`impl<T, U> Into for T where U: From<T>,` [src]

`fn into(self) -> U`[src]

`impl<T> Resource for T where T: 'static + Send + Sync,` [src]

`impl<T> ToOwned for T where T: Clone,` [src]

`type Owned = T`

The resulting type after obtaining ownership.

`fn to_owned(&self) -> T`[src]

`fn clone_into(&self, target: &mut T)`[src]

`impl<T, U> TryFrom for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

`fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>`[src]

`impl<T, U> TryInto for T where U: TryFrom<T>,` [src]

`type Error = >::Error`

The type returned in the event of a conversion error.

`fn try_into(self) -> Result<U, >::Error>`[src]

[−][src]Struct legion::filter::ChunksetFilterData

Fields

Trait Implementations

impl<'a> Clone for ChunksetFilterData<'a>[src]

fn clone(&self) -> ChunksetFilterData<'a>[src]

fn clone_from(&mut self, source: &Self)1.0.0[src]

impl<'a> Copy for ChunksetFilterData<'a>[src]

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

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

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

fn init(&self)[src]

fn matches(&mut self, source: T) -> FilterIter<Self, T>[src]

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

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

fn init(&self)[src]

fn matches(&mut self, source: T) -> FilterIter<Self, T>[src]

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

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

fn init(&self)[src]

fn matches(&mut self, source: T) -> FilterIter<Self, T>[src]

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

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

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

fn init(&self)[src]

fn matches(&mut self, source: T) -> FilterIter<Self, T>[src]

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

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

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

fn init(&self)[src]

fn matches(&mut self, source: T) -> FilterIter<Self, T>[src]

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

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

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

fn init(&self)[src]

fn matches(&mut self, source: T) -> FilterIter<Self, T>[src]

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

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

fn init(&self)[src]

fn matches(&mut self, source: T) -> FilterIter<Self, T>[src]

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

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

fn init(&self)[src]

fn matches(&mut self, source: T) -> FilterIter<Self, T>[src]

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

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

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

fn init(&self)[src]

fn matches(&mut self, source: T) -> FilterIter<Self, T>[src]

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

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

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

fn init(&self)[src]

fn matches(&mut self, source: T) -> FilterIter<Self, T>[src]

impl<'a> Filter<ChunksetFilterData<'a>> for ()[src]

type Iter = Take<Repeat<()>>

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

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

fn init(&self)[src]

fn matches(&mut self, source: T) -> FilterIter<Self, T>[src]

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

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

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

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

fn init(&self)[src]

fn matches(&mut self, source: T) -> FilterIter<Self, T>[src]

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

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

fn init(&self)[src]

fn matches(&mut self, source: T) -> FilterIter<Self, T>[src]

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

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

`impl<'a> Clone for ChunksetFilterData<'a>`[src]

`fn clone(&self) -> ChunksetFilterData<'a>`[src]

`fn clone_from(&mut self, source: &Self)`1.0.0[src]

`impl<'a> Copy for ChunksetFilterData<'a>`[src]

`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,` [src]

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

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

`fn init(&self)`[src]

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

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

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

`fn init(&self)`[src]

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

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

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

`fn init(&self)`[src]

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

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

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

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

`fn init(&self)`[src]

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

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

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

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

`fn init(&self)`[src]

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

`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,` [src]

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

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

`fn init(&self)`[src]

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

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

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

`fn init(&self)`[src]

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

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

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

`fn init(&self)`[src]

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

`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,` [src]

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

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

`fn init(&self)`[src]

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

`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,` [src]

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

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

`fn init(&self)`[src]

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

`impl<'a> Filter<ChunksetFilterData<'a>> for ()`[src]

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

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

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

`fn init(&self)`[src]

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

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

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

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

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

`fn init(&self)`[src]

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

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

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

`fn init(&self)`[src]

`fn matches(&mut self, source: T) -> FilterIter<Self, T>`[src]

`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,` [src]

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

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

`fn init(&self)`[src]