Trait intbits::BitsIndex

pub trait BitsIndex<T> {
    fn bit(value: T, index: Self) -> bool;
    fn bits<R>(value: T, range: R) -> <T as Bits>::Bits
    where
        T: Bits,
        R: RangeBounds<Self>;
    fn set_bit(value: &mut T, index: Self, bit: bool);
    fn set_bits<R>(value: &mut T, range: R, bits: <T as Bits>::Bits)
    where
        T: Bits,
        R: RangeBounds<Self>;
}

Trait for types that can be used to index the bits of T.

Required methods

fn bit(value: T, index: Self) -> bool

See Bits::bit.

fn bits<R>(value: T, range: R) -> <T as Bits>::Bits where
    T: Bits,
    R: RangeBounds<Self>, 

See Bits::bits.

fn set_bit(value: &mut T, index: Self, bit: bool)

See Bits::set_bit.

fn set_bits<R>(value: &mut T, range: R, bits: <T as Bits>::Bits) where
    T: Bits,
    R: RangeBounds<Self>, 

See Bits::set_bits.

Loading content...

Implementors

impl BitsIndex<i8> for i8

fn bit(v: i8, i: Self) -> bool

fn bits<R>(v: i8, range: R) -> u8 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i8, i: Self, bit: bool)

fn set_bits<R>(v: &mut i8, range: R, bits: u8) where
    R: RangeBounds<Self>, 

impl BitsIndex<i8> for i16

fn bit(v: i8, i: Self) -> bool

fn bits<R>(v: i8, range: R) -> u8 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i8, i: Self, bit: bool)

fn set_bits<R>(v: &mut i8, range: R, bits: u8) where
    R: RangeBounds<Self>, 

impl BitsIndex<i8> for i32

fn bit(v: i8, i: Self) -> bool

fn bits<R>(v: i8, range: R) -> u8 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i8, i: Self, bit: bool)

fn set_bits<R>(v: &mut i8, range: R, bits: u8) where
    R: RangeBounds<Self>, 

impl BitsIndex<i8> for i64

fn bit(v: i8, i: Self) -> bool

fn bits<R>(v: i8, range: R) -> u8 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i8, i: Self, bit: bool)

fn set_bits<R>(v: &mut i8, range: R, bits: u8) where
    R: RangeBounds<Self>, 

impl BitsIndex<i8> for i128

fn bit(v: i8, i: Self) -> bool

fn bits<R>(v: i8, range: R) -> u8 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i8, i: Self, bit: bool)

fn set_bits<R>(v: &mut i8, range: R, bits: u8) where
    R: RangeBounds<Self>, 

impl BitsIndex<i8> for isize

fn bit(v: i8, i: Self) -> bool

fn bits<R>(v: i8, range: R) -> u8 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i8, i: Self, bit: bool)

fn set_bits<R>(v: &mut i8, range: R, bits: u8) where
    R: RangeBounds<Self>, 

impl BitsIndex<i8> for u8

fn bit(v: i8, i: Self) -> bool

fn bits<R>(v: i8, range: R) -> u8 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i8, i: Self, bit: bool)

fn set_bits<R>(v: &mut i8, range: R, bits: u8) where
    R: RangeBounds<Self>, 

impl BitsIndex<i8> for u16

fn bit(v: i8, i: Self) -> bool

fn bits<R>(v: i8, range: R) -> u8 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i8, i: Self, bit: bool)

fn set_bits<R>(v: &mut i8, range: R, bits: u8) where
    R: RangeBounds<Self>, 

impl BitsIndex<i8> for u32

fn bit(v: i8, i: Self) -> bool

fn bits<R>(v: i8, range: R) -> u8 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i8, i: Self, bit: bool)

fn set_bits<R>(v: &mut i8, range: R, bits: u8) where
    R: RangeBounds<Self>, 

impl BitsIndex<i8> for u64

fn bit(v: i8, i: Self) -> bool

fn bits<R>(v: i8, range: R) -> u8 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i8, i: Self, bit: bool)

fn set_bits<R>(v: &mut i8, range: R, bits: u8) where
    R: RangeBounds<Self>, 

impl BitsIndex<i8> for u128

fn bit(v: i8, i: Self) -> bool

fn bits<R>(v: i8, range: R) -> u8 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i8, i: Self, bit: bool)

fn set_bits<R>(v: &mut i8, range: R, bits: u8) where
    R: RangeBounds<Self>, 

impl BitsIndex<i8> for usize

fn bit(v: i8, i: Self) -> bool

fn bits<R>(v: i8, range: R) -> u8 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i8, i: Self, bit: bool)

fn set_bits<R>(v: &mut i8, range: R, bits: u8) where
    R: RangeBounds<Self>, 

impl BitsIndex<i16> for i8

fn bit(v: i16, i: Self) -> bool

fn bits<R>(v: i16, range: R) -> u16 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i16, i: Self, bit: bool)

fn set_bits<R>(v: &mut i16, range: R, bits: u16) where
    R: RangeBounds<Self>, 

impl BitsIndex<i16> for i16

fn bit(v: i16, i: Self) -> bool

fn bits<R>(v: i16, range: R) -> u16 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i16, i: Self, bit: bool)

fn set_bits<R>(v: &mut i16, range: R, bits: u16) where
    R: RangeBounds<Self>, 

impl BitsIndex<i16> for i32

fn bit(v: i16, i: Self) -> bool

fn bits<R>(v: i16, range: R) -> u16 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i16, i: Self, bit: bool)

fn set_bits<R>(v: &mut i16, range: R, bits: u16) where
    R: RangeBounds<Self>, 

