Enum bitvec::domain::BitDomain

pub enum BitDomain<'a, O, T> where
    O: BitOrder,
    T: BitStore,  {
    Enclave {
        head: BitIdx<T::Mem>,
        body: &'a BitSlice<O, T>,
        tail: BitTail<T::Mem>,
    },
    Region {
        head: &'a BitSlice<O, T>,
        body: &'a BitSlice<O, T::Unalias>,
        tail: &'a BitSlice<O, T>,
    },
}

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 acts like the .split* methods in that it only subdivides the source BitSlice into smaller BitSlices, and makes appropriate modifications to the aliasing markers.

It does not add any aliasing markers: if the slice is marked as aliased, then the edge partitions will retain that marker, and if it is not, then the edge partitions do not need it.

This does not provide references to the underlying memory buffer. If you need such direct access, use the Domain or DomainMut enums.

Lifetimes

• 'a: The lifetime of the referent storage region.

Type Parameters

• O: The ordering type of the source BitSlice handle.
• T: The register type of the source BitSlice handle, including any aliasing markers.

Aliasing Awareness

This enum does not grant access to memory outside the scope of the original BitSlice handle, and so does not need to modfiy any aliasing conditions.

Variants

Enclave

Fields

head: BitIdx<T::Mem>

The start index of the BitSlice.

This is not likely to be useful information, but is retained for structural similarity with the rest of the module.

body: &'a BitSlice<O, T>

The original BitSlice used to create this bit-domain view.

tail: BitTail<T::Mem>

The end index of the BitSlice.

This is not likely to be useful information, but is retained for structural similarity with the rest of the module.

Indicates that a BitSlice is contained entirely in the interior indices of a single memory register.

Region

Fields

head: &'a BitSlice<O, T>

Any bits that partially-fill the base element of the slice region.

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

body: &'a BitSlice<O, T::Unalias>

Any bits inside elements that the source BitSlice completely covers.

This is marked as unaliased, 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: &'a BitSlice<O, T>

Any bits that partially fill the last element of the slice region.

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

Indicates that a BitSlice region touches at least one edge index of any number of elements.

This contains two BitSlices representing the partially-occupied edge elements, with their original aliasing marker, and one BitSlice representing the fully-occupied interior elements, marked as unaliased.

Implementations

impl<'a, O, T> BitDomain<'a, O, T> where
    O: BitOrder,
    T: BitStore, 

pub fn enclave(
    self
) -> Option<(BitIdx<T::Mem>, &'a BitSlice<O, T>, BitTail<T::Mem>)>

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<(&'a BitSlice<O, T>, &'a BitSlice<O, T::Unalias>, &'a BitSlice<O, T>)>

Attempts to view the domain as a 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

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

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, O: Debug, T: Debug> Debug for BitDomain<'a, O, T> where
    O: BitOrder,
    T: BitStore,
    T::Mem: Debug,
    T::Mem: Debug,
    T::Unalias: Debug, 

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

Formats the value using the given formatter.

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