Struct BitPos

pub struct BitPos<R = usize>
where
    R: BitRegister,
{ /* private fields */ }

Bit Position

This is a position counter of a real bit in an R memory element.

Like BitIdx, it is a counter in the ring 0 .. R::BITS. It marks a real bit in memory, and is the shift distance in the expression 1 << n. It can only be produced by applying BitOrder::at to an existing BitIdx produced by bitvec.

Type Parameters

• R: The register element that this position governs.

Validity

Values of this type are required to be in the range 0 .. R::BITS. Any value not less than R::BITS makes the program invalid, and will likely cause either a crash or incorrect memory access.

Construction

This type is publicly constructible, but is only correct to do so within an implementation of BitOrder::at. bitvec will only request its creation through that trait implementation, and has no sites that can publicly accept untrusted values.

Implementations

impl<R> BitPos<R>

where R: BitRegister,

pub const MAX: BitPos<R> = _

The position value of the most significant bit in an R element.

pub const MIN: BitPos<R> = _

The position value of the least significant bit in an R element.

pub fn new(pos: u8) -> Option<BitPos<R>>

Wraps a counter value as a known-good position within an R register.

Parameters

• pos: The counter value to mark as a position. This must be in the range 0 .. R::BITS.

Returns

This returns Some(pos) when it is in the valid range 0 .. R::BITS, and None when it is not.

pub unsafe fn new_unchecked(pos: u8) -> BitPos<R>

Wraps a counter value as an assumed-good position within an R register.

Parameters

• value: The counter value to mark as a position. This must be in the range 0 .. R::BITS.

Returns

This unconditionally marks pos as a valid bit-position.

Safety

If the pos value is outside the valid range, then the program is incorrect. Debug builds will panic; release builds do not inspect the value or specify a behavior.

pub fn into_inner(self) -> u8

Available on non-tarpaulin_include only.

Removes the position wrapper, leaving the internal counter.

pub fn select(self) -> BitSel<R>

Computes the bit selector corresponding to self.

This is always 1 << self.pos.

pub fn mask(self) -> BitMask<R>

Available on non-tarpaulin_include only.

Computes the bit selector for self as an accessor mask.

This is a type-cast over Self::select.

Trait Implementations

impl<R> Binary for BitPos<R>

where R: BitRegister,

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

Formats the value using the given formatter.

impl<R> Clone for BitPos<R>

where R: Clone + BitRegister,

fn clone(&self) -> BitPos<R>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<R> Debug for BitPos<R>

where R: BitRegister,

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

Formats the value using the given formatter.

impl<R> Default for BitPos<R>

where R: Default + BitRegister,

fn default() -> BitPos<R>

Returns the “default value” for a type.

impl<R> Display for BitPos<R>

where R: BitRegister,

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

Formats the value using the given formatter.

impl<R> Hash for BitPos<R>

where R: Hash + BitRegister,

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

where __H: Hasher,

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<R> Ord for BitPos<R>

where R: Ord + BitRegister,

fn cmp(&self, other: &BitPos<R>) -> Ordering

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<R> PartialEq for BitPos<R>

where R: PartialEq + BitRegister,

fn eq(&self, other: &BitPos<R>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<R> PartialOrd for BitPos<R>

where R: PartialOrd + BitRegister,

fn partial_cmp(&self, other: &BitPos<R>) -> Option<Ordering>

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<R> Copy for BitPos<R>

where R: Copy + BitRegister,

impl<R> Eq for BitPos<R>

where R: Eq + BitRegister,

impl<R> StructuralPartialEq for BitPos<R>

where R: BitRegister,

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 1 byte