impl BitsIndex<i16> for i64

fn bit(v: i16, i: Self) -> bool

fn bits<R>(v: i16, range: R) -> u16 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i16, i: Self, bit: bool)

fn set_bits<R>(v: &mut i16, range: R, bits: u16) where
    R: RangeBounds<Self>, 

impl BitsIndex<i16> for i128

fn bit(v: i16, i: Self) -> bool

fn bits<R>(v: i16, range: R) -> u16 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i16, i: Self, bit: bool)

fn set_bits<R>(v: &mut i16, range: R, bits: u16) where
    R: RangeBounds<Self>, 

impl BitsIndex<i16> for isize

fn bit(v: i16, i: Self) -> bool

fn bits<R>(v: i16, range: R) -> u16 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i16, i: Self, bit: bool)

fn set_bits<R>(v: &mut i16, range: R, bits: u16) where
    R: RangeBounds<Self>, 

impl BitsIndex<i16> for u8

fn bit(v: i16, i: Self) -> bool

fn bits<R>(v: i16, range: R) -> u16 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i16, i: Self, bit: bool)

fn set_bits<R>(v: &mut i16, range: R, bits: u16) where
    R: RangeBounds<Self>, 

impl BitsIndex<i16> for u16

fn bit(v: i16, i: Self) -> bool

fn bits<R>(v: i16, range: R) -> u16 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i16, i: Self, bit: bool)

fn set_bits<R>(v: &mut i16, range: R, bits: u16) where
    R: RangeBounds<Self>, 

impl BitsIndex<i16> for u32

fn bit(v: i16, i: Self) -> bool

fn bits<R>(v: i16, range: R) -> u16 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i16, i: Self, bit: bool)

fn set_bits<R>(v: &mut i16, range: R, bits: u16) where
    R: RangeBounds<Self>, 

impl BitsIndex<i16> for u64

fn bit(v: i16, i: Self) -> bool

fn bits<R>(v: i16, range: R) -> u16 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i16, i: Self, bit: bool)

fn set_bits<R>(v: &mut i16, range: R, bits: u16) where
    R: RangeBounds<Self>, 

impl BitsIndex<i16> for u128

fn bit(v: i16, i: Self) -> bool

fn bits<R>(v: i16, range: R) -> u16 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i16, i: Self, bit: bool)

fn set_bits<R>(v: &mut i16, range: R, bits: u16) where
    R: RangeBounds<Self>, 

impl BitsIndex<i16> for usize

fn bit(v: i16, i: Self) -> bool

fn bits<R>(v: i16, range: R) -> u16 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i16, i: Self, bit: bool)

fn set_bits<R>(v: &mut i16, range: R, bits: u16) where
    R: RangeBounds<Self>, 

impl BitsIndex<i32> for i8

fn bit(v: i32, i: Self) -> bool

fn bits<R>(v: i32, range: R) -> u32 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i32, i: Self, bit: bool)

fn set_bits<R>(v: &mut i32, range: R, bits: u32) where
    R: RangeBounds<Self>, 

impl BitsIndex<i32> for i16

fn bit(v: i32, i: Self) -> bool

fn bits<R>(v: i32, range: R) -> u32 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i32, i: Self, bit: bool)

fn set_bits<R>(v: &mut i32, range: R, bits: u32) where
    R: RangeBounds<Self>, 

impl BitsIndex<i32> for i32

fn bit(v: i32, i: Self) -> bool

fn bits<R>(v: i32, range: R) -> u32 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i32, i: Self, bit: bool)

fn set_bits<R>(v: &mut i32, range: R, bits: u32) where
    R: RangeBounds<Self>, 

impl BitsIndex<i32> for i64

fn bit(v: i32, i: Self) -> bool

fn bits<R>(v: i32, range: R) -> u32 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i32, i: Self, bit: bool)

fn set_bits<R>(v: &mut i32, range: R, bits: u32) where
    R: RangeBounds<Self>, 

impl BitsIndex<i32> for i128

fn bit(v: i32, i: Self) -> bool

fn bits<R>(v: i32, range: R) -> u32 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i32, i: Self, bit: bool)

fn set_bits<R>(v: &mut i32, range: R, bits: u32) where
    R: RangeBounds<Self>, 

impl BitsIndex<i32> for isize

fn bit(v: i32, i: Self) -> bool

fn bits<R>(v: i32, range: R) -> u32 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i32, i: Self, bit: bool)

fn set_bits<R>(v: &mut i32, range: R, bits: u32) where
    R: RangeBounds<Self>, 

impl BitsIndex<i32> for u8

fn bit(v: i32, i: Self) -> bool

fn bits<R>(v: i32, range: R) -> u32 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i32, i: Self, bit: bool)

fn set_bits<R>(v: &mut i32, range: R, bits: u32) where
    R: RangeBounds<Self>, 

impl BitsIndex<i32> for u16

fn bit(v: i32, i: Self) -> bool

fn bits<R>(v: i32, range: R) -> u32 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i32, i: Self, bit: bool)

fn set_bits<R>(v: &mut i32, range: R, bits: u32) where
    R: RangeBounds<Self>, 

impl BitsIndex<i32> for u32

fn bit(v: i32, i: Self) -> bool

fn bits<R>(v: i32, range: R) -> u32 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i32, i: Self, bit: bool)

fn set_bits<R>(v: &mut i32, range: R, bits: u32) where
    R: RangeBounds<Self>, 

impl BitsIndex<i32> for u64

fn bit(v: i32, i: Self) -> bool

