pub trait BitStore: 'static + Debug {
type Mem: BitRegister + BitStore<Mem = Self::Mem>;
type Access: BitAccess<Item = Self::Mem> + BitStore<Mem = Self::Mem>;
type Alias: BitStore<Mem = Self::Mem>;
type Unalias: BitStore<Mem = Self::Mem>;
const ZERO: Self;
const ALIGNED_TO_SIZE: [(); 1];
const ALIAS_WIDTH: [(); 1];
fn new(value: Self::Mem) -> Self;
fn load_value(&self) -> Self::Mem;
fn store_value(&mut self, value: Self::Mem);
fn get_bit<O>(&self, index: BitIdx<Self::Mem>) -> bool
where
O: BitOrder,
{ ... }
}
Expand description
Bit Storage
This trait drives bitvec
’s ability to view memory as a collection of discrete
bits. It combines awareness of storage element width, memory-bus access
requirements, element contention, and buffer management, into a type-system
graph that the rest of the crate can use to abstract away concerns about memory
representation or access rules.
It is responsible for extending the standard Rust &
/&mut
shared/exclusion
rules to apply to individual bits while avoiding violating those rules when
operating on real memory so that Rust and LLVM cannot find fault with the object
code it produces.
Implementors
This is implemented on three type families:
- all
BitRegister
raw integer fundamentals - all
Cell
wrappers of them - all atomic variants of them
The BitSlice
region, and all structures composed atop it, can be built out
of regions of memory that have this trait implementation.
Associated Types
The associated types attached to each implementation create a closed graph of
type transitions used to manage alias conditions. When a bit-slice region
determines that an aliasing or unaliasing event has occurred, it transitions
along the type graph in order to maintain correct operations in memory. The
methods that cause type transitions can be found in BitSlice
and domain
.
Required Associated Types
type Mem: BitRegister + BitStore<Mem = Self::Mem>
type Mem: BitRegister + BitStore<Mem = Self::Mem>
The element type used in the memory region underlying a BitSlice
. It
is always one of the unsigned integer fundamentals.
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.
This must be at least able to manage aliasing.
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.
Required Associated Constants
const ALIGNED_TO_SIZE: [(); 1]
const ALIGNED_TO_SIZE: [(); 1]
All implementors are required to have their alignment match their size.
Use mem::aligned_to_size::<Self>()
to prove this.
const ALIAS_WIDTH: [(); 1]
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.
Use mem::layout_eq::<Self, Self::Alias>()
to prove this.
Required Methods
fn load_value(&self) -> Self::Mem
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)
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.
Provided Methods
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.
Type Parameters
O
: The ordering of bits withinSelf::Mem
governing the lookup.
Parameters
index
: The semantic index of a bit in*self
.
Returns
The value of the bit in *self
at BitOrder::at(index)
.
Implementations on Foreign Types
sourceimpl BitStore for u8
impl BitStore for u8
type Access = Cell<u8>
type Access = Cell<u8>
The unsigned integers will only be BitStore
type parameters
for handles to unaliased memory, following the normal Rust
reference rules.
type Mem = u8
type Alias = BitSafeU8
type Unalias = u8
const ZERO: Self = 0u8
fn new(value: Self::Mem) -> Self
fn load_value(&self) -> Self::Mem
fn store_value(&mut self, value: Self::Mem)
const ALIGNED_TO_SIZE: [(); 1] = _
const ALIAS_WIDTH: [(); 1] = _
sourceimpl BitStore for Cell<u8>
impl BitStore for Cell<u8>
type Mem = u8
type Access = Cell<u8>
type Alias = Cell<u8>
type Unalias = Cell<u8>
const ZERO: Self = _
fn new(value: Self::Mem) -> Self
fn load_value(&self) -> Self::Mem
fn store_value(&mut self, value: Self::Mem)
const ALIGNED_TO_SIZE: [(); 1] = _
const ALIAS_WIDTH: [(); 1] = _
sourceimpl BitStore for u16
impl BitStore for u16
type Access = Cell<u16>
type Access = Cell<u16>
The unsigned integers will only be BitStore
type parameters
for handles to unaliased memory, following the normal Rust
reference rules.
type Mem = u16
type Alias = BitSafeU16
type Unalias = u16
const ZERO: Self = 0u16
fn new(value: Self::Mem) -> Self
fn load_value(&self) -> Self::Mem
fn store_value(&mut self, value: Self::Mem)
const ALIGNED_TO_SIZE: [(); 1] = _
const ALIAS_WIDTH: [(); 1] = _
sourceimpl BitStore for Cell<u16>
impl BitStore for Cell<u16>
type Mem = u16
type Access = Cell<u16>
type Alias = Cell<u16>
type Unalias = Cell<u16>
const ZERO: Self = _
fn new(value: Self::Mem) -> Self
fn load_value(&self) -> Self::Mem
fn store_value(&mut self, value: Self::Mem)
const ALIGNED_TO_SIZE: [(); 1] = _
const ALIAS_WIDTH: [(); 1] = _
sourceimpl BitStore for u32
impl BitStore for u32
type Access = Cell<u32>
type Access = Cell<u32>
The unsigned integers will only be BitStore
type parameters
for handles to unaliased memory, following the normal Rust
reference rules.
type Mem = u32
type Alias = BitSafeU32
type Unalias = u32
const ZERO: Self = 0u32
fn new(value: Self::Mem) -> Self
fn load_value(&self) -> Self::Mem
fn store_value(&mut self, value: Self::Mem)
const ALIGNED_TO_SIZE: [(); 1] = _
const ALIAS_WIDTH: [(); 1] = _
sourceimpl BitStore for Cell<u32>
impl BitStore for Cell<u32>
type Mem = u32
type Access = Cell<u32>
type Alias = Cell<u32>
type Unalias = Cell<u32>
const ZERO: Self = _
fn new(value: Self::Mem) -> Self
fn load_value(&self) -> Self::Mem
fn store_value(&mut self, value: Self::Mem)
const ALIGNED_TO_SIZE: [(); 1] = _
const ALIAS_WIDTH: [(); 1] = _
sourceimpl BitStore for u64
impl BitStore for u64
type Access = Cell<u64>
type Access = Cell<u64>
The unsigned integers will only be BitStore
type parameters
for handles to unaliased memory, following the normal Rust
reference rules.
type Mem = u64
type Alias = BitSafeU64
type Unalias = u64
const ZERO: Self = 0u64
fn new(value: Self::Mem) -> Self
fn load_value(&self) -> Self::Mem
fn store_value(&mut self, value: Self::Mem)
const ALIGNED_TO_SIZE: [(); 1] = _
const ALIAS_WIDTH: [(); 1] = _
sourceimpl BitStore for Cell<u64>
impl BitStore for Cell<u64>
type Mem = u64
type Access = Cell<u64>
type Alias = Cell<u64>
type Unalias = Cell<u64>
const ZERO: Self = _
fn new(value: Self::Mem) -> Self
fn load_value(&self) -> Self::Mem
fn store_value(&mut self, value: Self::Mem)
const ALIGNED_TO_SIZE: [(); 1] = _
const ALIAS_WIDTH: [(); 1] = _
sourceimpl BitStore for usize
impl BitStore for usize
type Access = Cell<usize>
type Access = Cell<usize>
The unsigned integers will only be BitStore
type parameters
for handles to unaliased memory, following the normal Rust
reference rules.