Enum bitvec::domain::BitDomainMut

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

Granular representation of the memory region containing a BitSlice.

BitSlice regions can be described in terms of edge and center elements, where the edge elements retain the aliasing status of the source BitSlice handle, and the center elements are 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 subregion of memory that no longer requires them for correct access.

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 provide references to the underlying memory elements. If you need such access directly, 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 element type of the source BitSlice handle, including aliasing markers.

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 mut 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 element.

Region

Fields

head: &'a mut 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 mut BitSlice<O, T::Mem>

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.

Safety Exception

&BitSlice<O, T::Alias> references have access to a .set_aliased method, which represents the only means in bitvec of writing to memory without an exclusive &mut reference.

Construction of two such shared, aliasing, references over the same data, then construction of a bit-domain view over one of them and simultaneous writing through the other to interior elements marked as unaliased, will cause the bit-domain view to be undefined behavior. Do not combine bit-domain views and .set_aliased calls.

tail: &'a mut 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> BitDomainMut<'a, O, T> where
    O: BitOrder,
    T: 'a + BitStore, 

pub fn enclave(
    self
) -> Option<(BitIdx<T::Mem>, &'a mut 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 mut BitSlice<O, T>, &'a mut BitSlice<O, T::Mem>, &'a mut 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<'a, O: Debug, T: Debug> Debug for BitDomainMut<'a, O, T> where
    O: BitOrder,
    T: 'a + BitStore,
    T::Mem: Debug,
    T::Mem: Debug,
    T::Mem: Debug, 

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

Formats the value using the given formatter.