Struct fieldmask::BitwiseWrap

pub struct BitwiseWrap<T>(pub T);

Tuple Fields

0: T

Trait Implementations

impl<T> AsMut<T> for BitwiseWrap<T>

fn as_mut(&mut self) -> &mut T

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T> AsRef<T> for BitwiseWrap<T>

fn as_ref(&self) -> &T

Converts this type into a shared reference of the (usually inferred) input type.

impl<T0: BitAnd<Output = T0>> BitAnd for BitwiseWrap<(T0,)>

type Output = BitwiseWrap<(T0,)>

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<T0: BitAnd<Output = T0>, T1: BitAnd<Output = T1>> BitAnd for BitwiseWrap<(T0, T1)>

type Output = BitwiseWrap<(T0, T1)>

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<T0: BitAnd<Output = T0>, T1: BitAnd<Output = T1>, T2: BitAnd<Output = T2>> BitAnd for BitwiseWrap<(T0, T1, T2)>

type Output = BitwiseWrap<(T0, T1, T2)>

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<T0: BitAnd<Output = T0>, T1: BitAnd<Output = T1>, T2: BitAnd<Output = T2>, T3: BitAnd<Output = T3>> BitAnd for BitwiseWrap<(T0, T1, T2, T3)>

type Output = BitwiseWrap<(T0, T1, T2, T3)>

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<T0: BitAnd<Output = T0>, T1: BitAnd<Output = T1>, T2: BitAnd<Output = T2>, T3: BitAnd<Output = T3>, T4: BitAnd<Output = T4>> BitAnd for BitwiseWrap<(T0, T1, T2, T3, T4)>

type Output = BitwiseWrap<(T0, T1, T2, T3, T4)>

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<T0: BitAnd<Output = T0>, T1: BitAnd<Output = T1>, T2: BitAnd<Output = T2>, T3: BitAnd<Output = T3>, T4: BitAnd<Output = T4>, T5: BitAnd<Output = T5>> BitAnd for BitwiseWrap<(T0, T1, T2, T3, T4, T5)>

type Output = BitwiseWrap<(T0, T1, T2, T3, T4, T5)>

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<T0: BitAnd<Output = T0>, T1: BitAnd<Output = T1>, T2: BitAnd<Output = T2>, T3: BitAnd<Output = T3>, T4: BitAnd<Output = T4>, T5: BitAnd<Output = T5>, T6: BitAnd<Output = T6>> BitAnd for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6)>

type Output = BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6)>

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<T0: BitAnd<Output = T0>, T1: BitAnd<Output = T1>, T2: BitAnd<Output = T2>, T3: BitAnd<Output = T3>, T4: BitAnd<Output = T4>, T5: BitAnd<Output = T5>, T6: BitAnd<Output = T6>, T7: BitAnd<Output = T7>> BitAnd for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7)>

type Output = BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7)>

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<T0: BitAnd<Output = T0>, T1: BitAnd<Output = T1>, T2: BitAnd<Output = T2>, T3: BitAnd<Output = T3>, T4: BitAnd<Output = T4>, T5: BitAnd<Output = T5>, T6: BitAnd<Output = T6>, T7: BitAnd<Output = T7>, T8: BitAnd<Output = T8>> BitAnd for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>

type Output = BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<T0: BitAnd<Output = T0>, T1: BitAnd<Output = T1>, T2: BitAnd<Output = T2>, T3: BitAnd<Output = T3>, T4: BitAnd<Output = T4>, T5: BitAnd<Output = T5>, T6: BitAnd<Output = T6>, T7: BitAnd<Output = T7>, T8: BitAnd<Output = T8>, T9: BitAnd<Output = T9>> BitAnd for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>

type Output = BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<T0: BitAnd<Output = T0>, T1: BitAnd<Output = T1>, T2: BitAnd<Output = T2>, T3: BitAnd<Output = T3>, T4: BitAnd<Output = T4>, T5: BitAnd<Output = T5>, T6: BitAnd<Output = T6>, T7: BitAnd<Output = T7>, T8: BitAnd<Output = T8>, T9: BitAnd<Output = T9>, T10: BitAnd<Output = T10>> BitAnd for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>