fn bits<R>(v: i32, range: R) -> u32 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i32, i: Self, bit: bool)

fn set_bits<R>(v: &mut i32, range: R, bits: u32) where
    R: RangeBounds<Self>, 

impl BitsIndex<i32> for u128

fn bit(v: i32, i: Self) -> bool

fn bits<R>(v: i32, range: R) -> u32 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i32, i: Self, bit: bool)

fn set_bits<R>(v: &mut i32, range: R, bits: u32) where
    R: RangeBounds<Self>, 

impl BitsIndex<i32> for usize

fn bit(v: i32, i: Self) -> bool

fn bits<R>(v: i32, range: R) -> u32 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i32, i: Self, bit: bool)

fn set_bits<R>(v: &mut i32, range: R, bits: u32) where
    R: RangeBounds<Self>, 

impl BitsIndex<i64> for i8

fn bit(v: i64, i: Self) -> bool

fn bits<R>(v: i64, range: R) -> u64 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i64, i: Self, bit: bool)

fn set_bits<R>(v: &mut i64, range: R, bits: u64) where
    R: RangeBounds<Self>, 

impl BitsIndex<i64> for i16

fn bit(v: i64, i: Self) -> bool

fn bits<R>(v: i64, range: R) -> u64 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i64, i: Self, bit: bool)

fn set_bits<R>(v: &mut i64, range: R, bits: u64) where
    R: RangeBounds<Self>, 

impl BitsIndex<i64> for i32

fn bit(v: i64, i: Self) -> bool

fn bits<R>(v: i64, range: R) -> u64 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i64, i: Self, bit: bool)

fn set_bits<R>(v: &mut i64, range: R, bits: u64) where
    R: RangeBounds<Self>, 

impl BitsIndex<i64> for i64

fn bit(v: i64, i: Self) -> bool

fn bits<R>(v: i64, range: R) -> u64 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i64, i: Self, bit: bool)

fn set_bits<R>(v: &mut i64, range: R, bits: u64) where
    R: RangeBounds<Self>, 

impl BitsIndex<i64> for i128

fn bit(v: i64, i: Self) -> bool

fn bits<R>(v: i64, range: R) -> u64 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i64, i: Self, bit: bool)

fn set_bits<R>(v: &mut i64, range: R, bits: u64) where
    R: RangeBounds<Self>, 

impl BitsIndex<i64> for isize

fn bit(v: i64, i: Self) -> bool

fn bits<R>(v: i64, range: R) -> u64 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i64, i: Self, bit: bool)

fn set_bits<R>(v: &mut i64, range: R, bits: u64) where
    R: RangeBounds<Self>, 

impl BitsIndex<i64> for u8

fn bit(v: i64, i: Self) -> bool

fn bits<R>(v: i64, range: R) -> u64 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i64, i: Self, bit: bool)

fn set_bits<R>(v: &mut i64, range: R, bits: u64) where
    R: RangeBounds<Self>, 

impl BitsIndex<i64> for u16

fn bit(v: i64, i: Self) -> bool

fn bits<R>(v: i64, range: R) -> u64 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i64, i: Self, bit: bool)

fn set_bits<R>(v: &mut i64, range: R, bits: u64) where
    R: RangeBounds<Self>, 

impl BitsIndex<i64> for u32

fn bit(v: i64, i: Self) -> bool

fn bits<R>(v: i64, range: R) -> u64 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i64, i: Self, bit: bool)

fn set_bits<R>(v: &mut i64, range: R, bits: u64) where
    R: RangeBounds<Self>, 

impl BitsIndex<i64> for u64

fn bit(v: i64, i: Self) -> bool

fn bits<R>(v: i64, range: R) -> u64 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i64, i: Self, bit: bool)

fn set_bits<R>(v: &mut i64, range: R, bits: u64) where
    R: RangeBounds<Self>, 

impl BitsIndex<i64> for u128

fn bit(v: i64, i: Self) -> bool

fn bits<R>(v: i64, range: R) -> u64 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i64, i: Self, bit: bool)

fn set_bits<R>(v: &mut i64, range: R, bits: u64) where
    R: RangeBounds<Self>, 

impl BitsIndex<i64> for usize

fn bit(v: i64, i: Self) -> bool

fn bits<R>(v: i64, range: R) -> u64 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i64, i: Self, bit: bool)

fn set_bits<R>(v: &mut i64, range: R, bits: u64) where
    R: RangeBounds<Self>, 

impl BitsIndex<i128> for i8

fn bit(v: i128, i: Self) -> bool

fn bits<R>(v: i128, range: R) -> u128 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i128, i: Self, bit: bool)

fn set_bits<R>(v: &mut i128, range: R, bits: u128) where
    R: RangeBounds<Self>, 

impl BitsIndex<i128> for i16

fn bit(v: i128, i: Self) -> bool

fn bits<R>(v: i128, range: R) -> u128 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i128, i: Self, bit: bool)

fn set_bits<R>(v: &mut i128, range: R, bits: u128) where
    R: RangeBounds<Self>, 

impl BitsIndex<i128> for i32

fn bit(v: i128, i: Self) -> bool

fn bits<R>(v: i128, range: R) -> u128 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i128, i: Self, bit: bool)

fn set_bits<R>(v: &mut i128, range: R, bits: u128) where
    R: RangeBounds<Self>, 

impl BitsIndex<i128> for i64

fn bit(v: i128, i: Self) -> bool

fn bits<R>(v: i128, range: R) -> u128 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i128, i: Self, bit: bool)

fn set_bits<R>(v: &mut i128, range: R, bits: u128) where
    R: RangeBounds<Self>, 

