Struct bitvec::index::BitEnd

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

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> BitEnd<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 into_inner(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<BitEnd<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.

pub fn span(self, len: usize) -> (usize, Self)

Computes the span information for a region beginning immediately after a preceding region.

The computed region of len bits has its start at the live bit that corresponds to the self dead tail. The return value is the number of memory elements containing live bits of the computed span and its tail marker.

Parameters

• self: A dead bit immediately after some region.
• len: The number of live bits in the span starting after self.

Returns

• .0: The number of elements R that contain live bits in the computed region.
• .1: The tail counter of the first dead bit after the new span.

Behavior

If len is 0, this returns (0, self), as the span has no live bits. If self is BitEnd::LAST, then the new region starts at BitIdx::ZERO in the next element.

Trait Implementations

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

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

Formats the value using the given formatter.

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

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

Formats the value using the given formatter.

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

fn default() -> BitEnd<R>

Returns the “default value” for a type.

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

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

Formats the value using the given formatter.

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

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

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

Feeds this value into the given Hasher.

pub 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 BitEnd<R> where
    R: BitRegister, 

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

This method returns an Ordering between self and other.

#[must_use]

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

Compares and returns the maximum of two values.

#[must_use]

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

Compares and returns the minimum of two values.

#[must_use]

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

Restrict a value to a certain interval.

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

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

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

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

This method tests for !=.

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

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

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

#[must_use]

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

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

#[must_use]

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

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

#[must_use]

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

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

#[must_use]

pub 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> StructuralEq for BitEnd<R> where
    R: BitRegister, 

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