Trait BitsIndex

pub trait BitsIndex<T> {
    // Required methods
    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.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

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

Implementors