[−]Struct acute_ecs::filter::Or

pub struct Or<T> {
    pub filters: T,
}

A filter which requires that any filter within T match.

Fields

filters: T

Trait Implementations

`impl<A, B, C, D, E, F, G, H> ActiveFilter for Or<(A, B, C, D, E, F, G, H)>`

`impl<A, B, C, D, E, F, G> ActiveFilter for Or<(A, B, C, D, E, F, G)>`

`impl<A, B, C, D> ActiveFilter for Or<(A, B, C, D)>`

`impl<A, B, C, D, E, F, G, H, I, J, K> ActiveFilter for Or<(A, B, C, D, E, F, G, H, I, J, K)>`

`impl<A, B, C> ActiveFilter for Or<(A, B, C)>`

`impl<A, B> ActiveFilter for Or<(A, B)>`

`impl<A, B, C, D, E, F, G, H, I, J> ActiveFilter for Or<(A, B, C, D, E, F, G, H, I, J)>`

`impl<A, B, C, D, E, F, G, H, I, J, K, L> ActiveFilter for Or<(A, B, C, D, E, F, G, H, I, J, K, L)>`

`impl<A, B, C, D, E> ActiveFilter for Or<(A, B, C, D, E)>`

`impl<A, B, C, D, E, F, G, H, I> ActiveFilter for Or<(A, B, C, D, E, F, G, H, I)>`

`impl<A, B, C, D, E, F> ActiveFilter for Or<(A, B, C, D, E, F)>`

`impl<A, B, C, D, E, F, G, H, I, J> BitAnd<Passthrough> for Or<(A, B, C, D, E, F, G, H, I, J)>`

`type Output = Or<(A, B, C, D, E, F, G, H, I, J)>`

The resulting type after applying the & operator.

`fn bitand( self, Passthrough ) -> <Or<(A, B, C, D, E, F, G, H, I, J)> as BitAnd<Passthrough>>::Output`

`impl<A, B, C, D, E> BitAnd<Passthrough> for Or<(A, B, C, D, E)>`

`type Output = Or<(A, B, C, D, E)>`

The resulting type after applying the & operator.

`fn bitand( self, Passthrough ) -> <Or<(A, B, C, D, E)> as BitAnd<Passthrough>>::Output`

`impl<A, B, C, D, E, F> BitAnd<Passthrough> for Or<(A, B, C, D, E, F)>`

`type Output = Or<(A, B, C, D, E, F)>`

The resulting type after applying the & operator.

`fn bitand( self, Passthrough ) -> <Or<(A, B, C, D, E, F)> as BitAnd<Passthrough>>::Output`

`impl<A, B, C> BitAnd<Passthrough> for Or<(A, B, C)>`

`type Output = Or<(A, B, C)>`

The resulting type after applying the & operator.

`fn bitand(self, Passthrough) -> <Or<(A, B, C)> as BitAnd<Passthrough>>::Output`

`impl<A, B> BitAnd<Passthrough> for Or<(A, B)>`

`type Output = Or<(A, B)>`

The resulting type after applying the & operator.

`fn bitand(self, Passthrough) -> <Or<(A, B)> as BitAnd<Passthrough>>::Output`

`impl<A, B, C, D, E, F, G, H, I, J, K, L> BitAnd<Passthrough> for Or<(A, B, C, D, E, F, G, H, I, J, K, L)>`

`type Output = Or<(A, B, C, D, E, F, G, H, I, J, K, L)>`

The resulting type after applying the & operator.

`fn bitand( self, Passthrough ) -> <Or<(A, B, C, D, E, F, G, H, I, J, K, L)> as BitAnd<Passthrough>>::Output`

`impl<A, B, C, D, E, F, G, H, I, J, K> BitAnd<Passthrough> for Or<(A, B, C, D, E, F, G, H, I, J, K)>`

`type Output = Or<(A, B, C, D, E, F, G, H, I, J, K)>`

The resulting type after applying the & operator.

`fn bitand( self, Passthrough ) -> <Or<(A, B, C, D, E, F, G, H, I, J, K)> as BitAnd<Passthrough>>::Output`

`impl<A, B, C, D, E, F, G> BitAnd<Passthrough> for Or<(A, B, C, D, E, F, G)>`

`type Output = Or<(A, B, C, D, E, F, G)>`

The resulting type after applying the & operator.

`fn bitand( self, Passthrough ) -> <Or<(A, B, C, D, E, F, G)> as BitAnd<Passthrough>>::Output`

`impl<A, B, C, D, E, F, G, H> BitAnd<Passthrough> for Or<(A, B, C, D, E, F, G, H)>`

`type Output = Or<(A, B, C, D, E, F, G, H)>`

The resulting type after applying the & operator.

`fn bitand( self, Passthrough ) -> <Or<(A, B, C, D, E, F, G, H)> as BitAnd<Passthrough>>::Output`

`impl<A, B, C, D> BitAnd<Passthrough> for Or<(A, B, C, D)>`

`type Output = Or<(A, B, C, D)>`

The resulting type after applying the & operator.

`fn bitand( self, Passthrough ) -> <Or<(A, B, C, D)> as BitAnd<Passthrough>>::Output`

