Struct bitvec::index::BitTail

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

A semantic index counter within or one bit past the end of a register element R.

This type is a counter in the ring 0 ..= R::BITS, and serves to mark a semantic index of a dead bit after a live region. As such, following in the C++ and LLVM memory model of first-live/first-dead region descriptiors, it marks an endpoint outside some bit-region, and may be used to compute the startpoint of a bit-region immediately succeeding, but not overlapping, the source.

As a dead-bit index, this cannot be used for indexing into a register. It is used only in abstract region computation.

This type is necessary in order to preserve the distinction between a dead memory address that is not part of a buffer and a live memory address that is within a region. BitIdx is insufficient to this task, and causes buffer management errors when used in its stead.

Type Parameters

• R: The register element that this end index governs.

Validity

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

Construction

This type can only be publicly constructed through BitIdx::span.

Implementations

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

pub const LAST: Self

The inclusive maximum tail within an element R.

pub const ZERO: Self

The inclusive minimum tail within an element R.

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

Wraps a counter value as a known-good tail of an R register.

Parameters

• value: The counter value to mark as a tail. This must be not less than Self::ZERO and not more than Self::LAST.

Returns

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

pub fn value(self) -> u8

Removes the tail wrapper, leaving the internal counter.

pub fn range_from(
    from: BitIdx<R>
) -> impl Iterator<Item = Self> + DoubleEndedIterator + ExactSizeIterator + FusedIterator

Iterates over all tail indices at and after an inclusive starting point.

Because implementation details of the range type family, including the RangeBounds trait, are not yet stable, and heterogenous ranges are not yet supported, this must be an opaque iterator rather than a direct Range<BitTail<R>>.

Parameters

• from: The inclusive low bound of the range. This will be the first tail produced by the iterator.

Returns

An opaque iterator that is equivalent to the range from ..= Self::LAST.

Trait Implementations

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

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

Formats the value using the given formatter.

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

fn default() -> BitTail<R>

Returns the “default value” for a type.

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

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

Formats the value using the given formatter.

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

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

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

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

Restrict a value to a certain interval.

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

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

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

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

This method tests for !=.

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

fn partial_cmp(&self, other: &BitTail<R>) -> 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<R: Copy> Copy for BitTail<R> where
    R: BitRegister, 

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

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

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