Struct bitvec::index::BitPos

#[repr(transparent)]pub struct BitPos<R> where
    R: BitRegister,  { /* fields omitted */ }

An electrical position of a single bit within a register R.

This type is used as the shift distance in the expression 1 << shamt. It is only produced by the translation of a semantic BitIdx<R> according to some BitOrder implementation using BitOrder::at. It can only be used for the construction of bit masks used to manipulate a register value during memory access, and serves no other purpose.

Type Parameters

• R: The register type that these values govern.

Validity

Values of this type are required to be in the range 0 .. R::BITS. Any value outside this range will cause the program state to become invalid, and the library’s behavior is unspecified. The library will never produce such an invalid value, and users are required to do the same.

Construction

This type offers public unsafe constructors. bitvec does not offer any public APIs that take values of this type directly; it always routes through BitOrder implementations. As BitIdx will only be constructed from safe, correct, values, and BitOrder::at is the only BitIdx -> BitPos transform function, all constructed BitPos values are known to be memory-correct.

Implementations

impl<R> BitPos<R> where
    R: BitRegister, 

pub unsafe fn new(pos: u8) -> Option<Self>

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

Parameters

• pos: An electrical position of a bit within an R register.

Returns

If pos is outside the valid range 0 .. R::BITS, this returns None; otherwise, it returns a BitPos wrapping the pos value.

Safety

This function must only be called within a BitOrder::at implementation which is verified to be correct.

pub unsafe fn new_unchecked(pos: u8) -> Self

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

Parameters

• pos: An electrical position within an R register.

Returns

pos wrapped in a BitPos.

Safety

pos must be within the valid range 0 .. R::BITS. In debug builds, invalid pos values cause a panic; release builds do not check the input.

This function must only be called in a correct BitOrder::at implementation.

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

Constructs a one-hot selection mask from the position counter.

This is a well-typed 1 << pos.

Parameters

• self

Returns

A one-hot mask for R selecting the bit specified by self.

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

Constructs an untyped bitmask from the position counter.

This removes the one-hot requirement from the selection mask.

Parameters

• self

Returns

A mask for R selecting only the bit specified by self.

pub fn value(self) -> u8

Views the internal position value.

Trait Implementations

impl<R: Clone> Clone for BitPos<R> where
    R: 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: Copy> Copy for BitPos<R> where
    R: BitRegister, 

impl<R> Debug for BitPos<R> where
    R: BitRegister, 

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

Formats the value using the given formatter.

impl<R: Default> Default for BitPos<R> where
    R: 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

Formats the value using the given formatter.

impl<R: Eq> Eq for BitPos<R> where
    R: BitRegister, 

impl<R: Hash> Hash for BitPos<R> where
    R: BitRegister, 

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, 

Feeds a slice of this type into the given Hasher.

impl<R: Ord> Ord for BitPos<R> where
    R: BitRegister, 

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

This method returns an Ordering between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl<R: PartialEq> PartialEq<BitPos<R>> for BitPos<R> where
    R: BitRegister, 

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

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

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

This method tests for !=.

impl<R: PartialOrd> PartialOrd<BitPos<R>> for BitPos<R> where
    R: 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: &BitPos<R>) -> bool

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

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

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

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

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

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

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

impl<R> StructuralEq for BitPos<R> where
    R: BitRegister, 

impl<R> StructuralPartialEq for BitPos<R> where
    R: BitRegister,