Enum bitvec::domain::BitDomain

source ·
pub enum BitDomain<'a, M = Const, T = usize, O = Lsb0>where
    M: Mutability,
    T: 'a + BitStore,
    O: BitOrder,
    Address<M, BitSlice<T, O>>: Referential<'a>,
    Address<M, BitSlice<T::Unalias, O>>: Referential<'a>,{
    Enclave(Reference<'a, M, BitSlice<T, O>>),
    Region {
        head: Reference<'a, M, BitSlice<T, O>>,
        body: Reference<'a, M, BitSlice<T::Unalias, O>>,
        tail: Reference<'a, M, BitSlice<T, O>>,
    },
}
Expand description

Bit-Slice Partitioning

This enum partitions a bit-slice into its head- and tail- edge bit-slices, and its interior body bit-slice, according to the definitions laid out in the module documentation.

It fragments a BitSlice into smaller BitSlices, and allows the interior bit-slice to become ::Unaliased. This is useful when you need to retain a bit-slice view of memory, but wish to remove synchronization costs imposed by a prior call to .split_at_mut() for as much of the bit-slice as possible.

Why Not Option?

The Enclave variant always contains as its single field the exact bit-slice that created the Enclave. As such, this type is easily replaceäble with an Option of the Region variant, which when None is understood to be the original.

This exists as a dedicated enum, even with a technically useless variant, in order to mirror the shape of the element-domain enum. This type should be understood as a shortcut to the end result of splitting by element-domain, then mapping each PartialElement and slice back into BitSlices, rather than testing whether a bit-slice can be split on alias boundaries.

You can get the alternate behavior, of testing whether or not a bit-slice can be split into a Region or is unsplittable, by calling .bit_domain().region() to produce exactly such an Option.

Variants§

§

