Struct bitvec::index::BitIdx

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

A semantic index of a single bit within a register R.

This type is a counter in the range 0 .. R::BITS, and marks the semantic position of a bit according to some BitOrder implementation. As an abstract counter, it can be used in arithmetic without having to go through BitOrder translation to an electrical position.

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.

Construction

This type cannot be constructed outside the bitvec crate. bitvec will construct safe values of this type, and allows users to view them and use them to construct other index types from them. All values of this type constructed by bitvec are known to be correct based on user input to the crate.

Implementations

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

pub fn position<O>(self) -> BitPos<R> where
    O: BitOrder, 

Computes the bit position corresponding to self under some ordering.

This forwards to O::at::<R>, and is the only public, safe, constructor for a position counter.

pub fn select<O>(self) -> BitSel<R> where
    O: BitOrder, 

Computes the bit selector corresponding to self under an ordering.

This forwards to O::select::<R>, and is the only public, safe, constructor for a bit selector.

pub fn mask<O>(self) -> BitMask<R> where
    O: BitOrder, 

Computes the bit selector for self as an accessor mask.

This is a type-cast over Self::select. It is one of the few public, safe, constructors of a multi-bit mask.

pub fn value(self) -> u8

Views the internal index value.

pub fn range(
    from: Self,
    upto: BitTail<R>
) -> impl Iterator<Item = Self> + DoubleEndedIterator + ExactSizeIterator + FusedIterator

Constructs a range over all indices between a start and end point.

Because implementation details of the RangeOps family are not yet stable, and heterogenous ranges are not supported, this must be an opaque iterator rather than a direct Range<BitIdx<R>>.

Parameters

• from: The inclusive low bound of the range. This will be the first index produced by the iterator.
• upto: The exclusive high bound of the range. The iterator will halt before yielding an index of this value.

Returns

An opaque iterator that is equivalent to the range from .. upto.

Requirements

from must be no greater than upto.

Trait Implementations

impl<R> Binary for BitIdx<R> where
    R: BitRegister, 

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

Formats the value using the given formatter.

impl<R: Clone> Clone for BitIdx<R> where
    R: BitRegister, 

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<R: Copy> Copy for BitIdx<R> where
    R: BitRegister, 

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

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

Formats the value using the given formatter.

impl<R: Default> Default for BitIdx<R> where
    R: BitRegister, 

fn default() -> BitIdx<R>

Returns the "default value" for a type.

impl<R> Display for BitIdx<R> where
    R: BitRegister, 

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

Formats the value using the given formatter.

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

impl<R: Hash> Hash for BitIdx<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 BitIdx<R> where
    R: BitRegister, 

fn cmp(&self, other: &BitIdx<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<BitIdx<R>> for BitIdx<R> where
    R: BitRegister, 

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

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

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

This method tests for !=.

impl<R: PartialOrd> PartialOrd<BitIdx<R>> for BitIdx<R> where
    R: BitRegister, 

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

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

fn lt(&self, other: &BitIdx<R>) -> bool

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

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

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

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

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

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

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

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

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

impl<R> TryFrom<u8> for BitIdx<R> where
    R: BitRegister, 

type Error = BitIdxErr<R>

The type returned in the event of a conversion error.

fn try_from(idx: u8) -> Result<Self, Self::Error>

Performs the conversion.