Trait bitvec::store::BitStore

source · [−]
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:

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

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.

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

Required Associated Constants

The zero constant.

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

Use mem::aligned_to_size::<Self>() to prove this.

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

Wraps a raw memory value as a BitStore type.

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.

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 within Self::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.

The unsigned integers will only be BitStore type parameters for handles to unaliased memory, following the normal Rust reference rules.

The unsigned integers will only be BitStore type parameters for handles to unaliased memory, following the normal Rust reference rules.

The unsigned integers will only be BitStore type parameters for handles to unaliased memory, following the normal Rust reference rules.

The unsigned integers will only be BitStore type parameters for handles to unaliased memory, following the normal Rust reference rules.

Implementors