Enclave(Reference<'a, M, BitSlice<T, O>>)

Indicates that a bit-slice’s contents are entirely in the interior indices of a single memory element.

The contained value is always the bit-slice that created this view.

§

Region

Fields

§head: Reference<'a, M, BitSlice<T, O>>

Any bits that partially-fill the first element of the underlying storage region.

This does not modify its aliasing status, as it will already be appropriately marked before this view is constructed.

§body: Reference<'a, M, BitSlice<T::Unalias, O>>

Any bits that wholly-fill elements in the interior of the bit-slice.

This is marked as unaliased, because it is statically impossible for any other handle derived from the source bit-slice to have conflicting access to the region of memory it describes. As such, even a bit-slice that was marked as ::Alias can revert this protection on the known-unaliased interior.

Proofs:

  • Rust’s &/&mut exclusion rules universally apply. If a reference exists, no other reference has unsynchronized write capability.
  • BitStore::Unalias only modifies unsynchronized types. Cell and atomic types unalias to themselves, and retain their original behavior.
§tail: Reference<'a, M, BitSlice<T, O>>

Any bits that partially-fill the last element of the underlying storage region.

This does not modify its aliasing status, as it will already be appropriately marked before this view is constructed.

Indicates that a bit-slice’s contents touch an element edge.

This splits the bit-slice into three partitions, each of which may be empty: two partially-occupied edge elements, with their original type status, and one interior span, which is known to not have any other aliases derived from the bit-slice that created this view.

Implementations§

source§

impl<'a, M, T, O> BitDomain<'a, M, T, O>where M: Mutability, T: 'a + BitStore, O: BitOrder, Address<M, BitSlice<T, O>>: Referential<'a>, Address<M, BitSlice<T::Unalias, O>>: Referential<'a>,

source

pub fn enclave(self) -> Option<Reference<'a, M, BitSlice<T, O>>>

Attempts to unpack the bit-domain as an Enclave variant. This is just a shorthand for explicit destructuring.

source

pub fn region( self ) -> Option<(Reference<'a, M, BitSlice<T, O>>, Reference<'a, M, BitSlice<T::Unalias, O>>, Reference<'a, M, BitSlice<T, O>>)>

Attempts to unpack the bit-domain as a Region variant. This is just a shorthand for explicit destructuring.

Trait Implementations§

source§

impl<T, O> Clone for BitDomain<'_, Const, T, O>where T: BitStore, O: BitOrder,

source§

fn clone(&self) -> Self

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl<'a, M, T, O> Debug for BitDomain<'a, M, T, O>where M: Mutability, T: 'a + BitStore, O: BitOrder, Address<M, BitSlice<T, O>>: Referential<'a>, Address<M, BitSlice<T::Unalias, O>>: Referential<'a>, Reference<'a, M, BitSlice<T, O>>: Debug, Reference<'a, M, BitSlice<T::Unalias, O>>: Debug,

source§

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

Formats the value using the given formatter. Read more
source§

impl<'a, M, T, O> Default for BitDomain<'a, M, T, O>where M: Mutability, T: 'a + BitStore, O: BitOrder, Address<M, BitSlice<T, O>>: Referential<'a>, Address<M, BitSlice<T::Unalias, O>>: Referential<'a>, Reference<'a, M, BitSlice<T, O>>: Default, Reference<'a, M, BitSlice<T::Unalias, O>>: Default,

source§

fn default() -> Self

Returns the “default value” for a type. Read more
source§

impl<T, O> Copy for BitDomain<'_, Const, T, O>where T: BitStore, O: BitOrder,

Auto Trait Implementations§

§

impl<'a, M = Const, T = usize, O = Lsb0> !RefUnwindSafe for BitDomain<'a, M, T, O>

§

impl<'a, M = Const, T = usize, O = Lsb0> !Send for BitDomain<'a, M, T, O>

§

impl<'a, M = Const, T = usize, O = Lsb0> !Sync for BitDomain<'a, M, T, O>

§

impl<'a, M = Const, T = usize, O = Lsb0> !Unpin for BitDomain<'a, M, T, O>

§

impl<'a, M = Const, T = usize, O = Lsb0> !UnwindSafe for BitDomain<'a, M, T, O>

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

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

Mutably borrows from an owned value. Read more
source§

impl<T> Conv for T

source§

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

Converts self into T using Into<T>. Read more
source§

impl<T> FmtForward for T

source§

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

Causes self to use its Binary implementation when Debug-formatted.
source§

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

Causes self to use its Display implementation when Debug-formatted.
source§

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

Causes self to use its LowerExp implementation when Debug-formatted.
source§

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

Causes self to use its LowerHex implementation when Debug-formatted.
source§

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

Causes self to use its Octal implementation when Debug-formatted.
source§

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

Causes self to use its Pointer implementation when Debug-formatted.
source§

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

Causes self to use its UpperExp implementation when Debug-formatted.
source§

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

Causes self to use its UpperHex implementation when Debug-formatted.
source§

fn fmt_list(self) -> FmtList<Self>where &'a Self: for<'a> IntoIterator,

Formats each item in a sequence. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

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

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

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

source§

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

Pipes by value. This is generally the method you want to use. Read more
source§

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

Borrows self and passes that borrow into the pipe function. Read more
source§

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

Mutably borrows self and passes that borrow into the pipe function. Read more
source§

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

Borrows self, then passes self.borrow() into the pipe function. Read more
source§

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

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more
source§

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

Borrows self, then passes self.as_ref() into the pipe function.
source§

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

Mutably borrows self, then passes self.as_mut() into the pipe function.
source§

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

Borrows self, then passes self.deref() into the pipe function.
source§

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

Mutably borrows self, then passes self.deref_mut() into the pipe function.
source§

impl<T> Tap for T

source§

fn tap(self, func: impl FnOnce(&Self)) -> Self

Immutable access to a value. Read more
source§

fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self

Mutable access to a value. Read more
source§

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

Immutable access to the Borrow<B> of a value. Read more
source§

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

Mutable access to the BorrowMut<B> of a value. Read more
source§

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

Immutable access to the AsRef<R> view of a value. Read more
source§

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

Mutable access to the AsMut<R> view of a value. Read more
source§

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

Immutable access to the Deref::Target of a value. Read more
source§

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

Mutable access to the Deref::Target of a value. Read more
source§

fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self

Calls .tap() only in debug builds, and is erased in release builds.
source§

fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self

Calls .tap_mut() only in debug builds, and is erased in release builds.
source§

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

Calls .tap_borrow() only in debug builds, and is erased in release builds.
source§

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

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds.
source§

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

Calls .tap_ref() only in debug builds, and is erased in release builds.
source§

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

Calls .tap_ref_mut() only in debug builds, and is erased in release builds.
source§

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

Calls .tap_deref() only in debug builds, and is erased in release builds.
source§

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

Calls .tap_deref_mut() only in debug builds, and is erased in release builds.
source§

impl<T> ToOwned for Twhere T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T> TryConv for T

source§

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

Attempts to convert self into T using TryInto<T>. Read more
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

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

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.