impl BitsIndex<i128> for i128

fn bit(v: i128, i: Self) -> bool

fn bits<R>(v: i128, range: R) -> u128 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i128, i: Self, bit: bool)

fn set_bits<R>(v: &mut i128, range: R, bits: u128) where
    R: RangeBounds<Self>, 

impl BitsIndex<i128> for isize

fn bit(v: i128, i: Self) -> bool

fn bits<R>(v: i128, range: R) -> u128 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i128, i: Self, bit: bool)

fn set_bits<R>(v: &mut i128, range: R, bits: u128) where
    R: RangeBounds<Self>, 

impl BitsIndex<i128> for u8

fn bit(v: i128, i: Self) -> bool

fn bits<R>(v: i128, range: R) -> u128 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i128, i: Self, bit: bool)

fn set_bits<R>(v: &mut i128, range: R, bits: u128) where
    R: RangeBounds<Self>, 

impl BitsIndex<i128> for u16

fn bit(v: i128, i: Self) -> bool

fn bits<R>(v: i128, range: R) -> u128 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i128, i: Self, bit: bool)

fn set_bits<R>(v: &mut i128, range: R, bits: u128) where
    R: RangeBounds<Self>, 

impl BitsIndex<i128> for u32

fn bit(v: i128, i: Self) -> bool

fn bits<R>(v: i128, range: R) -> u128 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i128, i: Self, bit: bool)

fn set_bits<R>(v: &mut i128, range: R, bits: u128) where
    R: RangeBounds<Self>, 

impl BitsIndex<i128> for u64

fn bit(v: i128, i: Self) -> bool

fn bits<R>(v: i128, range: R) -> u128 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i128, i: Self, bit: bool)

fn set_bits<R>(v: &mut i128, range: R, bits: u128) where
    R: RangeBounds<Self>, 

impl BitsIndex<i128> for u128

fn bit(v: i128, i: Self) -> bool

fn bits<R>(v: i128, range: R) -> u128 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i128, i: Self, bit: bool)

fn set_bits<R>(v: &mut i128, range: R, bits: u128) where
    R: RangeBounds<Self>, 

impl BitsIndex<i128> for usize

fn bit(v: i128, i: Self) -> bool

fn bits<R>(v: i128, range: R) -> u128 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut i128, i: Self, bit: bool)

fn set_bits<R>(v: &mut i128, range: R, bits: u128) where
    R: RangeBounds<Self>, 

impl BitsIndex<isize> for i8

fn bit(v: isize, i: Self) -> bool

fn bits<R>(v: isize, range: R) -> usize where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut isize, i: Self, bit: bool)

fn set_bits<R>(v: &mut isize, range: R, bits: usize) where
    R: RangeBounds<Self>, 

impl BitsIndex<isize> for i16

fn bit(v: isize, i: Self) -> bool

fn bits<R>(v: isize, range: R) -> usize where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut isize, i: Self, bit: bool)

fn set_bits<R>(v: &mut isize, range: R, bits: usize) where
    R: RangeBounds<Self>, 

impl BitsIndex<isize> for i32

fn bit(v: isize, i: Self) -> bool

fn bits<R>(v: isize, range: R) -> usize where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut isize, i: Self, bit: bool)

fn set_bits<R>(v: &mut isize, range: R, bits: usize) where
    R: RangeBounds<Self>, 

impl BitsIndex<isize> for i64

fn bit(v: isize, i: Self) -> bool

fn bits<R>(v: isize, range: R) -> usize where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut isize, i: Self, bit: bool)

fn set_bits<R>(v: &mut isize, range: R, bits: usize) where
    R: RangeBounds<Self>, 

impl BitsIndex<isize> for i128

fn bit(v: isize, i: Self) -> bool

fn bits<R>(v: isize, range: R) -> usize where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut isize, i: Self, bit: bool)

fn set_bits<R>(v: &mut isize, range: R, bits: usize) where
    R: RangeBounds<Self>, 

impl BitsIndex<isize> for isize

fn bit(v: isize, i: Self) -> bool

fn bits<R>(v: isize, range: R) -> usize where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut isize, i: Self, bit: bool)

fn set_bits<R>(v: &mut isize, range: R, bits: usize) where
    R: RangeBounds<Self>, 

impl BitsIndex<isize> for u8

fn bit(v: isize, i: Self) -> bool

fn bits<R>(v: isize, range: R) -> usize where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut isize, i: Self, bit: bool)

fn set_bits<R>(v: &mut isize, range: R, bits: usize) where
    R: RangeBounds<Self>, 

impl BitsIndex<isize> for u16

fn bit(v: isize, i: Self) -> bool

fn bits<R>(v: isize, range: R) -> usize where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut isize, i: Self, bit: bool)

fn set_bits<R>(v: &mut isize, range: R, bits: usize) where
    R: RangeBounds<Self>, 

impl BitsIndex<isize> for u32

fn bit(v: isize, i: Self) -> bool

fn bits<R>(v: isize, range: R) -> usize where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut isize, i: Self, bit: bool)

fn set_bits<R>(v: &mut isize, range: R, bits: usize) where
    R: RangeBounds<Self>, 

impl BitsIndex<isize> for u64

fn bit(v: isize, i: Self) -> bool

fn bits<R>(v: isize, range: R) -> usize where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut isize, i: Self, bit: bool)

fn set_bits<R>(v: &mut isize, range: R, bits: usize) where
    R: RangeBounds<Self>, 

impl BitsIndex<isize> for u128

fn bit(v: isize, i: Self) -> bool

