Struct bitmap32::LE

#[repr(transparent)]
pub struct LE<B: BitBlock>(pub B);

BitBlocks that use Little Endian order instead of Big Endian Order.

Example

let map = BitMap::from_raw_le([0b00000001u8, 0b01000000]);

assert_eq!(map.test(0), Some(true));
assert_eq!(map.test(9), Some(false));
assert_eq!(map.test(14), Some(true));
assert_eq!(map.test(7), Some(false));

Tuple Fields

0: B

Trait Implementations

impl<B: BitBlock> BitAnd<LE<B>> for LE<B>

type Output = LE<<B as BitAnd<B>>::Output>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<B: BitBlock> BitAndAssign<LE<B>> for LE<B>

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl BitBlock for LE<u128>

const ZERO: Self = _

const UPSTREAM_ONE: Self = _

As of now, this value is not 1 for unsigned integers UPSTREAM_ONE.wrapping_shift_upstream(1) should be 0. For example, for u8, this value is 0x80 (0b10000000).

const BITS: usize = 128usize

Represents the number of bits in a block. It is generally a good idea for this number to be a power of two.

fn wrapping_shift_downstream(self, n: usize) -> Self

Shifts self n bits in the indexing direction.

fn wrapping_shift_upstream(self, n: usize) -> Self

Shifts self n bits against the indexing direction.

fn leading_zeros(self) -> usize

Gets the leading zeros in the indexing direction.

fn leading_ones(self) -> usize

Gets the leading ones in the indexing direction.

fn get_block_index(idx: usize) -> usize

Returns the index of the block holding the bit at the specified location in a collection (eg. for a u8, get_block_index(9) == 2).

fn bit_index_from_block_index(idx: usize) -> usize

Returns the index of the first bit in the block at idx..

fn wrapping_test_bit(self, idx: usize) -> bool

Returns true if the bit at idx is 1.

fn wrapping_with_bit(self, idx: usize) -> Self

Returns self with the bit at idx set to 1.

fn wrapping_without_bit(self, idx: usize) -> Self

Returns self with the bit at idx set to 0.

fn ones_mask(position: usize, length: NonZeroUsize) -> Self

Returns a bit mask of ones at position (wrapped) with a length of length (saturated).

impl BitBlock for LE<u16>

const ZERO: Self = _

const UPSTREAM_ONE: Self = _

As of now, this value is not 1 for unsigned integers UPSTREAM_ONE.wrapping_shift_upstream(1) should be 0. For example, for u8, this value is 0x80 (0b10000000).

const BITS: usize = 16usize

Represents the number of bits in a block. It is generally a good idea for this number to be a power of two.

fn wrapping_shift_downstream(self, n: usize) -> Self

Shifts self n bits in the indexing direction.

fn wrapping_shift_upstream(self, n: usize) -> Self

Shifts self n bits against the indexing direction.

fn leading_zeros(self) -> usize

Gets the leading zeros in the indexing direction.

fn leading_ones(self) -> usize

Gets the leading ones in the indexing direction.

fn get_block_index(idx: usize) -> usize

Returns the index of the block holding the bit at the specified location in a collection (eg. for a u8, get_block_index(9) == 2).

fn bit_index_from_block_index(idx: usize) -> usize

Returns the index of the first bit in the block at idx..

fn wrapping_test_bit(self, idx: usize) -> bool

Returns true if the bit at idx is 1.

fn wrapping_with_bit(self, idx: usize) -> Self

Returns self with the bit at idx set to 1.

fn wrapping_without_bit(self, idx: usize) -> Self

Returns self with the bit at idx set to 0.

fn ones_mask(position: usize, length: NonZeroUsize) -> Self

Returns a bit mask of ones at position (wrapped) with a length of length (saturated).

impl BitBlock for LE<u32>

const ZERO: Self = _

const UPSTREAM_ONE: Self = _

As of now, this value is not 1 for unsigned integers UPSTREAM_ONE.wrapping_shift_upstream(1) should be 0. For example, for u8, this value is 0x80 (0b10000000).

const BITS: usize = 32usize

Represents the number of bits in a block. It is generally a good idea for this number to be a power of two.

fn wrapping_shift_downstream(self, n: usize) -> Self

Shifts self n bits in the indexing direction.

fn wrapping_shift_upstream(self, n: usize) -> Self

Shifts self n bits against the indexing direction.

fn leading_zeros(self) -> usize

Gets the leading zeros in the indexing direction.

fn leading_ones(self) -> usize

Gets the leading ones in the indexing direction.

fn get_block_index(idx: usize) -> usize

Returns the index of the block holding the bit at the specified location in a collection (eg. for a u8, get_block_index(9) == 2).

fn bit_index_from_block_index(idx: usize) -> usize