`impl<A, B, C, D, E, F, G, H, I> BitAnd<Passthrough> for Or<(A, B, C, D, E, F, G, H, I)>`

`type Output = Or<(A, B, C, D, E, F, G, H, I)>`

The resulting type after applying the & operator.

`fn bitand( self, Passthrough ) -> <Or<(A, B, C, D, E, F, G, H, I)> as BitAnd<Passthrough>>::Output`

`impl<A, B, C, D, E, F, G, H, Rhs> BitAnd<Rhs> for Or<(A, B, C, D, E, F, G, H)> where Rhs: ActiveFilter,`

`type Output = And<(Or<(A, B, C, D, E, F, G, H)>, Rhs)>`

The resulting type after applying the & operator.

`fn bitand( self, rhs: Rhs ) -> <Or<(A, B, C, D, E, F, G, H)> as BitAnd<Rhs>>::Output`

`impl<A, B, C, D, E, Rhs> BitAnd<Rhs> for Or<(A, B, C, D, E)> where Rhs: ActiveFilter,`

`type Output = And<(Or<(A, B, C, D, E)>, Rhs)>`

The resulting type after applying the & operator.

`fn bitand(self, rhs: Rhs) -> <Or<(A, B, C, D, E)> as BitAnd<Rhs>>::Output`

`impl<A, B, C, D, E, F, G, H, I, J, K, Rhs> BitAnd<Rhs> for Or<(A, B, C, D, E, F, G, H, I, J, K)> where Rhs: ActiveFilter,`

`type Output = And<(Or<(A, B, C, D, E, F, G, H, I, J, K)>, Rhs)>`

The resulting type after applying the & operator.

`fn bitand( self, rhs: Rhs ) -> <Or<(A, B, C, D, E, F, G, H, I, J, K)> as BitAnd<Rhs>>::Output`

`impl<A, B, C, D, E, F, G, H, I, J, K, L, Rhs> BitAnd<Rhs> for Or<(A, B, C, D, E, F, G, H, I, J, K, L)> where Rhs: ActiveFilter,`

`type Output = And<(Or<(A, B, C, D, E, F, G, H, I, J, K, L)>, Rhs)>`

The resulting type after applying the & operator.

`fn bitand( self, rhs: Rhs ) -> <Or<(A, B, C, D, E, F, G, H, I, J, K, L)> as BitAnd<Rhs>>::Output`

`impl<A, B, Rhs> BitAnd<Rhs> for Or<(A, B)> where Rhs: ActiveFilter,`

`type Output = And<(Or<(A, B)>, Rhs)>`

The resulting type after applying the & operator.

`fn bitand(self, rhs: Rhs) -> <Or<(A, B)> as BitAnd<Rhs>>::Output`

`impl<A, B, C, D, E, F, G, H, I, Rhs> BitAnd<Rhs> for Or<(A, B, C, D, E, F, G, H, I)> where Rhs: ActiveFilter,`

`type Output = And<(Or<(A, B, C, D, E, F, G, H, I)>, Rhs)>`

The resulting type after applying the & operator.

`fn bitand( self, rhs: Rhs ) -> <Or<(A, B, C, D, E, F, G, H, I)> as BitAnd<Rhs>>::Output`

`impl<A, B, C, D, Rhs> BitAnd<Rhs> for Or<(A, B, C, D)> where Rhs: ActiveFilter,`

`type Output = And<(Or<(A, B, C, D)>, Rhs)>`

The resulting type after applying the & operator.

`fn bitand(self, rhs: Rhs) -> <Or<(A, B, C, D)> as BitAnd<Rhs>>::Output`

`impl<A, B, C, Rhs> BitAnd<Rhs> for Or<(A, B, C)> where Rhs: ActiveFilter,`

`type Output = And<(Or<(A, B, C)>, Rhs)>`

The resulting type after applying the & operator.

`fn bitand(self, rhs: Rhs) -> <Or<(A, B, C)> as BitAnd<Rhs>>::Output`

`impl<A, B, C, D, E, F, G, Rhs> BitAnd<Rhs> for Or<(A, B, C, D, E, F, G)> where Rhs: ActiveFilter,`

`type Output = And<(Or<(A, B, C, D, E, F, G)>, Rhs)>`

The resulting type after applying the & operator.

`fn bitand(self, rhs: Rhs) -> <Or<(A, B, C, D, E, F, G)> as BitAnd<Rhs>>::Output`

`impl<A, B, C, D, E, F, Rhs> BitAnd<Rhs> for Or<(A, B, C, D, E, F)> where Rhs: ActiveFilter,`

`type Output = And<(Or<(A, B, C, D, E, F)>, Rhs)>`

The resulting type after applying the & operator.

`fn bitand(self, rhs: Rhs) -> <Or<(A, B, C, D, E, F)> as BitAnd<Rhs>>::Output`

`impl<A, B, C, D, E, F, G, H, I, J, Rhs> BitAnd<Rhs> for Or<(A, B, C, D, E, F, G, H, I, J)> where Rhs: ActiveFilter,`

`type Output = And<(Or<(A, B, C, D, E, F, G, H, I, J)>, Rhs)>`

The resulting type after applying the & operator.

