Trait bitvec::store::BitStore [−][src]
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
.
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.
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
The unsigned integers will only be BitStore
type parameters
for handles to unaliased memory, following the normal Rust
reference rules.
type Mem = Self
type Alias = BitSafeU16
type Unalias = Self
The unsigned integers will only be BitStore
type parameters
for handles to unaliased memory, following the normal Rust
reference rules.
type Mem = Self
type Alias = BitSafeU32
type Unalias = Self
The unsigned integers will only be BitStore
type parameters
for handles to unaliased memory, following the normal Rust
reference rules.
type Mem = Self
type Alias = BitSafeU64
type Unalias = Self
The unsigned integers will only be BitStore
type parameters
for handles to unaliased memory, following the normal Rust
reference rules.