Struct BitSafeU32

#[repr(transparent)]
pub struct BitSafeU32 {
    inner: <BitSafeU32 as BitSafe>::Rad,
}

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.

Fields

inner: <BitSafeU32 as BitSafe>::Rad

Trait Implementations

impl BitSafe for BitSafeU32

const ZERO: BitSafeU32 = _

The zero constant.

type Mem = u32

The element type being guarded against improper mutation.

type Rad = AtomicU32

The memory-access type this guards.

fn load(&self) -> <BitSafeU32 as BitSafe>::Mem

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

impl BitStore for BitSafeU32

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

The zero constant.

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.

type Mem = u32

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

type Access = <BitSafeU32 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 = BitSafeU32

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 = u32

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

fn new(value: <BitSafeU32 as BitStore>::Mem) -> BitSafeU32

Wraps a raw memory value as a BitStore type.

fn load_value(&self) -> <BitSafeU32 as BitStore>::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: <BitSafeU32 as BitStore>::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.

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 BitSafeU32

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

Formats the value using the given formatter.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 4 bytes