Struct BitEnd

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

One-Bit-After Tail Index

This is a semantic bit-index within or one bit after an R register. It is the index of the first “dead” bit after a “live” region, and corresponds to the similar half-open range concept in the Rust Range type or the LLVM memory model, pointer values include the address one object past the end of a region.

It is a counter in the ring 0 ..= R::BITS (note the inclusive high end). Like BitIdx, this is a virtual semantic index with no bearing on real memory effects; unlike BitIdx, it can never be translated to real memory because it does not describe real memory.

This type is necessary in order to preserve the distinction between a dead memory address that is not part of a region and a live memory address that is within a region. Additionally, it makes computation of region extension or offsets easy. BitIdx is insufficient to this task, and produces off-by-one errors when used in its stead.

Type Parameters

• R: The register element that this dead-bit 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 cannot be publicly constructed except by using the iterators provided for testing.

Implementations

impl<R> BitEnd<R>

where R: BitRegister,

pub const MAX: BitEnd<R> = _

The inclusive maximum tail within (or after) an R element.

pub const MIN: BitEnd<R> = _

The inclusive minimum tail within (or after) an R element.

pub fn new(end: u8) -> Option<BitEnd<R>>

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

Parameters

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

Returns

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

pub fn into_inner(self) -> u8

Available on non-tarpaulin_include only.

Removes the tail wrapper, leaving the internal counter.

pub fn range_from( from: BitIdx<R>, ) -> impl Iterator<Item = BitEnd<R>> + 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 heterogeneous 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::MAX.

Trait Implementations

impl<R> Binary for BitEnd<R>

where R: BitRegister,

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

Formats the value using the given formatter.

impl<R> Clone for BitEnd<R>

where R: Clone + BitRegister,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<R> Debug for BitEnd<R>

where R: BitRegister,

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

Formats the value using the given formatter.

impl<R> Default for BitEnd<R>

where R: Default + 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<(), Error>

Formats the value using the given formatter.

impl<R> Hash for BitEnd<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 BitEnd<R>

where R: Ord + BitRegister,

fn cmp(&self, other: &BitEnd<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 BitEnd<R>

where R: PartialEq + BitRegister,

fn eq(&self, other: &BitEnd<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 BitEnd<R>

where R: PartialOrd + BitRegister,

fn partial_cmp(&self, other: &BitEnd<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 BitEnd<R>

where R: Copy + BitRegister,

impl<R> Eq for BitEnd<R>

where R: Eq + BitRegister,

impl<R> StructuralPartialEq for BitEnd<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