Struct bitvec::index::BitPos

source · [−]

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

Expand description

An electrical position of a single bit within a memory element M.

This type is used as the shift distance in the expression 1 << shamt. It is only produced by the translation of a semantic BitIdx<M> according to some BitOrder implementation using BitOrder::at. It can only be used for the construction of bit masks used to manipulate a register value during memory access, and serves no other purpose.

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, and users are required to do the same.

Construction

This type offers public unsafe constructors. bitvec does not offer any public APIs that take values of this type directly; it always routes through BitOrder implementations. As BitIdx will only be constructed from safe, correct, values, and BitOrder::at is the only BitIdx -> BitPos transform function, all constructed BitPos values are known to be memory-correct.

Struct bitvec::index::BitPos

Implementations

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

pub unsafe fn new(pos: u8) -> Option<Self>

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

pub fn select(self) -> BitSel<M>

pub fn mask(self) -> BitMask<M>

pub fn value(self) -> u8

Trait Implementations

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

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

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

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

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

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

fn default() -> BitPos<M>

impl<M: Hash> Hash for BitPos<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 BitPos<M> where M: BitMemory,

fn cmp(&self, other: &BitPos<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<BitPos<M>> for BitPos<M> where M: BitMemory,

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

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

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

fn partial_cmp(&self, other: &BitPos<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 BitPos<M> where M: BitMemory,

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

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

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

Auto Trait Implementations

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

impl<M> Send for BitPos<M>

impl<M> Sync for BitPos<M>

impl<M> Unpin for BitPos<M>

impl<M> UnwindSafe for BitPos<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<T> Tap for T

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

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

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

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

impl<M: Hash> Hash for BitPos<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 BitPos<M> where
M: BitMemory,

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

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

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

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

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

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

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

impl<M> UnwindSafe for BitPos<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>,