type Output = BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<T0: BitAnd<Output = T0>, T1: BitAnd<Output = T1>, T2: BitAnd<Output = T2>, T3: BitAnd<Output = T3>, T4: BitAnd<Output = T4>, T5: BitAnd<Output = T5>, T6: BitAnd<Output = T6>, T7: BitAnd<Output = T7>, T8: BitAnd<Output = T8>, T9: BitAnd<Output = T9>, T10: BitAnd<Output = T10>, T11: BitAnd<Output = T11>> BitAnd for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>

type Output = BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<T0: BitAnd<Output = T0>, T1: BitAnd<Output = T1>, T2: BitAnd<Output = T2>, T3: BitAnd<Output = T3>, T4: BitAnd<Output = T4>, T5: BitAnd<Output = T5>, T6: BitAnd<Output = T6>, T7: BitAnd<Output = T7>, T8: BitAnd<Output = T8>, T9: BitAnd<Output = T9>, T10: BitAnd<Output = T10>, T11: BitAnd<Output = T11>, T12: BitAnd<Output = T12>> BitAnd for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>

type Output = BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<T0: BitAndAssign> BitAndAssign for BitwiseWrap<(T0,)>

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl<T0: BitAndAssign, T1: BitAndAssign> BitAndAssign for BitwiseWrap<(T0, T1)>

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl<T0: BitAndAssign, T1: BitAndAssign, T2: BitAndAssign> BitAndAssign for BitwiseWrap<(T0, T1, T2)>

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl<T0: BitAndAssign, T1: BitAndAssign, T2: BitAndAssign, T3: BitAndAssign> BitAndAssign for BitwiseWrap<(T0, T1, T2, T3)>

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl<T0: BitAndAssign, T1: BitAndAssign, T2: BitAndAssign, T3: BitAndAssign, T4: BitAndAssign> BitAndAssign for BitwiseWrap<(T0, T1, T2, T3, T4)>

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl<T0: BitAndAssign, T1: BitAndAssign, T2: BitAndAssign, T3: BitAndAssign, T4: BitAndAssign, T5: BitAndAssign> BitAndAssign for BitwiseWrap<(T0, T1, T2, T3, T4, T5)>

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl<T0: BitAndAssign, T1: BitAndAssign, T2: BitAndAssign, T3: BitAndAssign, T4: BitAndAssign, T5: BitAndAssign, T6: BitAndAssign> BitAndAssign for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6)>

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl<T0: BitAndAssign, T1: BitAndAssign, T2: BitAndAssign, T3: BitAndAssign, T4: BitAndAssign, T5: BitAndAssign, T6: BitAndAssign, T7: BitAndAssign> BitAndAssign for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7)>

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl<T0: BitAndAssign, T1: BitAndAssign, T2: BitAndAssign, T3: BitAndAssign, T4: BitAndAssign, T5: BitAndAssign, T6: BitAndAssign, T7: BitAndAssign, T8: BitAndAssign> BitAndAssign for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl<T0: BitAndAssign, T1: BitAndAssign, T2: BitAndAssign, T3: BitAndAssign, T4: BitAndAssign, T5: BitAndAssign, T6: BitAndAssign, T7: BitAndAssign, T8: BitAndAssign, T9: BitAndAssign> BitAndAssign for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl<T0: BitAndAssign, T1: BitAndAssign, T2: BitAndAssign, T3: BitAndAssign, T4: BitAndAssign, T5: BitAndAssign, T6: BitAndAssign, T7: BitAndAssign, T8: BitAndAssign, T9: BitAndAssign, T10: BitAndAssign> BitAndAssign for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl<T0: BitAndAssign, T1: BitAndAssign, T2: BitAndAssign, T3: BitAndAssign, T4: BitAndAssign, T5: BitAndAssign, T6: BitAndAssign, T7: BitAndAssign, T8: BitAndAssign, T9: BitAndAssign, T10: BitAndAssign, T11: BitAndAssign> BitAndAssign for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl<T0: BitAndAssign, T1: BitAndAssign, T2: BitAndAssign, T3: BitAndAssign, T4: BitAndAssign, T5: BitAndAssign, T6: BitAndAssign, T7: BitAndAssign, T8: BitAndAssign, T9: BitAndAssign, T10: BitAndAssign, T11: BitAndAssign, T12: BitAndAssign> BitAndAssign for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl<T0: BitOr<Output = T0>> BitOr for BitwiseWrap<(T0,)>

