Struct bitvec::index::BitIdx[−][src]

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

Expand description

A semantic index of a single bit within a register R.

This type is a counter in the range 0 .. R::BITS, and marks the semantic position of a bit according to some BitOrder implementation. As an abstract counter, it can be used in arithmetic without having to go through BitOrder translation to an electrical position.

Type Parameters

R: The register type that these values govern.

Validity

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

Struct bitvec::index::BitIdx[−][src]

Implementations

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

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 value(self) -> u8

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

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 = BitIdxErr<R>

fn try_from(idx: 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<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 where T: ?Sized,

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

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,

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

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(
from: Self,
upto: BitTail<R>
) -> 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,

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

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

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,