`fn bitand( self, rhs: Rhs ) -> <Or<(A, B, C, D, E, F, G, H, I, J)> as BitAnd<Rhs>>::Output`

`impl<A, B, C> BitOr<Passthrough> for Or<(A, B, C)>`

`type Output = Or<(A, B, C)>`

The resulting type after applying the | operator.

`fn bitor(self, Passthrough) -> <Or<(A, B, C)> as BitOr<Passthrough>>::Output`

`impl<A, B, C, D, E, F, G, H> BitOr<Passthrough> for Or<(A, B, C, D, E, F, G, H)>`

`type Output = Or<(A, B, C, D, E, F, G, H)>`

The resulting type after applying the | operator.

`fn bitor( self, Passthrough ) -> <Or<(A, B, C, D, E, F, G, H)> as BitOr<Passthrough>>::Output`

`impl<A, B, C, D, E, F, G, H, I> BitOr<Passthrough> for Or<(A, B, C, D, E, F, G, H, I)>`

`type Output = Or<(A, B, C, D, E, F, G, H, I)>`

The resulting type after applying the | operator.

`fn bitor( self, Passthrough ) -> <Or<(A, B, C, D, E, F, G, H, I)> as BitOr<Passthrough>>::Output`

`impl<A, B, C, D, E> BitOr<Passthrough> for Or<(A, B, C, D, E)>`

`type Output = Or<(A, B, C, D, E)>`

The resulting type after applying the | operator.

`fn bitor( self, Passthrough ) -> <Or<(A, B, C, D, E)> as BitOr<Passthrough>>::Output`

`impl<A, B, C, D, E, F, G, H, I, J, K> BitOr<Passthrough> for Or<(A, B, C, D, E, F, G, H, I, J, K)>`

`type Output = Or<(A, B, C, D, E, F, G, H, I, J, K)>`

The resulting type after applying the | operator.

`fn bitor( self, Passthrough ) -> <Or<(A, B, C, D, E, F, G, H, I, J, K)> as BitOr<Passthrough>>::Output`

`impl<A, B, C, D> BitOr<Passthrough> for Or<(A, B, C, D)>`

`type Output = Or<(A, B, C, D)>`

The resulting type after applying the | operator.

`fn bitor(self, Passthrough) -> <Or<(A, B, C, D)> as BitOr<Passthrough>>::Output`

`impl<A, B> BitOr<Passthrough> for Or<(A, B)>`

`type Output = Or<(A, B)>`

The resulting type after applying the | operator.

`fn bitor(self, Passthrough) -> <Or<(A, B)> as BitOr<Passthrough>>::Output`

`impl<A, B, C, D, E, F> BitOr<Passthrough> for Or<(A, B, C, D, E, F)>`

`type Output = Or<(A, B, C, D, E, F)>`

The resulting type after applying the | operator.

`fn bitor( self, Passthrough ) -> <Or<(A, B, C, D, E, F)> as BitOr<Passthrough>>::Output`

`impl<A, B, C, D, E, F, G, H, I, J, K, L> BitOr<Passthrough> for Or<(A, B, C, D, E, F, G, H, I, J, K, L)>`

`type Output = Or<(A, B, C, D, E, F, G, H, I, J, K, L)>`

The resulting type after applying the | operator.

`fn bitor( self, Passthrough ) -> <Or<(A, B, C, D, E, F, G, H, I, J, K, L)> as BitOr<Passthrough>>::Output`

`impl<A, B, C, D, E, F, G, H, I, J> BitOr<Passthrough> for Or<(A, B, C, D, E, F, G, H, I, J)>`

`type Output = Or<(A, B, C, D, E, F, G, H, I, J)>`

The resulting type after applying the | operator.

`fn bitor( self, Passthrough ) -> <Or<(A, B, C, D, E, F, G, H, I, J)> as BitOr<Passthrough>>::Output`

`impl<A, B, C, D, E, F, G> BitOr<Passthrough> for Or<(A, B, C, D, E, F, G)>`

`type Output = Or<(A, B, C, D, E, F, G)>`

The resulting type after applying the | operator.

`fn bitor( self, Passthrough ) -> <Or<(A, B, C, D, E, F, G)> as BitOr<Passthrough>>::Output`

`impl<A, B, C, D, E, F, G, H, I, J, Rhs> BitOr<Rhs> for Or<(A, B, C, D, E, F, G, H, I, J)> where Rhs: ActiveFilter,`

`type Output = Or<(A, B, C, D, E, F, G, H, I, J, Rhs)>`

The resulting type after applying the | operator.

`fn bitor( self, rhs: Rhs ) -> <Or<(A, B, C, D, E, F, G, H, I, J)> as BitOr<Rhs>>::Output`

`impl<A, B, C, D, E, F, G, H, I, Rhs> BitOr<Rhs> for Or<(A, B, C, D, E, F, G, H, I)> where Rhs: ActiveFilter,`

`type Output = Or<(A, B, C, D, E, F, G, H, I, Rhs)>`

The resulting type after applying the | operator.

`fn bitor( self, rhs: Rhs ) -> <Or<(A, B, C, D, E, F, G, H, I)> as BitOr<Rhs>>::Output`