type Output = BitwiseWrap<(T0,)>

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<T0: BitOr<Output = T0>, T1: BitOr<Output = T1>> BitOr for BitwiseWrap<(T0, T1)>

type Output = BitwiseWrap<(T0, T1)>

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<T0: BitOr<Output = T0>, T1: BitOr<Output = T1>, T2: BitOr<Output = T2>> BitOr for BitwiseWrap<(T0, T1, T2)>

type Output = BitwiseWrap<(T0, T1, T2)>

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<T0: BitOr<Output = T0>, T1: BitOr<Output = T1>, T2: BitOr<Output = T2>, T3: BitOr<Output = T3>> BitOr for BitwiseWrap<(T0, T1, T2, T3)>

type Output = BitwiseWrap<(T0, T1, T2, T3)>

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<T0: BitOr<Output = T0>, T1: BitOr<Output = T1>, T2: BitOr<Output = T2>, T3: BitOr<Output = T3>, T4: BitOr<Output = T4>> BitOr for BitwiseWrap<(T0, T1, T2, T3, T4)>

type Output = BitwiseWrap<(T0, T1, T2, T3, T4)>

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<T0: BitOr<Output = T0>, T1: BitOr<Output = T1>, T2: BitOr<Output = T2>, T3: BitOr<Output = T3>, T4: BitOr<Output = T4>, T5: BitOr<Output = T5>> BitOr for BitwiseWrap<(T0, T1, T2, T3, T4, T5)>

type Output = BitwiseWrap<(T0, T1, T2, T3, T4, T5)>

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<T0: BitOr<Output = T0>, T1: BitOr<Output = T1>, T2: BitOr<Output = T2>, T3: BitOr<Output = T3>, T4: BitOr<Output = T4>, T5: BitOr<Output = T5>, T6: BitOr<Output = T6>> BitOr for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6)>

type Output = BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6)>

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<T0: BitOr<Output = T0>, T1: BitOr<Output = T1>, T2: BitOr<Output = T2>, T3: BitOr<Output = T3>, T4: BitOr<Output = T4>, T5: BitOr<Output = T5>, T6: BitOr<Output = T6>, T7: BitOr<Output = T7>> BitOr for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7)>

type Output = BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7)>

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<T0: BitOr<Output = T0>, T1: BitOr<Output = T1>, T2: BitOr<Output = T2>, T3: BitOr<Output = T3>, T4: BitOr<Output = T4>, T5: BitOr<Output = T5>, T6: BitOr<Output = T6>, T7: BitOr<Output = T7>, T8: BitOr<Output = T8>> BitOr for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>

type Output = BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<T0: BitOr<Output = T0>, T1: BitOr<Output = T1>, T2: BitOr<Output = T2>, T3: BitOr<Output = T3>, T4: BitOr<Output = T4>, T5: BitOr<Output = T5>, T6: BitOr<Output = T6>, T7: BitOr<Output = T7>, T8: BitOr<Output = T8>, T9: BitOr<Output = T9>> BitOr for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>

type Output = BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<T0: BitOr<Output = T0>, T1: BitOr<Output = T1>, T2: BitOr<Output = T2>, T3: BitOr<Output = T3>, T4: BitOr<Output = T4>, T5: BitOr<Output = T5>, T6: BitOr<Output = T6>, T7: BitOr<Output = T7>, T8: BitOr<Output = T8>, T9: BitOr<Output = T9>, T10: BitOr<Output = T10>> BitOr for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>

type Output = BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<T0: BitOr<Output = T0>, T1: BitOr<Output = T1>, T2: BitOr<Output = T2>, T3: BitOr<Output = T3>, T4: BitOr<Output = T4>, T5: BitOr<Output = T5>, T6: BitOr<Output = T6>, T7: BitOr<Output = T7>, T8: BitOr<Output = T8>, T9: BitOr<Output = T9>, T10: BitOr<Output = T10>, T11: BitOr<Output = T11>> BitOr for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>