fn bits<R>(v: isize, range: R) -> usize where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut isize, i: Self, bit: bool)

fn set_bits<R>(v: &mut isize, range: R, bits: usize) where
    R: RangeBounds<Self>, 

impl BitsIndex<isize> for usize

fn bit(v: isize, i: Self) -> bool

fn bits<R>(v: isize, range: R) -> usize where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut isize, i: Self, bit: bool)

fn set_bits<R>(v: &mut isize, range: R, bits: usize) where
    R: RangeBounds<Self>, 

impl BitsIndex<u8> for i8

fn bit(v: u8, i: Self) -> bool

fn bits<R>(v: u8, range: R) -> u8 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u8, i: Self, bit: bool)

fn set_bits<R>(v: &mut u8, range: R, bits: u8) where
    R: RangeBounds<Self>, 

impl BitsIndex<u8> for i16

fn bit(v: u8, i: Self) -> bool

fn bits<R>(v: u8, range: R) -> u8 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u8, i: Self, bit: bool)

fn set_bits<R>(v: &mut u8, range: R, bits: u8) where
    R: RangeBounds<Self>, 

impl BitsIndex<u8> for i32

fn bit(v: u8, i: Self) -> bool

fn bits<R>(v: u8, range: R) -> u8 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u8, i: Self, bit: bool)

fn set_bits<R>(v: &mut u8, range: R, bits: u8) where
    R: RangeBounds<Self>, 

impl BitsIndex<u8> for i64

fn bit(v: u8, i: Self) -> bool

fn bits<R>(v: u8, range: R) -> u8 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u8, i: Self, bit: bool)

fn set_bits<R>(v: &mut u8, range: R, bits: u8) where
    R: RangeBounds<Self>, 

impl BitsIndex<u8> for i128

fn bit(v: u8, i: Self) -> bool

fn bits<R>(v: u8, range: R) -> u8 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u8, i: Self, bit: bool)

fn set_bits<R>(v: &mut u8, range: R, bits: u8) where
    R: RangeBounds<Self>, 

impl BitsIndex<u8> for isize

fn bit(v: u8, i: Self) -> bool

fn bits<R>(v: u8, range: R) -> u8 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u8, i: Self, bit: bool)

fn set_bits<R>(v: &mut u8, range: R, bits: u8) where
    R: RangeBounds<Self>, 

impl BitsIndex<u8> for u8

fn bit(v: u8, i: Self) -> bool

fn bits<R>(v: u8, range: R) -> u8 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u8, i: Self, bit: bool)

fn set_bits<R>(v: &mut u8, range: R, bits: u8) where
    R: RangeBounds<Self>, 

impl BitsIndex<u8> for u16

fn bit(v: u8, i: Self) -> bool

fn bits<R>(v: u8, range: R) -> u8 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u8, i: Self, bit: bool)

fn set_bits<R>(v: &mut u8, range: R, bits: u8) where
    R: RangeBounds<Self>, 

impl BitsIndex<u8> for u32

fn bit(v: u8, i: Self) -> bool

fn bits<R>(v: u8, range: R) -> u8 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u8, i: Self, bit: bool)

fn set_bits<R>(v: &mut u8, range: R, bits: u8) where
    R: RangeBounds<Self>, 

impl BitsIndex<u8> for u64

fn bit(v: u8, i: Self) -> bool

fn bits<R>(v: u8, range: R) -> u8 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u8, i: Self, bit: bool)

fn set_bits<R>(v: &mut u8, range: R, bits: u8) where
    R: RangeBounds<Self>, 

impl BitsIndex<u8> for u128

fn bit(v: u8, i: Self) -> bool

fn bits<R>(v: u8, range: R) -> u8 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u8, i: Self, bit: bool)

fn set_bits<R>(v: &mut u8, range: R, bits: u8) where
    R: RangeBounds<Self>, 

impl BitsIndex<u8> for usize

fn bit(v: u8, i: Self) -> bool

fn bits<R>(v: u8, range: R) -> u8 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u8, i: Self, bit: bool)

fn set_bits<R>(v: &mut u8, range: R, bits: u8) where
    R: RangeBounds<Self>, 

impl BitsIndex<u16> for i8

fn bit(v: u16, i: Self) -> bool

fn bits<R>(v: u16, range: R) -> u16 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u16, i: Self, bit: bool)

fn set_bits<R>(v: &mut u16, range: R, bits: u16) where
    R: RangeBounds<Self>, 

impl BitsIndex<u16> for i16

fn bit(v: u16, i: Self) -> bool

fn bits<R>(v: u16, range: R) -> u16 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u16, i: Self, bit: bool)

fn set_bits<R>(v: &mut u16, range: R, bits: u16) where
    R: RangeBounds<Self>, 

impl BitsIndex<u16> for i32

fn bit(v: u16, i: Self) -> bool

fn bits<R>(v: u16, range: R) -> u16 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u16, i: Self, bit: bool)

fn set_bits<R>(v: &mut u16, range: R, bits: u16) where
    R: RangeBounds<Self>, 

impl BitsIndex<u16> for i64

fn bit(v: u16, i: Self) -> bool

fn bits<R>(v: u16, range: R) -> u16 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u16, i: Self, bit: bool)

fn set_bits<R>(v: &mut u16, range: R, bits: u16) where
    R: RangeBounds<Self>, 

impl BitsIndex<u16> for i128

fn bit(v: u16, i: Self) -> bool

fn bits<R>(v: u16, range: R) -> u16 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u16, i: Self, bit: bool)

fn set_bits<R>(v: &mut u16, range: R, bits: u16) where
    R: RangeBounds<Self>, 