Returns the index of the first bit in the block at idx..

fn wrapping_test_bit(self, idx: usize) -> bool

Returns true if the bit at idx is 1.

fn wrapping_with_bit(self, idx: usize) -> Self

Returns self with the bit at idx set to 1.

fn wrapping_without_bit(self, idx: usize) -> Self

Returns self with the bit at idx set to 0.

fn ones_mask(position: usize, length: NonZeroUsize) -> Self

Returns a bit mask of ones at position (wrapped) with a length of length (saturated).

impl BitBlock for LE<u64>

const ZERO: Self = _

const UPSTREAM_ONE: Self = _

As of now, this value is not 1 for unsigned integers UPSTREAM_ONE.wrapping_shift_upstream(1) should be 0. For example, for u8, this value is 0x80 (0b10000000).

const BITS: usize = 64usize

Represents the number of bits in a block. It is generally a good idea for this number to be a power of two.

fn wrapping_shift_downstream(self, n: usize) -> Self

Shifts self n bits in the indexing direction.

fn wrapping_shift_upstream(self, n: usize) -> Self

Shifts self n bits against the indexing direction.

fn leading_zeros(self) -> usize

Gets the leading zeros in the indexing direction.

fn leading_ones(self) -> usize

Gets the leading ones in the indexing direction.

fn get_block_index(idx: usize) -> usize

Returns the index of the block holding the bit at the specified location in a collection (eg. for a u8, get_block_index(9) == 2).

fn bit_index_from_block_index(idx: usize) -> usize

Returns the index of the first bit in the block at idx..

fn wrapping_test_bit(self, idx: usize) -> bool

Returns true if the bit at idx is 1.

fn wrapping_with_bit(self, idx: usize) -> Self

Returns self with the bit at idx set to 1.

fn wrapping_without_bit(self, idx: usize) -> Self

Returns self with the bit at idx set to 0.

fn ones_mask(position: usize, length: NonZeroUsize) -> Self

Returns a bit mask of ones at position (wrapped) with a length of length (saturated).

impl BitBlock for LE<u8>

const ZERO: Self = _

const UPSTREAM_ONE: Self = _

As of now, this value is not 1 for unsigned integers UPSTREAM_ONE.wrapping_shift_upstream(1) should be 0. For example, for u8, this value is 0x80 (0b10000000).

const BITS: usize = 8usize

Represents the number of bits in a block. It is generally a good idea for this number to be a power of two.

fn wrapping_shift_downstream(self, n: usize) -> Self

Shifts self n bits in the indexing direction.

fn wrapping_shift_upstream(self, n: usize) -> Self

Shifts self n bits against the indexing direction.

fn leading_zeros(self) -> usize

Gets the leading zeros in the indexing direction.

fn leading_ones(self) -> usize

Gets the leading ones in the indexing direction.

fn get_block_index(idx: usize) -> usize

Returns the index of the block holding the bit at the specified location in a collection (eg. for a u8, get_block_index(9) == 2).

fn bit_index_from_block_index(idx: usize) -> usize

Returns the index of the first bit in the block at idx..

fn wrapping_test_bit(self, idx: usize) -> bool

Returns true if the bit at idx is 1.

fn wrapping_with_bit(self, idx: usize) -> Self

Returns self with the bit at idx set to 1.

fn wrapping_without_bit(self, idx: usize) -> Self

Returns self with the bit at idx set to 0.

fn ones_mask(position: usize, length: NonZeroUsize) -> Self

Returns a bit mask of ones at position (wrapped) with a length of length (saturated).

impl<B: BitBlock> BitOr<LE<B>> for LE<B>

type Output = LE<<B as BitOr<B>>::Output>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<B: BitBlock> BitOrAssign<LE<B>> for LE<B>

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl<B: Clone + BitBlock> Clone for LE<B>

fn clone(&self) -> LE<B>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<B: Debug + BitBlock> Debug for LE<B>

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

Formats the value using the given formatter.

impl<B: Hash + BitBlock> Hash for LE<B>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<B: BitBlock> Not for LE<B>

type Output = LE<<B as Not>::Output>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<B: Ord + BitBlock> Ord for LE<B>

fn cmp(&self, other: &LE<B>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl<B: PartialEq + BitBlock> PartialEq<LE<B>> for LE<B>

fn eq(&self, other: &LE<B>) -> 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<B: PartialOrd + BitBlock> PartialOrd<LE<B>> for LE<B>

fn partial_cmp(&self, other: &LE<B>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<B: Copy + BitBlock> Copy for LE<B>

impl<B: Eq + BitBlock> Eq for LE<B>

impl<B: BitBlock> StructuralEq for LE<B>

impl<B: BitBlock> StructuralPartialEq for LE<B>