type Output = BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<T0: BitOr<Output = T0>, T1: BitOr<Output = T1>, T2: BitOr<Output = T2>, T3: BitOr<Output = T3>, T4: BitOr<Output = T4>, T5: BitOr<Output = T5>, T6: BitOr<Output = T6>, T7: BitOr<Output = T7>, T8: BitOr<Output = T8>, T9: BitOr<Output = T9>, T10: BitOr<Output = T10>, T11: BitOr<Output = T11>, T12: BitOr<Output = T12>> BitOr for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>

type Output = BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<T0: BitOrAssign> BitOrAssign for BitwiseWrap<(T0,)>

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl<T0: BitOrAssign, T1: BitOrAssign> BitOrAssign for BitwiseWrap<(T0, T1)>

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl<T0: BitOrAssign, T1: BitOrAssign, T2: BitOrAssign> BitOrAssign for BitwiseWrap<(T0, T1, T2)>

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl<T0: BitOrAssign, T1: BitOrAssign, T2: BitOrAssign, T3: BitOrAssign> BitOrAssign for BitwiseWrap<(T0, T1, T2, T3)>

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl<T0: BitOrAssign, T1: BitOrAssign, T2: BitOrAssign, T3: BitOrAssign, T4: BitOrAssign> BitOrAssign for BitwiseWrap<(T0, T1, T2, T3, T4)>

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl<T0: BitOrAssign, T1: BitOrAssign, T2: BitOrAssign, T3: BitOrAssign, T4: BitOrAssign, T5: BitOrAssign> BitOrAssign for BitwiseWrap<(T0, T1, T2, T3, T4, T5)>

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl<T0: BitOrAssign, T1: BitOrAssign, T2: BitOrAssign, T3: BitOrAssign, T4: BitOrAssign, T5: BitOrAssign, T6: BitOrAssign> BitOrAssign for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6)>

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl<T0: BitOrAssign, T1: BitOrAssign, T2: BitOrAssign, T3: BitOrAssign, T4: BitOrAssign, T5: BitOrAssign, T6: BitOrAssign, T7: BitOrAssign> BitOrAssign for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7)>

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl<T0: BitOrAssign, T1: BitOrAssign, T2: BitOrAssign, T3: BitOrAssign, T4: BitOrAssign, T5: BitOrAssign, T6: BitOrAssign, T7: BitOrAssign, T8: BitOrAssign> BitOrAssign for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl<T0: BitOrAssign, T1: BitOrAssign, T2: BitOrAssign, T3: BitOrAssign, T4: BitOrAssign, T5: BitOrAssign, T6: BitOrAssign, T7: BitOrAssign, T8: BitOrAssign, T9: BitOrAssign> BitOrAssign for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl<T0: BitOrAssign, T1: BitOrAssign, T2: BitOrAssign, T3: BitOrAssign, T4: BitOrAssign, T5: BitOrAssign, T6: BitOrAssign, T7: BitOrAssign, T8: BitOrAssign, T9: BitOrAssign, T10: BitOrAssign> BitOrAssign for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl<T0: BitOrAssign, T1: BitOrAssign, T2: BitOrAssign, T3: BitOrAssign, T4: BitOrAssign, T5: BitOrAssign, T6: BitOrAssign, T7: BitOrAssign, T8: BitOrAssign, T9: BitOrAssign, T10: BitOrAssign, T11: BitOrAssign> BitOrAssign for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl<T0: BitOrAssign, T1: BitOrAssign, T2: BitOrAssign, T3: BitOrAssign, T4: BitOrAssign, T5: BitOrAssign, T6: BitOrAssign, T7: BitOrAssign, T8: BitOrAssign, T9: BitOrAssign, T10: BitOrAssign, T11: BitOrAssign, T12: BitOrAssign> BitOrAssign for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl<T0: BitXor<Output = T0>> BitXor for BitwiseWrap<(T0,)>