impl BitsIndex<u16> for isize

fn bit(v: u16, i: Self) -> bool

fn bits<R>(v: u16, range: R) -> u16 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u16, i: Self, bit: bool)

fn set_bits<R>(v: &mut u16, range: R, bits: u16) where
    R: RangeBounds<Self>, 

impl BitsIndex<u16> for u8

fn bit(v: u16, i: Self) -> bool

fn bits<R>(v: u16, range: R) -> u16 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u16, i: Self, bit: bool)

fn set_bits<R>(v: &mut u16, range: R, bits: u16) where
    R: RangeBounds<Self>, 

impl BitsIndex<u16> for u16

fn bit(v: u16, i: Self) -> bool

fn bits<R>(v: u16, range: R) -> u16 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u16, i: Self, bit: bool)

fn set_bits<R>(v: &mut u16, range: R, bits: u16) where
    R: RangeBounds<Self>, 

impl BitsIndex<u16> for u32

fn bit(v: u16, i: Self) -> bool

fn bits<R>(v: u16, range: R) -> u16 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u16, i: Self, bit: bool)

fn set_bits<R>(v: &mut u16, range: R, bits: u16) where
    R: RangeBounds<Self>, 

impl BitsIndex<u16> for u64

fn bit(v: u16, i: Self) -> bool

fn bits<R>(v: u16, range: R) -> u16 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u16, i: Self, bit: bool)

fn set_bits<R>(v: &mut u16, range: R, bits: u16) where
    R: RangeBounds<Self>, 

impl BitsIndex<u16> for u128

fn bit(v: u16, i: Self) -> bool

fn bits<R>(v: u16, range: R) -> u16 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u16, i: Self, bit: bool)

fn set_bits<R>(v: &mut u16, range: R, bits: u16) where
    R: RangeBounds<Self>, 

impl BitsIndex<u16> for usize

fn bit(v: u16, i: Self) -> bool

fn bits<R>(v: u16, range: R) -> u16 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u16, i: Self, bit: bool)

fn set_bits<R>(v: &mut u16, range: R, bits: u16) where
    R: RangeBounds<Self>, 

impl BitsIndex<u32> for i8

fn bit(v: u32, i: Self) -> bool

fn bits<R>(v: u32, range: R) -> u32 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u32, i: Self, bit: bool)

fn set_bits<R>(v: &mut u32, range: R, bits: u32) where
    R: RangeBounds<Self>, 

impl BitsIndex<u32> for i16

fn bit(v: u32, i: Self) -> bool

fn bits<R>(v: u32, range: R) -> u32 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u32, i: Self, bit: bool)

fn set_bits<R>(v: &mut u32, range: R, bits: u32) where
    R: RangeBounds<Self>, 

impl BitsIndex<u32> for i32

fn bit(v: u32, i: Self) -> bool

fn bits<R>(v: u32, range: R) -> u32 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u32, i: Self, bit: bool)

fn set_bits<R>(v: &mut u32, range: R, bits: u32) where
    R: RangeBounds<Self>, 

impl BitsIndex<u32> for i64

fn bit(v: u32, i: Self) -> bool

fn bits<R>(v: u32, range: R) -> u32 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u32, i: Self, bit: bool)

fn set_bits<R>(v: &mut u32, range: R, bits: u32) where
    R: RangeBounds<Self>, 

impl BitsIndex<u32> for i128

fn bit(v: u32, i: Self) -> bool

fn bits<R>(v: u32, range: R) -> u32 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u32, i: Self, bit: bool)

fn set_bits<R>(v: &mut u32, range: R, bits: u32) where
    R: RangeBounds<Self>, 

impl BitsIndex<u32> for isize

fn bit(v: u32, i: Self) -> bool

fn bits<R>(v: u32, range: R) -> u32 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u32, i: Self, bit: bool)

fn set_bits<R>(v: &mut u32, range: R, bits: u32) where
    R: RangeBounds<Self>, 

impl BitsIndex<u32> for u8

fn bit(v: u32, i: Self) -> bool

fn bits<R>(v: u32, range: R) -> u32 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u32, i: Self, bit: bool)

fn set_bits<R>(v: &mut u32, range: R, bits: u32) where
    R: RangeBounds<Self>, 

impl BitsIndex<u32> for u16

fn bit(v: u32, i: Self) -> bool

fn bits<R>(v: u32, range: R) -> u32 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u32, i: Self, bit: bool)

fn set_bits<R>(v: &mut u32, range: R, bits: u32) where
    R: RangeBounds<Self>, 

impl BitsIndex<u32> for u32

fn bit(v: u32, i: Self) -> bool

fn bits<R>(v: u32, range: R) -> u32 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u32, i: Self, bit: bool)

fn set_bits<R>(v: &mut u32, range: R, bits: u32) where
    R: RangeBounds<Self>, 

impl BitsIndex<u32> for u64

fn bit(v: u32, i: Self) -> bool

fn bits<R>(v: u32, range: R) -> u32 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u32, i: Self, bit: bool)

fn set_bits<R>(v: &mut u32, range: R, bits: u32) where
    R: RangeBounds<Self>, 

impl BitsIndex<u32> for u128

fn bit(v: u32, i: Self) -> bool

fn bits<R>(v: u32, range: R) -> u32 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u32, i: Self, bit: bool)

fn set_bits<R>(v: &mut u32, range: R, bits: u32) where
    R: RangeBounds<Self>, 

impl BitsIndex<u32> for usize

fn bit(v: u32, i: Self) -> bool

