Struct bitvec::index::BitTail

source · [−]

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

Expand description

Semantic index of a dead bit after a live region.

Like BitIdx<M>, this type indicates a semantic counter within a memory element M. However, it marks the position of a dead bit after a live range. This means that it is permitted to have the value of M::BITS, to indicate that a live region touches the semantic back edge of the element M.

Instances of this type will only contain the value 0 when the span that created them is empty. Otherwise, they will have the range 1 ..= M::BITS.

This type cannot be used for indexing into an element M, and does not translate to a BitPos<M>. It has no behavior other than viewing its internal counter for region arithmetic.

Type Parameters

M: The register type that values of this type govern.

Validity

Values of this type are required to be in the range 0 ..= M::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 directly constructed outside the bitvec crate. bitvec will construct safe values of this type, and allows users to view them and use them for region computation. All values of this type constructed by bitvec are known to be correct based on user input to the crate.

Struct bitvec::index::BitTail

Type Parameters

Validity

Construction

Implementations

impl<M> BitTail<M> where M: BitMemory,

pub fn value(self) -> u8

Trait Implementations

impl<M: Clone> Clone for BitTail<M> where M: BitMemory,

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

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

impl<M> Debug for BitTail<M> where M: BitMemory,

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

impl<M: Default> Default for BitTail<M> where M: BitMemory,

fn default() -> BitTail<M>

impl<M> Display for BitTail<M> where M: BitMemory,

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

impl<M: Hash> Hash for BitTail<M> where M: BitMemory,

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

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

impl<M: Ord> Ord for BitTail<M> where M: BitMemory,

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

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

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

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

impl<M: PartialEq> PartialEq<BitTail<M>> for BitTail<M> where M: BitMemory,

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

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

impl<M: PartialOrd> PartialOrd<BitTail<M>> for BitTail<M> where M: BitMemory,

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

impl<M: Eq> Eq for BitTail<M> where M: BitMemory,

impl<M> StructuralEq for BitTail<M> where M: BitMemory,

impl<M> StructuralPartialEq for BitTail<M> where M: BitMemory,

Auto Trait Implementations

impl<M> RefUnwindSafe for BitTail<M> where M: RefUnwindSafe,

impl<M> Send for BitTail<M>

impl<M> Sync for BitTail<M>

impl<M> Unpin for BitTail<M>

impl<M> UnwindSafe for BitTail<M> where M: 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> 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<T> From<T> for T

pub fn from(t: T) -> T

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

pub fn into(self) -> U

impl<T> Pipe for T

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R

impl<T> PipeAsRef for T

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,

impl<T> PipeBorrow for T

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,

impl<T> PipeDeref for T

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,

impl<T> PipeRef for T

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,

impl<M> BitTail<M> where
M: BitMemory,

impl<M: Clone> Clone for BitTail<M> where
M: BitMemory,

impl<M> Debug for BitTail<M> where
M: BitMemory,

impl<M: Default> Default for BitTail<M> where
M: BitMemory,

impl<M> Display for BitTail<M> where
M: BitMemory,

impl<M: Hash> Hash for BitTail<M> where
M: BitMemory,

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

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

impl<M: Ord> Ord for BitTail<M> where
M: BitMemory,

impl<M: PartialEq> PartialEq<BitTail<M>> for BitTail<M> where
M: BitMemory,

impl<M: PartialOrd> PartialOrd<BitTail<M>> for BitTail<M> where
M: BitMemory,

impl<M: Copy> Copy for BitTail<M> where
M: BitMemory,

impl<M: Eq> Eq for BitTail<M> where
M: BitMemory,

impl<M> StructuralEq for BitTail<M> where
M: BitMemory,

impl<M> StructuralPartialEq for BitTail<M> where
M: BitMemory,

impl<M> RefUnwindSafe for BitTail<M> where
M: RefUnwindSafe,

impl<M> UnwindSafe for BitTail<M> where
M: 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 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>,

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<F, R>(self, func: F) -> Self where
F: FnOnce(&Self) -> R,

fn tap_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&Self) -> R,

fn tap_mut<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R,

fn tap_mut_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R,

impl<T, U> TapAsRef<U> for T where
U: ?Sized,

fn tap_ref<F, R>(self, func: F) -> Self where
Self: AsRef<T>,
F: FnOnce(&T) -> R,

fn tap_ref_dbg<F, R>(self, func: F) -> Self where
Self: AsRef<T>,
F: FnOnce(&T) -> R,

fn tap_ref_mut<F, R>(self, func: F) -> Self where
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,

fn tap_ref_mut_dbg<F, R>(self, func: F) -> Self where
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,

impl<T, U> TapBorrow<U> for T where
U: ?Sized,

fn tap_borrow<F, R>(self, func: F) -> Self where
Self: Borrow<T>,
F: FnOnce(&T) -> R,

fn tap_borrow_dbg<F, R>(self, func: F) -> Self where
Self: Borrow<T>,
F: FnOnce(&T) -> R,

fn tap_borrow_mut<F, R>(self, func: F) -> Self where
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,

fn tap_borrow_mut_dbg<F, R>(self, func: F) -> Self where
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,

fn tap_deref<F, R>(self, func: F) -> Self where
Self: Deref,
F: FnOnce(&Self::Target) -> R,

fn tap_deref_dbg<F, R>(self, func: F) -> Self where
Self: Deref,
F: FnOnce(&Self::Target) -> R,

fn tap_deref_mut<F, R>(self, func: F) -> Self where
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,

fn tap_deref_mut_dbg<F, R>(self, func: F) -> Self where
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,

fn try_conv<T>(self) -> Result<T, Self::Error> where
Self: TryInto<T>,

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

impl<T, U> TryInto<U> for T where
U: TryFrom<T>,