type Output = BitwiseWrap<(T0,)>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<T0: BitXor<Output = T0>, T1: BitXor<Output = T1>> BitXor for BitwiseWrap<(T0, T1)>

type Output = BitwiseWrap<(T0, T1)>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<T0: BitXor<Output = T0>, T1: BitXor<Output = T1>, T2: BitXor<Output = T2>> BitXor for BitwiseWrap<(T0, T1, T2)>

type Output = BitwiseWrap<(T0, T1, T2)>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<T0: BitXor<Output = T0>, T1: BitXor<Output = T1>, T2: BitXor<Output = T2>, T3: BitXor<Output = T3>> BitXor for BitwiseWrap<(T0, T1, T2, T3)>

type Output = BitwiseWrap<(T0, T1, T2, T3)>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<T0: BitXor<Output = T0>, T1: BitXor<Output = T1>, T2: BitXor<Output = T2>, T3: BitXor<Output = T3>, T4: BitXor<Output = T4>> BitXor for BitwiseWrap<(T0, T1, T2, T3, T4)>

type Output = BitwiseWrap<(T0, T1, T2, T3, T4)>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<T0: BitXor<Output = T0>, T1: BitXor<Output = T1>, T2: BitXor<Output = T2>, T3: BitXor<Output = T3>, T4: BitXor<Output = T4>, T5: BitXor<Output = T5>> BitXor for BitwiseWrap<(T0, T1, T2, T3, T4, T5)>

type Output = BitwiseWrap<(T0, T1, T2, T3, T4, T5)>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<T0: BitXor<Output = T0>, T1: BitXor<Output = T1>, T2: BitXor<Output = T2>, T3: BitXor<Output = T3>, T4: BitXor<Output = T4>, T5: BitXor<Output = T5>, T6: BitXor<Output = T6>> BitXor for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6)>

type Output = BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6)>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<T0: BitXor<Output = T0>, T1: BitXor<Output = T1>, T2: BitXor<Output = T2>, T3: BitXor<Output = T3>, T4: BitXor<Output = T4>, T5: BitXor<Output = T5>, T6: BitXor<Output = T6>, T7: BitXor<Output = T7>> BitXor for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7)>

type Output = BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7)>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<T0: BitXor<Output = T0>, T1: BitXor<Output = T1>, T2: BitXor<Output = T2>, T3: BitXor<Output = T3>, T4: BitXor<Output = T4>, T5: BitXor<Output = T5>, T6: BitXor<Output = T6>, T7: BitXor<Output = T7>, T8: BitXor<Output = T8>> BitXor for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>

type Output = BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<T0: BitXor<Output = T0>, T1: BitXor<Output = T1>, T2: BitXor<Output = T2>, T3: BitXor<Output = T3>, T4: BitXor<Output = T4>, T5: BitXor<Output = T5>, T6: BitXor<Output = T6>, T7: BitXor<Output = T7>, T8: BitXor<Output = T8>, T9: BitXor<Output = T9>> BitXor for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>

type Output = BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<T0: BitXor<Output = T0>, T1: BitXor<Output = T1>, T2: BitXor<Output = T2>, T3: BitXor<Output = T3>, T4: BitXor<Output = T4>, T5: BitXor<Output = T5>, T6: BitXor<Output = T6>, T7: BitXor<Output = T7>, T8: BitXor<Output = T8>, T9: BitXor<Output = T9>, T10: BitXor<Output = T10>> BitXor for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>

type Output = BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<T0: BitXor<Output = T0>, T1: BitXor<Output = T1>, T2: BitXor<Output = T2>, T3: BitXor<Output = T3>, T4: BitXor<Output = T4>, T5: BitXor<Output = T5>, T6: BitXor<Output = T6>, T7: BitXor<Output = T7>, T8: BitXor<Output = T8>, T9: BitXor<Output = T9>, T10: BitXor<Output = T10>, T11: BitXor<Output = T11>> BitXor for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>

type Output = BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<T0: BitXor<Output = T0>, T1: BitXor<Output = T1>, T2: BitXor<Output = T2>, T3: BitXor<Output = T3>, T4: BitXor<Output = T4>, T5: BitXor<Output = T5>, T6: BitXor<Output = T6>, T7: BitXor<Output = T7>, T8: BitXor<Output = T8>, T9: BitXor<Output = T9>, T10: BitXor<Output = T10>, T11: BitXor<Output = T11>, T12: BitXor<Output = T12>> BitXor for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>

