Enum bitvec::domain::DomainMut [−][src]
pub enum DomainMut<'a, T> where
T: BitStore, { Enclave { head: BitIdx<T::Mem>, elem: &'a T::Access, tail: BitTail<T::Mem>, }, Region { head: Option<(BitIdx<T::Mem>, &'a T::Access)>, body: &'a mut [T::Unalias], tail: Option<(&'a T::Access, BitTail<T::Mem>)>, }, }
Granular representation of the memory region containing a
BitSlice.
BitSlice regions can be described in terms of edge and center
partitions, where the edge partitions must retain the aliasing
status of the source BitSlice handle, and the center partition is
known to be completely unaliased by any other view. This property
allows any BitSlice handle to be decomposed into smaller regions,
and safely remove any aliasing markers from the center partition
that no longer requires such safeguarding.
This enum splits the underlying element slice [T] into the
maybe-aliased edge elements and known-unaliased center elements. If
you do not need to work with the memory elements directly, and only
need to firmly specify the access behavior of the BitSlice
handle, use the BitDomain and BitDomainMut enums.
Lifetimes
'a: The lifetime of the referent storage region.
Type Parameters
T: The register type of the sourceBitSlicehandle, including any aliasing markers.
Mutability
The immutable view produces T::Alias references, which permit
foreign writes to the referent location but disallow writes through
itself. The mutable view produces T::Access references, because
&mut _ references can only ever be produced when no other aliasing
handle exists. The write permissions must be weakened from
&mut T::Alias to &T::Access in order to satisfy the Rust memory
rules.
The edge references do not forbid modifying bits outside of the
source BitSlice domain, and writes out of bounds will be
correctly handled by any other handles capable of viewing those
elements. Doing so is still incorrect, though defined, and you are
responsible for writing only within bounds when using DomainMut.
Variants
Indicates that a BitSlice is contained entirely in the
interior indices of a single memory element.
Show fields
Fields of Enclave
Indicates that a BitSlice region touches at least one edge
index of any number of elements.
This contains two optional references to the aliased edges, and one reference to the unaliased middle. Each can be queried and used individually.
Show fields
Fields of Region
head: Option<(BitIdx<T::Mem>, &'a T::Access)>If the BitSlice started in the interior of its first
element, this contains the starting index and the base
address.
body: &'a mut [T::Unalias]All fully-spanned, unaliased, elements.
This is marked as bare memory without any access
protections, because it is statically impossible for any
other handle to have write access to the region it covers.
As such, a BitSlice that was marked as entirely aliased,
but contains interior unaliased elements, can safely remove
its aliasing protections.
tail: Option<(&'a T::Access, BitTail<T::Mem>)>If the BitSlice ended in the interior of its last element,
this contains the ending index and the last address.
Implementations
impl<'a, T> DomainMut<'a, T> where
T: BitStore, [src]
impl<'a, T> DomainMut<'a, T> where
T: BitStore, [src]pub fn enclave(self) -> Option<(BitIdx<T::Mem>, &'a T::Access, BitTail<T::Mem>)>[src]
Attempts to view the domain as an enclave variant.
Parameters
self
Returns
If self is the Enclave variant, this returns Some of the
enclave fields, as a tuple. Otherwise, it returns None.
pub fn region(
self
) -> Option<(Option<(BitIdx<T::Mem>, &'a T::Access)>, &'a mut [T::Unalias], Option<(&'a T::Access, BitTail<T::Mem>)>)>[src]
self
) -> Option<(Option<(BitIdx<T::Mem>, &'a T::Access)>, &'a mut [T::Unalias], Option<(&'a T::Access, BitTail<T::Mem>)>)>
Attempts to view the domain as the region variant.
Parameters
self
Returns
If self is the Region variant, this returns Some of the
region fields, as a tuple. Otherwise, it returns None.
Trait Implementations
Auto Trait Implementations
impl<'a, T> RefUnwindSafe for DomainMut<'a, T> where
<T as BitStore>::Access: RefUnwindSafe,
<T as BitStore>::Mem: RefUnwindSafe,
<T as BitStore>::Unalias: RefUnwindSafe,
<T as BitStore>::Access: RefUnwindSafe,
<T as BitStore>::Mem: RefUnwindSafe,
<T as BitStore>::Unalias: RefUnwindSafe,
impl<'a, T> Send for DomainMut<'a, T> where
<T as BitStore>::Access: Sync,
<T as BitStore>::Unalias: Send,
<T as BitStore>::Access: Sync,
<T as BitStore>::Unalias: Send,
impl<'a, T> Sync for DomainMut<'a, T> where
<T as BitStore>::Access: Sync,
<T as BitStore>::Unalias: Sync,
<T as BitStore>::Access: Sync,
<T as BitStore>::Unalias: Sync,
impl<'a, T> Unpin for DomainMut<'a, T>
impl<'a, T> !UnwindSafe for DomainMut<'a, T>
Blanket Implementations
impl<T> FmtForward for T[src]
impl<T> FmtForward for T[src]pub fn fmt_binary(self) -> FmtBinary<Self> where
Self: Binary, [src]
Self: Binary,
pub fn fmt_display(self) -> FmtDisplay<Self> where
Self: Display, [src]
Self: Display,
pub fn fmt_lower_exp(self) -> FmtLowerExp<Self> where
Self: LowerExp, [src]
Self: LowerExp,
pub fn fmt_lower_hex(self) -> FmtLowerHex<Self> where
Self: LowerHex, [src]
Self: LowerHex,
pub fn fmt_octal(self) -> FmtOctal<Self> where
Self: Octal, [src]
Self: Octal,
pub fn fmt_pointer(self) -> FmtPointer<Self> where
Self: Pointer, [src]
Self: Pointer,
pub fn fmt_upper_exp(self) -> FmtUpperExp<Self> where
Self: UpperExp, [src]
Self: UpperExp,
pub fn fmt_upper_hex(self) -> FmtUpperHex<Self> where
Self: UpperHex, [src]
Self: UpperHex,
impl<T> Pipe for T where
T: ?Sized, [src]
impl<T> Pipe for T where
T: ?Sized, [src]pub fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R[src]
pub fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where
R: 'a, [src]
R: 'a,
pub fn pipe_ref_mut<'a, R>(
&'a mut self,
func: impl FnOnce(&'a mut Self) -> R
) -> R where
R: 'a, [src]
&'a mut self,
func: impl FnOnce(&'a mut Self) -> R
) -> R where
R: 'a,
pub fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R where
Self: Borrow<B>,
R: 'a,
B: 'a + ?Sized, [src]
Self: Borrow<B>,
R: 'a,
B: 'a + ?Sized,
pub fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R where
Self: BorrowMut<B>,
R: 'a,
B: 'a + ?Sized, [src]
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R where
Self: BorrowMut<B>,
R: 'a,
B: 'a + ?Sized,
pub fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R where
Self: AsRef<U>,
R: 'a,
U: 'a + ?Sized, [src]
Self: AsRef<U>,
R: 'a,
U: 'a + ?Sized,
pub fn pipe_as_mut<'a, U, R>(
&'a mut self,
func: impl FnOnce(&'a mut U) -> R
) -> R where
Self: AsMut<U>,
R: 'a,
U: 'a + ?Sized, [src]
&'a mut self,
func: impl FnOnce(&'a mut U) -> R
) -> R where
Self: AsMut<U>,
R: 'a,
U: 'a + ?Sized,
pub 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, [src]
Self: Deref<Target = T>,
T: 'a + ?Sized,
R: 'a,
pub 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, [src]
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: DerefMut<Target = T> + Deref,
T: 'a + ?Sized,
R: 'a,
impl<T> PipeAsRef for T[src]
impl<T> PipeAsRef for T[src]pub fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: AsRef<T>,
T: 'a,
R: 'a, [src]
Self: AsRef<T>,
T: 'a,
R: 'a,
pub 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, [src]
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: AsMut<T>,
T: 'a,
R: 'a,
impl<T> PipeBorrow for T[src]
impl<T> PipeBorrow for T[src]pub fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Borrow<T>,
T: 'a,
R: 'a, [src]
Self: Borrow<T>,
T: 'a,
R: 'a,
pub 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, [src]
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: BorrowMut<T>,
T: 'a,
R: 'a,
impl<T> PipeDeref for T[src]
impl<T> PipeDeref for T[src]pub fn pipe_deref<'a, R>(
&'a self,
func: impl FnOnce(&'a Self::Target) -> R
) -> R where
Self: Deref,
R: 'a, [src]
&'a self,
func: impl FnOnce(&'a Self::Target) -> R
) -> R where
Self: Deref,
R: 'a,
pub fn pipe_deref_mut<'a, R>(
&'a mut self,
func: impl FnOnce(&'a mut Self::Target) -> R
) -> R where
Self: DerefMut,
R: 'a, [src]
&'a mut self,
func: impl FnOnce(&'a mut Self::Target) -> R
) -> R where
Self: DerefMut,
R: 'a,
impl<T> Tap for T[src]
impl<T> Tap for T[src]pub fn tap(self, func: impl FnOnce(&Self)) -> Self[src]
pub fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self[src]
pub fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized, [src]
Self: Borrow<B>,
B: ?Sized,
pub fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized, [src]
Self: BorrowMut<B>,
B: ?Sized,
pub fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self where
Self: AsRef<R>,
R: ?Sized, [src]
Self: AsRef<R>,
R: ?Sized,
pub fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized, [src]
Self: AsMut<R>,
R: ?Sized,
pub fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self where
Self: Deref<Target = T>,
T: ?Sized, [src]
Self: Deref<Target = T>,
T: ?Sized,
pub fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self where
Self: DerefMut<Target = T> + Deref,
T: ?Sized, [src]
Self: DerefMut<Target = T> + Deref,
T: ?Sized,
pub fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self[src]
pub fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self[src]
pub fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized, [src]
Self: Borrow<B>,
B: ?Sized,
pub fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized, [src]
Self: BorrowMut<B>,
B: ?Sized,
pub fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self where
Self: AsRef<R>,
R: ?Sized, [src]
Self: AsRef<R>,
R: ?Sized,
pub fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized, [src]
Self: AsMut<R>,
R: ?Sized,
pub fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self where
Self: Deref<Target = T>,
T: ?Sized, [src]
Self: Deref<Target = T>,
T: ?Sized,
pub fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self where
Self: DerefMut<Target = T> + Deref,
T: ?Sized, [src]
Self: DerefMut<Target = T> + Deref,
T: ?Sized,
impl<T> Tap for T[src]
impl<T> Tap for T[src]pub fn tap<F, R>(self, func: F) -> Self where
F: FnOnce(&Self) -> R, [src]
F: FnOnce(&Self) -> R,
pub fn tap_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&Self) -> R, [src]
F: FnOnce(&Self) -> R,
pub fn tap_mut<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R, [src]
F: FnOnce(&mut Self) -> R,
pub fn tap_mut_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R, [src]
F: FnOnce(&mut Self) -> R,
impl<T, U> TapAsRef<U> for T where
U: ?Sized, [src]
impl<T, U> TapAsRef<U> for T where
U: ?Sized, [src]pub fn tap_ref<F, R>(self, func: F) -> Self where
Self: AsRef<T>,
F: FnOnce(&T) -> R, [src]
Self: AsRef<T>,
F: FnOnce(&T) -> R,
pub fn tap_ref_dbg<F, R>(self, func: F) -> Self where
Self: AsRef<T>,
F: FnOnce(&T) -> R, [src]
Self: AsRef<T>,
F: FnOnce(&T) -> R,
pub fn tap_ref_mut<F, R>(self, func: F) -> Self where
Self: AsMut<T>,
F: FnOnce(&mut T) -> R, [src]
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
pub fn tap_ref_mut_dbg<F, R>(self, func: F) -> Self where
Self: AsMut<T>,
F: FnOnce(&mut T) -> R, [src]
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
impl<T, U> TapBorrow<U> for T where
U: ?Sized, [src]
impl<T, U> TapBorrow<U> for T where
U: ?Sized, [src]pub fn tap_borrow<F, R>(self, func: F) -> Self where
Self: Borrow<T>,
F: FnOnce(&T) -> R, [src]
Self: Borrow<T>,
F: FnOnce(&T) -> R,
pub fn tap_borrow_dbg<F, R>(self, func: F) -> Self where
Self: Borrow<T>,
F: FnOnce(&T) -> R, [src]
Self: Borrow<T>,
F: FnOnce(&T) -> R,
pub fn tap_borrow_mut<F, R>(self, func: F) -> Self where
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R, [src]
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
pub fn tap_borrow_mut_dbg<F, R>(self, func: F) -> Self where
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R, [src]
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
impl<T> TapDeref for T[src]
impl<T> TapDeref for T[src]pub fn tap_deref<F, R>(self, func: F) -> Self where
Self: Deref,
F: FnOnce(&Self::Target) -> R, [src]
Self: Deref,
F: FnOnce(&Self::Target) -> R,
pub fn tap_deref_dbg<F, R>(self, func: F) -> Self where
Self: Deref,
F: FnOnce(&Self::Target) -> R, [src]
Self: Deref,
F: FnOnce(&Self::Target) -> R,
pub fn tap_deref_mut<F, R>(self, func: F) -> Self where
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R, [src]
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
pub fn tap_deref_mut_dbg<F, R>(self, func: F) -> Self where
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R, [src]
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,