fn bits<R>(v: u32, range: R) -> u32 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u32, i: Self, bit: bool)

fn set_bits<R>(v: &mut u32, range: R, bits: u32) where
    R: RangeBounds<Self>, 

impl BitsIndex<u64> for i8

fn bit(v: u64, i: Self) -> bool

fn bits<R>(v: u64, range: R) -> u64 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u64, i: Self, bit: bool)

fn set_bits<R>(v: &mut u64, range: R, bits: u64) where
    R: RangeBounds<Self>, 

impl BitsIndex<u64> for i16

fn bit(v: u64, i: Self) -> bool

fn bits<R>(v: u64, range: R) -> u64 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u64, i: Self, bit: bool)

fn set_bits<R>(v: &mut u64, range: R, bits: u64) where
    R: RangeBounds<Self>, 

impl BitsIndex<u64> for i32

fn bit(v: u64, i: Self) -> bool

fn bits<R>(v: u64, range: R) -> u64 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u64, i: Self, bit: bool)

fn set_bits<R>(v: &mut u64, range: R, bits: u64) where
    R: RangeBounds<Self>, 

impl BitsIndex<u64> for i64

fn bit(v: u64, i: Self) -> bool

fn bits<R>(v: u64, range: R) -> u64 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u64, i: Self, bit: bool)

fn set_bits<R>(v: &mut u64, range: R, bits: u64) where
    R: RangeBounds<Self>, 

impl BitsIndex<u64> for i128

fn bit(v: u64, i: Self) -> bool

fn bits<R>(v: u64, range: R) -> u64 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u64, i: Self, bit: bool)

fn set_bits<R>(v: &mut u64, range: R, bits: u64) where
    R: RangeBounds<Self>, 

impl BitsIndex<u64> for isize

fn bit(v: u64, i: Self) -> bool

fn bits<R>(v: u64, range: R) -> u64 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u64, i: Self, bit: bool)

fn set_bits<R>(v: &mut u64, range: R, bits: u64) where
    R: RangeBounds<Self>, 

impl BitsIndex<u64> for u8

fn bit(v: u64, i: Self) -> bool

fn bits<R>(v: u64, range: R) -> u64 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u64, i: Self, bit: bool)

fn set_bits<R>(v: &mut u64, range: R, bits: u64) where
    R: RangeBounds<Self>, 

impl BitsIndex<u64> for u16

fn bit(v: u64, i: Self) -> bool

fn bits<R>(v: u64, range: R) -> u64 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u64, i: Self, bit: bool)

fn set_bits<R>(v: &mut u64, range: R, bits: u64) where
    R: RangeBounds<Self>, 

impl BitsIndex<u64> for u32

fn bit(v: u64, i: Self) -> bool

fn bits<R>(v: u64, range: R) -> u64 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u64, i: Self, bit: bool)

fn set_bits<R>(v: &mut u64, range: R, bits: u64) where
    R: RangeBounds<Self>, 

impl BitsIndex<u64> for u64

fn bit(v: u64, i: Self) -> bool

fn bits<R>(v: u64, range: R) -> u64 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u64, i: Self, bit: bool)

fn set_bits<R>(v: &mut u64, range: R, bits: u64) where
    R: RangeBounds<Self>, 

impl BitsIndex<u64> for u128

fn bit(v: u64, i: Self) -> bool

fn bits<R>(v: u64, range: R) -> u64 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u64, i: Self, bit: bool)

fn set_bits<R>(v: &mut u64, range: R, bits: u64) where
    R: RangeBounds<Self>, 

impl BitsIndex<u64> for usize

fn bit(v: u64, i: Self) -> bool

fn bits<R>(v: u64, range: R) -> u64 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u64, i: Self, bit: bool)

fn set_bits<R>(v: &mut u64, range: R, bits: u64) where
    R: RangeBounds<Self>, 

impl BitsIndex<u128> for i8

fn bit(v: u128, i: Self) -> bool

fn bits<R>(v: u128, range: R) -> u128 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u128, i: Self, bit: bool)

fn set_bits<R>(v: &mut u128, range: R, bits: u128) where
    R: RangeBounds<Self>, 

impl BitsIndex<u128> for i16

fn bit(v: u128, i: Self) -> bool

fn bits<R>(v: u128, range: R) -> u128 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u128, i: Self, bit: bool)

fn set_bits<R>(v: &mut u128, range: R, bits: u128) where
    R: RangeBounds<Self>, 

impl BitsIndex<u128> for i32

fn bit(v: u128, i: Self) -> bool

fn bits<R>(v: u128, range: R) -> u128 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u128, i: Self, bit: bool)

fn set_bits<R>(v: &mut u128, range: R, bits: u128) where
    R: RangeBounds<Self>, 

impl BitsIndex<u128> for i64

fn bit(v: u128, i: Self) -> bool

fn bits<R>(v: u128, range: R) -> u128 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u128, i: Self, bit: bool)

fn set_bits<R>(v: &mut u128, range: R, bits: u128) where
    R: RangeBounds<Self>, 

impl BitsIndex<u128> for i128

fn bit(v: u128, i: Self) -> bool

fn bits<R>(v: u128, range: R) -> u128 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u128, i: Self, bit: bool)

fn set_bits<R>(v: &mut u128, range: R, bits: u128) where
    R: RangeBounds<Self>, 

impl BitsIndex<u128> for isize

fn bit(v: u128, i: Self) -> bool

fn bits<R>(v: u128, range: R) -> u128 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u128, i: Self, bit: bool)

fn set_bits<R>(v: &mut u128, range: R, bits: u128) where
    R: RangeBounds<Self>, 