type Output = BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<T0: BitXorAssign> BitXorAssign for BitwiseWrap<(T0,)>

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl<T0: BitXorAssign, T1: BitXorAssign> BitXorAssign for BitwiseWrap<(T0, T1)>

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl<T0: BitXorAssign, T1: BitXorAssign, T2: BitXorAssign> BitXorAssign for BitwiseWrap<(T0, T1, T2)>

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl<T0: BitXorAssign, T1: BitXorAssign, T2: BitXorAssign, T3: BitXorAssign> BitXorAssign for BitwiseWrap<(T0, T1, T2, T3)>

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl<T0: BitXorAssign, T1: BitXorAssign, T2: BitXorAssign, T3: BitXorAssign, T4: BitXorAssign> BitXorAssign for BitwiseWrap<(T0, T1, T2, T3, T4)>

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl<T0: BitXorAssign, T1: BitXorAssign, T2: BitXorAssign, T3: BitXorAssign, T4: BitXorAssign, T5: BitXorAssign> BitXorAssign for BitwiseWrap<(T0, T1, T2, T3, T4, T5)>

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl<T0: BitXorAssign, T1: BitXorAssign, T2: BitXorAssign, T3: BitXorAssign, T4: BitXorAssign, T5: BitXorAssign, T6: BitXorAssign> BitXorAssign for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6)>

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl<T0: BitXorAssign, T1: BitXorAssign, T2: BitXorAssign, T3: BitXorAssign, T4: BitXorAssign, T5: BitXorAssign, T6: BitXorAssign, T7: BitXorAssign> BitXorAssign for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7)>

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl<T0: BitXorAssign, T1: BitXorAssign, T2: BitXorAssign, T3: BitXorAssign, T4: BitXorAssign, T5: BitXorAssign, T6: BitXorAssign, T7: BitXorAssign, T8: BitXorAssign> BitXorAssign for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl<T0: BitXorAssign, T1: BitXorAssign, T2: BitXorAssign, T3: BitXorAssign, T4: BitXorAssign, T5: BitXorAssign, T6: BitXorAssign, T7: BitXorAssign, T8: BitXorAssign, T9: BitXorAssign> BitXorAssign for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl<T0: BitXorAssign, T1: BitXorAssign, T2: BitXorAssign, T3: BitXorAssign, T4: BitXorAssign, T5: BitXorAssign, T6: BitXorAssign, T7: BitXorAssign, T8: BitXorAssign, T9: BitXorAssign, T10: BitXorAssign> BitXorAssign for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl<T0: BitXorAssign, T1: BitXorAssign, T2: BitXorAssign, T3: BitXorAssign, T4: BitXorAssign, T5: BitXorAssign, T6: BitXorAssign, T7: BitXorAssign, T8: BitXorAssign, T9: BitXorAssign, T10: BitXorAssign, T11: BitXorAssign> BitXorAssign for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl<T0: BitXorAssign, T1: BitXorAssign, T2: BitXorAssign, T3: BitXorAssign, T4: BitXorAssign, T5: BitXorAssign, T6: BitXorAssign, T7: BitXorAssign, T8: BitXorAssign, T9: BitXorAssign, T10: BitXorAssign, T11: BitXorAssign, T12: BitXorAssign> BitXorAssign for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl<T: Debug> Debug for BitwiseWrap<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for BitwiseWrap<T>

fn default() -> BitwiseWrap<T>

Returns the “default value” for a type.

impl<T> Deref for BitwiseWrap<T>

where T: Deref,

type Target = <T as Deref>::Target

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T> DerefMut for BitwiseWrap<T>

where T: DerefMut,

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T> From<T> for BitwiseWrap<T>

fn from(original: T) -> BitwiseWrap<T>

Converts to this type from the input type.

impl<T0: Not<Output = T0>> Not for BitwiseWrap<(T0,)>

