Struct bitvec::access::BitSafeU8

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

Read-Only Shared-Mutable Handle

This type marks a handle to a shared-mutable type that may be modified through other handles, but cannot be modified through this one. It is used when a BitSlice region has partial ownership of an element and wishes to expose the entire underlying raw element to the user without granting them write permissions.

Under the feature = "atomic" build setting, this uses radium’s best-effort atomic alias; when this feature is disabled, it reverts to Cell.

Trait Implementations

impl BitSafe for BitSafeU8

type Mem = u8

The element type being guarded against improper mutation.

type Rad = AtomicU8

The memory-access type this guards.

const ZERO: Self = _

The zero constant.

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

Loads the value from memory, allowing for the possibility that other handles have write permissions to it.

impl BitStore for BitSafeU8

type Mem = u8

The element type used in the memory region underlying a BitSlice. It is always one of the unsigned integer fundamentals.

type Access = <BitSafeU8 as BitSafe>::Rad

A type that selects the appropriate load/store instructions when 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 = BitSafeU8

A sibling BitStore implementor that is known to be alias-safe. It is used when a BitSlice introduces multiple handles that view the same memory location, and at least one of them has write capabilities to it. It must have the same underlying memory type, and can only change access patterns or public-facing usage.

type Unalias = u8

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

const ZERO: Self = <Self as BitSafe>::ZERO

The zero constant.

fn new(value: Self::Mem) -> Self

Wraps a raw memory value as a BitStore type.

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

Loads a value out of the memory system according to the ::Access rules. This may be called when the value is aliased by a write-capable reference.

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

Stores a value into the memory system. This is only called when there are no other handles to the value, and it may bypass ::Access constraints.

const ALIGNED_TO_SIZE: [(); 1] = _

All implementors are required to have their alignment match their size.

const ALIAS_WIDTH: [(); 1] = _

All implementors are required to have Self and Self::Alias be equal in representation. This is true by fiat for all types except the unsigned integers.

fn get_bit<O>(&self, index: BitIdx<Self::Mem>) -> boolwhere 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 BitSafeU8

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

Formats the value using the given formatter.