impl BitsIndex<u128> for u8

fn bit(v: u128, i: Self) -> bool

fn bits<R>(v: u128, range: R) -> u128 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u128, i: Self, bit: bool)

fn set_bits<R>(v: &mut u128, range: R, bits: u128) where
    R: RangeBounds<Self>, 

impl BitsIndex<u128> for u16

fn bit(v: u128, i: Self) -> bool

fn bits<R>(v: u128, range: R) -> u128 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u128, i: Self, bit: bool)

fn set_bits<R>(v: &mut u128, range: R, bits: u128) where
    R: RangeBounds<Self>, 

impl BitsIndex<u128> for u32

fn bit(v: u128, i: Self) -> bool

fn bits<R>(v: u128, range: R) -> u128 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u128, i: Self, bit: bool)

fn set_bits<R>(v: &mut u128, range: R, bits: u128) where
    R: RangeBounds<Self>, 

impl BitsIndex<u128> for u64

fn bit(v: u128, i: Self) -> bool

fn bits<R>(v: u128, range: R) -> u128 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u128, i: Self, bit: bool)

fn set_bits<R>(v: &mut u128, range: R, bits: u128) where
    R: RangeBounds<Self>, 

impl BitsIndex<u128> for u128

fn bit(v: u128, i: Self) -> bool

fn bits<R>(v: u128, range: R) -> u128 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u128, i: Self, bit: bool)

fn set_bits<R>(v: &mut u128, range: R, bits: u128) where
    R: RangeBounds<Self>, 

impl BitsIndex<u128> for usize

fn bit(v: u128, i: Self) -> bool

fn bits<R>(v: u128, range: R) -> u128 where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut u128, i: Self, bit: bool)

fn set_bits<R>(v: &mut u128, range: R, bits: u128) where
    R: RangeBounds<Self>, 

impl BitsIndex<usize> for i8

fn bit(v: usize, i: Self) -> bool

fn bits<R>(v: usize, range: R) -> usize where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut usize, i: Self, bit: bool)

fn set_bits<R>(v: &mut usize, range: R, bits: usize) where
    R: RangeBounds<Self>, 

impl BitsIndex<usize> for i16

fn bit(v: usize, i: Self) -> bool

fn bits<R>(v: usize, range: R) -> usize where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut usize, i: Self, bit: bool)

fn set_bits<R>(v: &mut usize, range: R, bits: usize) where
    R: RangeBounds<Self>, 

impl BitsIndex<usize> for i32

fn bit(v: usize, i: Self) -> bool

fn bits<R>(v: usize, range: R) -> usize where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut usize, i: Self, bit: bool)

fn set_bits<R>(v: &mut usize, range: R, bits: usize) where
    R: RangeBounds<Self>, 

impl BitsIndex<usize> for i64

fn bit(v: usize, i: Self) -> bool

fn bits<R>(v: usize, range: R) -> usize where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut usize, i: Self, bit: bool)

fn set_bits<R>(v: &mut usize, range: R, bits: usize) where
    R: RangeBounds<Self>, 

impl BitsIndex<usize> for i128

fn bit(v: usize, i: Self) -> bool

fn bits<R>(v: usize, range: R) -> usize where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut usize, i: Self, bit: bool)

fn set_bits<R>(v: &mut usize, range: R, bits: usize) where
    R: RangeBounds<Self>, 

impl BitsIndex<usize> for isize

fn bit(v: usize, i: Self) -> bool

fn bits<R>(v: usize, range: R) -> usize where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut usize, i: Self, bit: bool)

fn set_bits<R>(v: &mut usize, range: R, bits: usize) where
    R: RangeBounds<Self>, 

impl BitsIndex<usize> for u8

fn bit(v: usize, i: Self) -> bool

fn bits<R>(v: usize, range: R) -> usize where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut usize, i: Self, bit: bool)

fn set_bits<R>(v: &mut usize, range: R, bits: usize) where
    R: RangeBounds<Self>, 

impl BitsIndex<usize> for u16

fn bit(v: usize, i: Self) -> bool

fn bits<R>(v: usize, range: R) -> usize where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut usize, i: Self, bit: bool)

fn set_bits<R>(v: &mut usize, range: R, bits: usize) where
    R: RangeBounds<Self>, 

impl BitsIndex<usize> for u32

fn bit(v: usize, i: Self) -> bool

fn bits<R>(v: usize, range: R) -> usize where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut usize, i: Self, bit: bool)

fn set_bits<R>(v: &mut usize, range: R, bits: usize) where
    R: RangeBounds<Self>, 

impl BitsIndex<usize> for u64

fn bit(v: usize, i: Self) -> bool

fn bits<R>(v: usize, range: R) -> usize where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut usize, i: Self, bit: bool)

fn set_bits<R>(v: &mut usize, range: R, bits: usize) where
    R: RangeBounds<Self>, 

impl BitsIndex<usize> for u128

fn bit(v: usize, i: Self) -> bool

fn bits<R>(v: usize, range: R) -> usize where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut usize, i: Self, bit: bool)

fn set_bits<R>(v: &mut usize, range: R, bits: usize) where
    R: RangeBounds<Self>, 

impl BitsIndex<usize> for usize

fn bit(v: usize, i: Self) -> bool

fn bits<R>(v: usize, range: R) -> usize where
    R: RangeBounds<Self>, 

fn set_bit(v: &mut usize, i: Self, bit: bool)

fn set_bits<R>(v: &mut usize, range: R, bits: usize) where
    R: RangeBounds<Self>, 

Loading content...