`impl<A, B, C, D, E, F, G, H, I, J, K, Rhs> BitOr<Rhs> for Or<(A, B, C, D, E, F, G, H, I, J, K)> where Rhs: ActiveFilter,`

`type Output = Or<(A, B, C, D, E, F, G, H, I, J, K, Rhs)>`

The resulting type after applying the | operator.

`fn bitor( self, rhs: Rhs ) -> <Or<(A, B, C, D, E, F, G, H, I, J, K)> as BitOr<Rhs>>::Output`

`impl<A, B, C, D, E, F, G, Rhs> BitOr<Rhs> for Or<(A, B, C, D, E, F, G)> where Rhs: ActiveFilter,`

`type Output = Or<(A, B, C, D, E, F, G, Rhs)>`

The resulting type after applying the | operator.

`fn bitor(self, rhs: Rhs) -> <Or<(A, B, C, D, E, F, G)> as BitOr<Rhs>>::Output`

`impl<A, B, C, D, E, Rhs> BitOr<Rhs> for Or<(A, B, C, D, E)> where Rhs: ActiveFilter,`

`type Output = Or<(A, B, C, D, E, Rhs)>`

The resulting type after applying the | operator.

`fn bitor(self, rhs: Rhs) -> <Or<(A, B, C, D, E)> as BitOr<Rhs>>::Output`

`impl<A, B, Rhs> BitOr<Rhs> for Or<(A, B)> where Rhs: ActiveFilter,`

`type Output = Or<(A, B, Rhs)>`

The resulting type after applying the | operator.

`fn bitor(self, rhs: Rhs) -> <Or<(A, B)> as BitOr<Rhs>>::Output`

`impl<A, B, C, D, E, F, G, H, Rhs> BitOr<Rhs> for Or<(A, B, C, D, E, F, G, H)> where Rhs: ActiveFilter,`

`type Output = Or<(A, B, C, D, E, F, G, H, Rhs)>`

The resulting type after applying the | operator.

`fn bitor(self, rhs: Rhs) -> <Or<(A, B, C, D, E, F, G, H)> as BitOr<Rhs>>::Output`

`impl<A, B, C, Rhs> BitOr<Rhs> for Or<(A, B, C)> where Rhs: ActiveFilter,`

`type Output = Or<(A, B, C, Rhs)>`

The resulting type after applying the | operator.

`fn bitor(self, rhs: Rhs) -> <Or<(A, B, C)> as BitOr<Rhs>>::Output`

`impl<A, B, C, D, Rhs> BitOr<Rhs> for Or<(A, B, C, D)> where Rhs: ActiveFilter,`

`type Output = Or<(A, B, C, D, Rhs)>`

The resulting type after applying the | operator.

`fn bitor(self, rhs: Rhs) -> <Or<(A, B, C, D)> as BitOr<Rhs>>::Output`

`impl<A, B, C, D, E, F, Rhs> BitOr<Rhs> for Or<(A, B, C, D, E, F)> where Rhs: ActiveFilter,`

`type Output = Or<(A, B, C, D, E, F, Rhs)>`

The resulting type after applying the | operator.

`fn bitor(self, rhs: Rhs) -> <Or<(A, B, C, D, E, F)> as BitOr<Rhs>>::Output`

`impl<A, B, C, D, E, F, G, H, I, J, K, L, Rhs> BitOr<Rhs> for Or<(A, B, C, D, E, F, G, H, I, J, K, L)> where Rhs: ActiveFilter,`

`type Output = Or<(A, B, C, D, E, F, G, H, I, J, K, L, Rhs)>`

The resulting type after applying the | operator.

`fn bitor( self, rhs: Rhs ) -> <Or<(A, B, C, D, E, F, G, H, I, J, K, L)> as BitOr<Rhs>>::Output`

`impl<T> Clone for Or<T> where T: Clone,`

`fn clone(&self) -> Or<T>`

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