type Output = BitwiseWrap<(T0,)>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T0: Not<Output = T0>, T1: Not<Output = T1>> Not for BitwiseWrap<(T0, T1)>

type Output = BitwiseWrap<(T0, T1)>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T0: Not<Output = T0>, T1: Not<Output = T1>, T2: Not<Output = T2>> Not for BitwiseWrap<(T0, T1, T2)>

type Output = BitwiseWrap<(T0, T1, T2)>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T0: Not<Output = T0>, T1: Not<Output = T1>, T2: Not<Output = T2>, T3: Not<Output = T3>> Not for BitwiseWrap<(T0, T1, T2, T3)>

type Output = BitwiseWrap<(T0, T1, T2, T3)>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T0: Not<Output = T0>, T1: Not<Output = T1>, T2: Not<Output = T2>, T3: Not<Output = T3>, T4: Not<Output = T4>> Not for BitwiseWrap<(T0, T1, T2, T3, T4)>

type Output = BitwiseWrap<(T0, T1, T2, T3, T4)>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T0: Not<Output = T0>, T1: Not<Output = T1>, T2: Not<Output = T2>, T3: Not<Output = T3>, T4: Not<Output = T4>, T5: Not<Output = T5>> Not for BitwiseWrap<(T0, T1, T2, T3, T4, T5)>

type Output = BitwiseWrap<(T0, T1, T2, T3, T4, T5)>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T0: Not<Output = T0>, T1: Not<Output = T1>, T2: Not<Output = T2>, T3: Not<Output = T3>, T4: Not<Output = T4>, T5: Not<Output = T5>, T6: Not<Output = T6>> Not for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6)>

type Output = BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6)>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T0: Not<Output = T0>, T1: Not<Output = T1>, T2: Not<Output = T2>, T3: Not<Output = T3>, T4: Not<Output = T4>, T5: Not<Output = T5>, T6: Not<Output = T6>, T7: Not<Output = T7>> Not for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7)>

type Output = BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7)>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T0: Not<Output = T0>, T1: Not<Output = T1>, T2: Not<Output = T2>, T3: Not<Output = T3>, T4: Not<Output = T4>, T5: Not<Output = T5>, T6: Not<Output = T6>, T7: Not<Output = T7>, T8: Not<Output = T8>> Not for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>

type Output = BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T0: Not<Output = T0>, T1: Not<Output = T1>, T2: Not<Output = T2>, T3: Not<Output = T3>, T4: Not<Output = T4>, T5: Not<Output = T5>, T6: Not<Output = T6>, T7: Not<Output = T7>, T8: Not<Output = T8>, T9: Not<Output = T9>> Not for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>

type Output = BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T0: Not<Output = T0>, T1: Not<Output = T1>, T2: Not<Output = T2>, T3: Not<Output = T3>, T4: Not<Output = T4>, T5: Not<Output = T5>, T6: Not<Output = T6>, T7: Not<Output = T7>, T8: Not<Output = T8>, T9: Not<Output = T9>, T10: Not<Output = T10>> Not for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>

type Output = BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T0: Not<Output = T0>, T1: Not<Output = T1>, T2: Not<Output = T2>, T3: Not<Output = T3>, T4: Not<Output = T4>, T5: Not<Output = T5>, T6: Not<Output = T6>, T7: Not<Output = T7>, T8: Not<Output = T8>, T9: Not<Output = T9>, T10: Not<Output = T10>, T11: Not<Output = T11>> Not for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>

type Output = BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T0: Not<Output = T0>, T1: Not<Output = T1>, T2: Not<Output = T2>, T3: Not<Output = T3>, T4: Not<Output = T4>, T5: Not<Output = T5>, T6: Not<Output = T6>, T7: Not<Output = T7>, T8: Not<Output = T8>, T9: Not<Output = T9>, T10: Not<Output = T10>, T11: Not<Output = T11>, T12: Not<Output = T12>> Not for BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>

type Output = BitwiseWrap<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T: PartialEq> PartialEq for BitwiseWrap<T>

fn eq(&self, other: &BitwiseWrap<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Eq> Eq for BitwiseWrap<T>

impl<T> StructuralPartialEq for BitwiseWrap<T>