Struct bitvec::domain::PartialElement

pub struct PartialElement<'a, M, T, O>
where
    M: Mutability,
    T: 'a + BitStore,
    O: BitOrder,
{ /* private fields */ }

Partially-Owned Memory Element

This type is a guarded reference to memory that permits interacting with it as an integer, but only allows views to the section of the integer that the producing handle has permission to observe. Unlike the BitSafe type family in the access module, it is not a transparent wrapper that can be used for reference conversion; it is a “heavy reference” that carries the mask and

Type Parameters

• T: The type, including register width and alias information, of the bit-slice handle that created it.
• O: This propagates the bit-ordering type used by the BitSlice handle that created it.

Lifetime

This carries the lifetime of the bit-slice handle that created it.

Usage

This structure is only created as part of the Domain region descriptions, and refers to partially-occupied edge elements. The underlying referent memory can be read with .load_value() or written with .store_value(), and the appropriate masking will be applied in order to restrict access to only the permitted bits.

Implementations

impl<'a, M, T, O> PartialElement<'a, M, T, O>

where M: Mutability, T: 'a + BitStore, O: BitOrder,

pub fn load_value(&self) -> T::Mem

Fetches the value stored through self and masks away extra bits.

Returns

A bit-map containing any bits set to 1 in the governed bits. All other bits are cleared to 0.

pub fn head(&self) -> BitIdx<T::Mem>

Gets the starting index of the live bits in the element.

pub fn tail(&self) -> BitEnd<T::Mem>

Gets the ending index of the live bits in the element.

pub fn bounds(&self) -> (BitIdx<T::Mem>, BitEnd<T::Mem>)

Gets the semantic head and tail indices that constrain which bits of the referent element may be accessed.

pub fn mask(&self) -> BitMask<T::Mem>

Gets the bit-mask over all accessible bits.

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

where Address<M, BitSlice<T, O>>: Referential<'a>,

Converts the partial element into a bit-slice over its governed bits.

impl<'a, T, O> PartialElement<'a, Mut, T, O>

where T: BitStore, O: BitOrder, Address<Mut, T>: Referential<'a>,

pub fn store_value(&mut self, value: T::Mem) -> T::Mem

Stores a value through self after masking away extra bits.

Parameters

• &mut self
• value: A bit-map which will be written into the governed bits. This is a bit-map store, not an integer store; the value will not be shifted into position and will only be masked directly against the bits that this partial-element governs.

Returns

The previous value of the governed bits.

pub fn invert(&mut self) -> T::Mem

Inverts the value of each bit governed by the partial-element.

Returns

The previous value of the governed bits.

pub fn clear(&mut self) -> T::Mem

Clears all bits governed by the partial-element to 0.

Returns

The previous value of the governed bits.

pub fn set(&mut self) -> T::Mem

Sets all bits governed by the partial-element to 1.

Returns

The previous value of the governed bits.

impl<'a, M, T, O> PartialElement<'a, M, T, O>

where M: Mutability, O: BitOrder, T: 'a + BitStore + Radium,

pub fn store_value_aliased(&self, value: T::Mem) -> T::Mem

Performs a store operation on a partial-element whose bits might be observed by another handle.

Trait Implementations

impl<'a, T, O> Clone for PartialElement<'a, Const, T, O>

where T: BitStore, O: BitOrder, Address<Const, T>: Referential<'a>,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, M, T, O> Debug for PartialElement<'a, M, T, O>

where M: Mutability, T: 'a + BitStore, O: BitOrder,

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

Formats the value using the given formatter.

impl<'a, M, T, O> Hash for PartialElement<'a, M, T, O>

where M: Mutability, T: 'a + BitStore, O: BitOrder,

fn hash<H>(&self, hasher: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T, O> Copy for PartialElement<'_, Const, T, O>

where T: BitStore, O: BitOrder,