`impl<T> Debug for Or<T> where T: Debug,`

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`

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

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

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

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

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

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

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

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

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

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

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

`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, B, C, D, E, F> Not for Or<(A, B, C, D, E, F)>`

`type Output = Not<Or<(A, B, C, D, E, F)>>`

The resulting type after applying the ! operator.

`fn not(self) -> <Or<(A, B, C, D, E, F)> as Not>::Output`

`impl<A, B, C, D, E> Not for Or<(A, B, C, D, E)>`

`type Output = Not<Or<(A, B, C, D, E)>>`

The resulting type after applying the ! operator.

`fn not(self) -> <Or<(A, B, C, D, E)> as Not>::Output`

`impl<A, B, C, D, E, F, G, H, I, J> Not for Or<(A, B, C, D, E, F, G, H, I, J)>`

`type Output = Not<Or<(A, B, C, D, E, F, G, H, I, J)>>`

The resulting type after applying the ! operator.

`fn not(self) -> <Or<(A, B, C, D, E, F, G, H, I, J)> as Not>::Output`

`impl<A, B, C, D, E, F, G, H, I> Not for Or<(A, B, C, D, E, F, G, H, I)>`

`type Output = Not<Or<(A, B, C, D, E, F, G, H, I)>>`

The resulting type after applying the ! operator.

`fn not(self) -> <Or<(A, B, C, D, E, F, G, H, I)> as Not>::Output`

`impl<A, B, C, D, E, F, G> Not for Or<(A, B, C, D, E, F, G)>`

`type Output = Not<Or<(A, B, C, D, E, F, G)>>`

The resulting type after applying the ! operator.

`fn not(self) -> <Or<(A, B, C, D, E, F, G)> as Not>::Output`

`impl<A, B> Not for Or<(A, B)>`

`type Output = Not<Or<(A, B)>>`

The resulting type after applying the ! operator.

`fn not(self) -> <Or<(A, B)> as Not>::Output`

`impl<A, B, C, D> Not for Or<(A, B, C, D)>`

`type Output = Not<Or<(A, B, C, D)>>`

The resulting type after applying the ! operator.

`fn not(self) -> <Or<(A, B, C, D)> as Not>::Output`

`impl<A, B, C, D, E, F, G, H, I, J, K> Not for Or<(A, B, C, D, E, F, G, H, I, J, K)>`

`type Output = Not<Or<(A, B, C, D, E, F, G, H, I, J, K)>>`

The resulting type after applying the ! operator.

`fn not(self) -> <Or<(A, B, C, D, E, F, G, H, I, J, K)> as Not>::Output`

`impl<A, B, C> Not for Or<(A, B, C)>`

`type Output = Not<Or<(A, B, C)>>`

The resulting type after applying the ! operator.

`fn not(self) -> <Or<(A, B, C)> as Not>::Output`

`impl<A, B, C, D, E, F, G, H, I, J, K, L> Not for Or<(A, B, C, D, E, F, G, H, I, J, K, L)>`

`type Output = Not<Or<(A, B, C, D, E, F, G, H, I, J, K, L)>>`

The resulting type after applying the ! operator.

`fn not(self) -> <Or<(A, B, C, D, E, F, G, H, I, J, K, L)> as Not>::Output`

`impl<A, B, C, D, E, F, G, H> Not for Or<(A, B, C, D, E, F, G, H)>`

`type Output = Not<Or<(A, B, C, D, E, F, G, H)>>`

The resulting type after applying the ! operator.

`fn not(self) -> <Or<(A, B, C, D, E, F, G, H)> as Not>::Output`

Auto Trait Implementations

`impl<T> RefUnwindSafe for Or<T> where T: RefUnwindSafe,`

`impl<T> Send for Or<T> where T: Send,`

`impl<T> Sync for Or<T> where T: Sync,`

`impl<T> Unpin for Or<T> where T: Unpin,`

`impl<T> UnwindSafe for Or<T> where T: UnwindSafe,`

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

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

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

[−]Struct acute_ecs::filter::Or

Fields

Trait Implementations

impl<A, B, C, D, E, F, G, H> ActiveFilter for Or<(A, B, C, D, E, F, G, H)>

impl<A, B, C, D, E, F, G> ActiveFilter for Or<(A, B, C, D, E, F, G)>

impl<A, B, C, D> ActiveFilter for Or<(A, B, C, D)>

impl<A, B, C, D, E, F, G, H, I, J, K> ActiveFilter for Or<(A, B, C, D, E, F, G, H, I, J, K)>

impl<A, B, C> ActiveFilter for Or<(A, B, C)>

impl<A, B> ActiveFilter for Or<(A, B)>

impl<A, B, C, D, E, F, G, H, I, J> ActiveFilter for Or<(A, B, C, D, E, F, G, H, I, J)>

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

impl<A, B, C, D, E> ActiveFilter for Or<(A, B, C, D, E)>

impl<A, B, C, D, E, F, G, H, I> ActiveFilter for Or<(A, B, C, D, E, F, G, H, I)>

impl<A, B, C, D, E, F> ActiveFilter for Or<(A, B, C, D, E, F)>

impl<A, B, C, D, E, F, G, H, I, J> BitAnd<Passthrough> for Or<(A, B, C, D, E, F, G, H, I, J)>

type Output = Or<(A, B, C, D, E, F, G, H, I, J)>

fn bitand( self, Passthrough) -> <Or<(A, B, C, D, E, F, G, H, I, J)> as BitAnd<Passthrough>>::Output

impl<A, B, C, D, E> BitAnd<Passthrough> for Or<(A, B, C, D, E)>

type Output = Or<(A, B, C, D, E)>

fn bitand( self, Passthrough) -> <Or<(A, B, C, D, E)> as BitAnd<Passthrough>>::Output

impl<A, B, C, D, E, F> BitAnd<Passthrough> for Or<(A, B, C, D, E, F)>

type Output = Or<(A, B, C, D, E, F)>

fn bitand( self, Passthrough) -> <Or<(A, B, C, D, E, F)> as BitAnd<Passthrough>>::Output

impl<A, B, C> BitAnd<Passthrough> for Or<(A, B, C)>

type Output = Or<(A, B, C)>

fn bitand(self, Passthrough) -> <Or<(A, B, C)> as BitAnd<Passthrough>>::Output

impl<A, B> BitAnd<Passthrough> for Or<(A, B)>

type Output = Or<(A, B)>

fn bitand(self, Passthrough) -> <Or<(A, B)> as BitAnd<Passthrough>>::Output

impl<A, B, C, D, E, F, G, H, I, J, K, L> BitAnd<Passthrough> for Or<(A, B, C, D, E, F, G, H, I, J, K, L)>

type Output = Or<(A, B, C, D, E, F, G, H, I, J, K, L)>

fn bitand( self, Passthrough) -> <Or<(A, B, C, D, E, F, G, H, I, J, K, L)> as BitAnd<Passthrough>>::Output

impl<A, B, C, D, E, F, G, H, I, J, K> BitAnd<Passthrough> for Or<(A, B, C, D, E, F, G, H, I, J, K)>

type Output = Or<(A, B, C, D, E, F, G, H, I, J, K)>

fn bitand( self, Passthrough) -> <Or<(A, B, C, D, E, F, G, H, I, J, K)> as BitAnd<Passthrough>>::Output

impl<A, B, C, D, E, F, G> BitAnd<Passthrough> for Or<(A, B, C, D, E, F, G)>

type Output = Or<(A, B, C, D, E, F, G)>

fn bitand( self, Passthrough) -> <Or<(A, B, C, D, E, F, G)> as BitAnd<Passthrough>>::Output

impl<A, B, C, D, E, F, G, H> BitAnd<Passthrough> for Or<(A, B, C, D, E, F, G, H)>

type Output = Or<(A, B, C, D, E, F, G, H)>

fn bitand( self, Passthrough) -> <Or<(A, B, C, D, E, F, G, H)> as BitAnd<Passthrough>>::Output

impl<A, B, C, D> BitAnd<Passthrough> for Or<(A, B, C, D)>

type Output = Or<(A, B, C, D)>

fn bitand( self, Passthrough) -> <Or<(A, B, C, D)> as BitAnd<Passthrough>>::Output

impl<A, B, C, D, E, F, G, H, I> BitAnd<Passthrough> for Or<(A, B, C, D, E, F, G, H, I)>

type Output = Or<(A, B, C, D, E, F, G, H, I)>

fn bitand( self, Passthrough) -> <Or<(A, B, C, D, E, F, G, H, I)> as BitAnd<Passthrough>>::Output

impl<A, B, C, D, E, F, G, H, Rhs> BitAnd<Rhs> for Or<(A, B, C, D, E, F, G, H)> where Rhs: ActiveFilter,

type Output = And<(Or<(A, B, C, D, E, F, G, H)>, Rhs)>

fn bitand( self, rhs: Rhs) -> <Or<(A, B, C, D, E, F, G, H)> as BitAnd<Rhs>>::Output

impl<A, B, C, D, E, Rhs> BitAnd<Rhs> for Or<(A, B, C, D, E)> where Rhs: ActiveFilter,

type Output = And<(Or<(A, B, C, D, E)>, Rhs)>

fn bitand(self, rhs: Rhs) -> <Or<(A, B, C, D, E)> as BitAnd<Rhs>>::Output

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

type Output = And<(Or<(A, B, C, D, E, F, G, H, I, J, K)>, Rhs)>

fn bitand( self, rhs: Rhs) -> <Or<(A, B, C, D, E, F, G, H, I, J, K)> as BitAnd<Rhs>>::Output

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

type Output = And<(Or<(A, B, C, D, E, F, G, H, I, J, K, L)>, Rhs)>

fn bitand( self, rhs: Rhs) -> <Or<(A, B, C, D, E, F, G, H, I, J, K, L)> as BitAnd<Rhs>>::Output

impl<A, B, Rhs> BitAnd<Rhs> for Or<(A, B)> where Rhs: ActiveFilter,

type Output = And<(Or<(A, B)>, Rhs)>

fn bitand(self, rhs: Rhs) -> <Or<(A, B)> as BitAnd<Rhs>>::Output

impl<A, B, C, D, E, F, G, H, I, Rhs> BitAnd<Rhs> for Or<(A, B, C, D, E, F, G, H, I)> where Rhs: ActiveFilter,

type Output = And<(Or<(A, B, C, D, E, F, G, H, I)>, Rhs)>

fn bitand( self, rhs: Rhs) -> <Or<(A, B, C, D, E, F, G, H, I)> as BitAnd<Rhs>>::Output

impl<A, B, C, D, Rhs> BitAnd<Rhs> for Or<(A, B, C, D)> where Rhs: ActiveFilter,

type Output = And<(Or<(A, B, C, D)>, Rhs)>

fn bitand(self, rhs: Rhs) -> <Or<(A, B, C, D)> as BitAnd<Rhs>>::Output

impl<A, B, C, Rhs> BitAnd<Rhs> for Or<(A, B, C)> where Rhs: ActiveFilter,

type Output = And<(Or<(A, B, C)>, Rhs)>

fn bitand(self, rhs: Rhs) -> <Or<(A, B, C)> as BitAnd<Rhs>>::Output

impl<A, B, C, D, E, F, G, Rhs> BitAnd<Rhs> for Or<(A, B, C, D, E, F, G)> where Rhs: ActiveFilter,

type Output = And<(Or<(A, B, C, D, E, F, G)>, Rhs)>

fn bitand(self, rhs: Rhs) -> <Or<(A, B, C, D, E, F, G)> as BitAnd<Rhs>>::Output

impl<A, B, C, D, E, F, Rhs> BitAnd<Rhs> for Or<(A, B, C, D, E, F)> where Rhs: ActiveFilter,

type Output = And<(Or<(A, B, C, D, E, F)>, Rhs)>

fn bitand(self, rhs: Rhs) -> <Or<(A, B, C, D, E, F)> as BitAnd<Rhs>>::Output

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

type Output = And<(Or<(A, B, C, D, E, F, G, H, I, J)>, Rhs)>

fn bitand( self, rhs: Rhs) -> <Or<(A, B, C, D, E, F, G, H, I, J)> as BitAnd<Rhs>>::Output

`impl<A, B, C, D, E, F, G, H> ActiveFilter for Or<(A, B, C, D, E, F, G, H)>`

`impl<A, B, C, D, E, F, G> ActiveFilter for Or<(A, B, C, D, E, F, G)>`

`impl<A, B, C, D> ActiveFilter for Or<(A, B, C, D)>`

`impl<A, B, C, D, E, F, G, H, I, J, K> ActiveFilter for Or<(A, B, C, D, E, F, G, H, I, J, K)>`

`impl<A, B, C> ActiveFilter for Or<(A, B, C)>`

`impl<A, B> ActiveFilter for Or<(A, B)>`

`impl<A, B, C, D, E, F, G, H, I, J> ActiveFilter for Or<(A, B, C, D, E, F, G, H, I, J)>`

`impl<A, B, C, D, E, F, G, H, I, J, K, L> ActiveFilter for Or<(A, B, C, D, E, F, G, H, I, J, K, L)>`

`impl<A, B, C, D, E> ActiveFilter for Or<(A, B, C, D, E)>`

`impl<A, B, C, D, E, F, G, H, I> ActiveFilter for Or<(A, B, C, D, E, F, G, H, I)>`

`impl<A, B, C, D, E, F> ActiveFilter for Or<(A, B, C, D, E, F)>`

`impl<A, B, C, D, E, F, G, H, I, J> BitAnd<Passthrough> for Or<(A, B, C, D, E, F, G, H, I, J)>`

`type Output = Or<(A, B, C, D, E, F, G, H, I, J)>`

`fn bitand( self, Passthrough ) -> <Or<(A, B, C, D, E, F, G, H, I, J)> as BitAnd<Passthrough>>::Output`

`impl<A, B, C, D, E> BitAnd<Passthrough> for Or<(A, B, C, D, E)>`

`type Output = Or<(A, B, C, D, E)>`

`fn bitand( self, Passthrough ) -> <Or<(A, B, C, D, E)> as BitAnd<Passthrough>>::Output`

`impl<A, B, C, D, E, F> BitAnd<Passthrough> for Or<(A, B, C, D, E, F)>`

`type Output = Or<(A, B, C, D, E, F)>`

`fn bitand( self, Passthrough ) -> <Or<(A, B, C, D, E, F)> as BitAnd<Passthrough>>::Output`

`impl<A, B, C> BitAnd<Passthrough> for Or<(A, B, C)>`

`type Output = Or<(A, B, C)>`

`fn bitand(self, Passthrough) -> <Or<(A, B, C)> as BitAnd<Passthrough>>::Output`

`impl<A, B> BitAnd<Passthrough> for Or<(A, B)>`

`type Output = Or<(A, B)>`

`fn bitand(self, Passthrough) -> <Or<(A, B)> as BitAnd<Passthrough>>::Output`

`impl<A, B, C, D, E, F, G, H, I, J, K, L> BitAnd<Passthrough> for Or<(A, B, C, D, E, F, G, H, I, J, K, L)>`

`type Output = Or<(A, B, C, D, E, F, G, H, I, J, K, L)>`

`fn bitand( self, Passthrough ) -> <Or<(A, B, C, D, E, F, G, H, I, J, K, L)> as BitAnd<Passthrough>>::Output`

`impl<A, B, C, D, E, F, G, H, I, J, K> BitAnd<Passthrough> for Or<(A, B, C, D, E, F, G, H, I, J, K)>`

`type Output = Or<(A, B, C, D, E, F, G, H, I, J, K)>`

`fn bitand( self, Passthrough ) -> <Or<(A, B, C, D, E, F, G, H, I, J, K)> as BitAnd<Passthrough>>::Output`

`impl<A, B, C, D, E, F, G> BitAnd<Passthrough> for Or<(A, B, C, D, E, F, G)>`

`type Output = Or<(A, B, C, D, E, F, G)>`

`fn bitand( self, Passthrough ) -> <Or<(A, B, C, D, E, F, G)> as BitAnd<Passthrough>>::Output`

`impl<A, B, C, D, E, F, G, H> BitAnd<Passthrough> for Or<(A, B, C, D, E, F, G, H)>`

`type Output = Or<(A, B, C, D, E, F, G, H)>`

`fn bitand( self, Passthrough ) -> <Or<(A, B, C, D, E, F, G, H)> as BitAnd<Passthrough>>::Output`

`impl<A, B, C, D> BitAnd<Passthrough> for Or<(A, B, C, D)>`

`type Output = Or<(A, B, C, D)>`

`fn bitand( self, Passthrough ) -> <Or<(A, B, C, D)> as BitAnd<Passthrough>>::Output`

`impl<A, B, C, D, E, F, G, H, I> BitAnd<Passthrough> for Or<(A, B, C, D, E, F, G, H, I)>`

`type Output = Or<(A, B, C, D, E, F, G, H, I)>`

`fn bitand( self, Passthrough ) -> <Or<(A, B, C, D, E, F, G, H, I)> as BitAnd<Passthrough>>::Output`

`impl<A, B, C, D, E, F, G, H, Rhs> BitAnd<Rhs> for Or<(A, B, C, D, E, F, G, H)> where Rhs: ActiveFilter,`

`type Output = And<(Or<(A, B, C, D, E, F, G, H)>, Rhs)>`

`fn bitand( self, rhs: Rhs ) -> <Or<(A, B, C, D, E, F, G, H)> as BitAnd<Rhs>>::Output`

`impl<A, B, C, D, E, Rhs> BitAnd<Rhs> for Or<(A, B, C, D, E)> where Rhs: ActiveFilter,`

`type Output = And<(Or<(A, B, C, D, E)>, Rhs)>`

`fn bitand(self, rhs: Rhs) -> <Or<(A, B, C, D, E)> as BitAnd<Rhs>>::Output`

`impl<A, B, C, D, E, F, G, H, I, J, K, Rhs> BitAnd<Rhs> for Or<(A, B, C, D, E, F, G, H, I, J, K)> where Rhs: ActiveFilter,`

`type Output = And<(Or<(A, B, C, D, E, F, G, H, I, J, K)>, Rhs)>`

`fn bitand( self, rhs: Rhs ) -> <Or<(A, B, C, D, E, F, G, H, I, J, K)> as BitAnd<Rhs>>::Output`

`impl<A, B, C, D, E, F, G, H, I, J, K, L, Rhs> BitAnd<Rhs> for Or<(A, B, C, D, E, F, G, H, I, J, K, L)> where Rhs: ActiveFilter,`

`type Output = And<(Or<(A, B, C, D, E, F, G, H, I, J, K, L)>, Rhs)>`

`fn bitand( self, rhs: Rhs ) -> <Or<(A, B, C, D, E, F, G, H, I, J, K, L)> as BitAnd<Rhs>>::Output`

`impl<A, B, Rhs> BitAnd<Rhs> for Or<(A, B)> where Rhs: ActiveFilter,`

`type Output = And<(Or<(A, B)>, Rhs)>`

`fn bitand(self, rhs: Rhs) -> <Or<(A, B)> as BitAnd<Rhs>>::Output`

`impl<A, B, C, D, E, F, G, H, I, Rhs> BitAnd<Rhs> for Or<(A, B, C, D, E, F, G, H, I)> where Rhs: ActiveFilter,`

`type Output = And<(Or<(A, B, C, D, E, F, G, H, I)>, Rhs)>`

`fn bitand( self, rhs: Rhs ) -> <Or<(A, B, C, D, E, F, G, H, I)> as BitAnd<Rhs>>::Output`

`impl<A, B, C, D, Rhs> BitAnd<Rhs> for Or<(A, B, C, D)> where Rhs: ActiveFilter,`

`type Output = And<(Or<(A, B, C, D)>, Rhs)>`

`fn bitand(self, rhs: Rhs) -> <Or<(A, B, C, D)> as BitAnd<Rhs>>::Output`

`impl<A, B, C, Rhs> BitAnd<Rhs> for Or<(A, B, C)> where Rhs: ActiveFilter,`

`type Output = And<(Or<(A, B, C)>, Rhs)>`

`fn bitand(self, rhs: Rhs) -> <Or<(A, B, C)> as BitAnd<Rhs>>::Output`

`impl<A, B, C, D, E, F, G, Rhs> BitAnd<Rhs> for Or<(A, B, C, D, E, F, G)> where Rhs: ActiveFilter,`

`type Output = And<(Or<(A, B, C, D, E, F, G)>, Rhs)>`

`fn bitand(self, rhs: Rhs) -> <Or<(A, B, C, D, E, F, G)> as BitAnd<Rhs>>::Output`

`impl<A, B, C, D, E, F, Rhs> BitAnd<Rhs> for Or<(A, B, C, D, E, F)> where Rhs: ActiveFilter,`

`type Output = And<(Or<(A, B, C, D, E, F)>, Rhs)>`

`fn bitand(self, rhs: Rhs) -> <Or<(A, B, C, D, E, F)> as BitAnd<Rhs>>::Output`

`impl<A, B, C, D, E, F, G, H, I, J, Rhs> BitAnd<Rhs> for Or<(A, B, C, D, E, F, G, H, I, J)> where Rhs: ActiveFilter,`

`type Output = And<(Or<(A, B, C, D, E, F, G, H, I, J)>, Rhs)>`

`fn bitand( self, rhs: Rhs ) -> <Or<(A, B, C, D, E, F, G, H, I, J)> as BitAnd<Rhs>>::Output`

`impl<A, B, C> BitOr<Passthrough> for Or<(A, B, C)>`

`type Output = Or<(A, B, C)>`

`fn bitor(self, Passthrough) -> <Or<(A, B, C)> as BitOr<Passthrough>>::Output`