Struct bitvec::index::BitIdx

source · [−]

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

Expand description

A semantic index counter within a register element R.

This type is a counter in the ring 0 .. R::BITS, and serves to mark a semantic index within some register element. It is a virtual index, and is the stored value used in pointer encodings to track region start information.

It is translated to an electrical index through the BitOrder trait. This virtual index is the only counter that can be used for address computation, and once lowered to an electrical index through BitOrder::at, the electrical address can only be used for instruction selection.

Type Parameters

R: The register element that this index governs.

Validity

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

Construction

This type can never be constructed outside of the bitvec crate. It is passed in to BitOrder implementations, which may use it to construct electrical position, selection, or mask values from it. All values of this type constructed by bitvec are known to be correct in their region; no other construction site can be trusted.

Struct bitvec::index::BitIdx

Implementations

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

pub const LAST: Self

pub const ZERO: Self

pub fn new(value: u8) -> Result<Self, BitIdxError<R>>

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

pub fn cast<S>(self) -> Result<BitIdx<S>, BitIdxError<S>> where S: BitRegister,

pub fn value(self) -> u8

pub fn next(self) -> (Self, bool)

pub fn prev(self) -> (Self, bool)

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

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

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

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

pub fn range_all() -> impl Iterator<Item = Self> + DoubleEndedIterator + ExactSizeIterator + FusedIterator

pub fn offset(self, by: isize) -> (isize, Self)

pub fn span(self, len: usize) -> (usize, BitTail<R>)

Trait Implementations

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

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

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

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

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

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

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

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

fn default() -> BitIdx<R>

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

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

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

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

fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type Error = BitIdxError<R>

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

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

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

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

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

Auto Trait Implementations

impl<R> RefUnwindSafe for BitIdx<R> where R: RefUnwindSafe,

impl<R> Send for BitIdx<R>

impl<R> Sync for BitIdx<R>

impl<R> Unpin for BitIdx<R>

impl<R> UnwindSafe for BitIdx<R> where R: UnwindSafe,

Blanket Implementations

impl<T> Any for T where T: 'static + ?Sized,

pub fn type_id(&self) -> TypeId

impl<T> Borrow<T> for T where T: ?Sized,

pub fn borrow(&self) -> &T

impl<T> BorrowMut<T> for T where T: ?Sized,

pub fn borrow_mut(&mut self) -> &mut T

impl<T> Conv for T

fn conv<T>(self) -> T where Self: Into<T>,

impl<T> Conv for T

fn conv<T>(self) -> T where Self: Into<T>,

impl<T> FmtForward for T

fn fmt_binary(self) -> FmtBinary<Self> where Self: Binary,

fn fmt_display(self) -> FmtDisplay<Self> where Self: Display,

fn fmt_lower_exp(self) -> FmtLowerExp<Self> where Self: LowerExp,

fn fmt_lower_hex(self) -> FmtLowerHex<Self> where Self: LowerHex,

fn fmt_octal(self) -> FmtOctal<Self> where Self: Octal,

fn fmt_pointer(self) -> FmtPointer<Self> where Self: Pointer,

fn fmt_upper_exp(self) -> FmtUpperExp<Self> where Self: UpperExp,

fn fmt_upper_hex(self) -> FmtUpperHex<Self> where Self: UpperHex,

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

pub fn cast<S>(self) -> Result<BitIdx<S>, BitIdxError<S>> where
S: BitRegister,

pub fn next(self) -> (Self, bool )

pub fn prev(self) -> (Self, bool )

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

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

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

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

pub fn range_all(
) -> impl Iterator<Item = Self> + DoubleEndedIterator + ExactSizeIterator + FusedIterator

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

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

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

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

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

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

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

fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,

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

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

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

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

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

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

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

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

impl<R> RefUnwindSafe for BitIdx<R> where
R: RefUnwindSafe,

impl<R> UnwindSafe for BitIdx<R> where
R: UnwindSafe,

impl<T> Any for T where
T: 'static + ?Sized,

impl<T> Borrow<T> for T where
T: ?Sized,

impl<T> BorrowMut<T> for T where
T: ?Sized,

fn conv<T>(self) -> T where
Self: Into<T>,

fn conv<T>(self) -> T where
Self: Into<T>,

fn fmt_binary(self) -> FmtBinary<Self> where
Self: Binary,

fn fmt_display(self) -> FmtDisplay<Self> where
Self: Display,

fn fmt_lower_exp(self) -> FmtLowerExp<Self> where
Self: LowerExp,

fn fmt_lower_hex(self) -> FmtLowerHex<Self> where
Self: LowerHex,

fn fmt_octal(self) -> FmtOctal<Self> where
Self: Octal,

fn fmt_pointer(self) -> FmtPointer<Self> where
Self: Pointer,

fn fmt_upper_exp(self) -> FmtUpperExp<Self> where
Self: UpperExp,

fn fmt_upper_hex(self) -> FmtUpperHex<Self> where
Self: UpperHex,

impl<T, U> Into<U> for T where
U: From<T>,

impl<T> Pipe for T where
T: ?Sized,

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where
R: 'a,

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where
R: 'a,

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R where
Self: Borrow<B>,
B: 'a + ?Sized,
R: 'a,

fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R where
Self: BorrowMut<B>,
B: 'a + ?Sized,
R: 'a,

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R where
Self: AsRef<U>,
U: 'a + ?Sized,
R: 'a,

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R where
Self: AsMut<U>,
U: 'a + ?Sized,
R: 'a,

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Deref<Target = T>,
T: 'a + ?Sized,
R: 'a,

fn pipe_deref_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: DerefMut<Target = T> + Deref,
T: 'a + ?Sized,
R: 'a,

fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: AsRef<T>,
T: 'a,
R: 'a,

fn pipe_as_mut<'a, T, R>(&'a mut self, func: impl FnOnce(&'a mut T) -> R) -> R where
Self: AsMut<T>,
T: 'a,
R: 'a,

fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Borrow<T>,
T: 'a,
R: 'a,

fn pipe_borrow_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: BorrowMut<T>,
T: 'a,
R: 'a,

fn pipe_deref<'a, R>(&'a self, func: impl FnOnce(&'a Self::Target) -> R) -> R where
Self: Deref,
R: 'a,

fn pipe_deref_mut<'a, R>(
&'a mut self,
func: impl FnOnce(&'a mut Self::Target) -> R
) -> R where
Self: DerefMut,
R: 'a,

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where
R: 'a,

fn pipe_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where
R: 'a,

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self where
Self: AsRef<R>,
R: ?Sized,

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self where
Self: Deref<Target = T>,
T: ?Sized,

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self where
Self: DerefMut<Target = T> + Deref,
T: ?Sized,

fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,

fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,

fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self where
Self: AsRef<R>,
R: ?Sized,

fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,