Struct bitvec::access::BitSafeU64

#[repr(transparent)]
pub struct BitSafeU64 { /* private fields */ }

A wrapper over a shared-mutable type that forbids writing to the location through its own reference. Other references to the location may still write to it, and reads from this reference will be aware of this possibility.

This is necessary in order to enforce bitvec’s memory model, which disallows shared mutation to individual bits. BitSlices may produce memory views that use this type in order to ensure that handles that lack write permission to an area may not write to it, even if other handles may.

Under the "atomic" feature, this uses radium’s best-effort atomic alias; when this feature is disabled, then it uses a Cell directly.

Trait Implementations

impl BitSafe for BitSafeU64

type Mem = u64

The register type being guarded against shared mutation.

type Rad = Cell<u64>

The accessor type being prevented from mutating while shared.

fn load(&self) -> u64

Reads the value out of memory only if a shared reference to the location can be produced.

fn store(&mut self, value: u64)

Writes a value into memory only if an exclusive reference to the location can be produced.

impl BitStore for BitSafeU64

This type is only ever produced by calling .split_at_mut() on BitSlice<_, T> where T is an unsigned integer. It cannot be constructed as a base data source.

type Mem = u64

The register type used in the slice region underlying a BitSlice handle. It is always an unsigned integer.

type Access = <Self as BitSafe>::Rad

A type that selects appropriate load/store instructions used for accessing the memory bus. It determines what instructions are used when moving a Self::Mem value between the processor and the memory system.

type Alias = Self

A sibling BitStore implementor. It is used when a BitSlice introduces multiple handles that view the same memory location, and at least one of them has write permission to it.

type Unalias = u64

The inverse of Alias. It is used when a BitSlice removes the conditions that required a T -> T::Alias transition.

fn load_value(&self) -> Self::Mem

Loads a value out of the memory system according to the ::Access rules.

fn store_value(&mut self, value: Self::Mem)

Stores a value into the memory system according to the ::Access rules.

fn get_bit<O>(&self, index: BitIdx<Self::Mem>) -> bool where
    O: BitOrder, 

Reads a single bit out of the memory system according to the ::Access rules. This is lifted from BitAccess so that it can be used elsewhere without additional casts.

impl Debug for BitSafeU64

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

Formats the value using the given formatter.