Struct strontium::memory::Memory

pub struct Memory {
    pub data: Vec<bool>,
}

A generic, very low-level structure for data and code storage. It has no concept of numbers or strings. Instead, it manipulates an array of bits. The basic operations can be used to store numbers or strings, compose methods like addition, multiplication, etc. This makes the module really versatile.

Fields

data: Vec<bool>

Implementations

impl Memory

pub fn new() -> Self

Create a new memory instance

pub fn load(&mut self, vec: &mut Vec<bool>)

Load a memory snapshot and drop the content from before

pub fn append(&mut self, vec: &mut Vec<bool>)

Add a vector of bits to the container

pub fn dump(&mut self) -> Vec<bool>

Return the contents of the container

pub fn set(&mut self, a: usize)

Set the given bit to 1

pub fn unset(&mut self, a: usize)

Set the given bit to 0

pub fn grow(&mut self, amount: usize)

Grow the container by (n) bits

pub fn shrink(&mut self, amount: usize) -> Result<(), &'static str>

Shrink the container by (n) bits

pub fn single_and(
    &mut self,
    a: Address,
    b: Address,
    out: Address
) -> Result<(), &'static str>

Perform a bitwise AND operation on a single bit

pub fn single_or(
    &mut self,
    a: Address,
    b: Address,
    out: Address
) -> Result<(), &'static str>

Perform a bitwise OR operation on a single bit

pub fn single_xor(
    &mut self,
    a: Address,
    b: Address,
    out: Address
) -> Result<(), &'static str>

Perform a bitwise exclusive OR operation on a single bit

pub fn single_not(&mut self, a: Address, out: Address) -> Result<(), &'static str>

Perform a bitwise negation on a single bit

pub fn range_and(
    &mut self,
    a: Range,
    b: Range,
    out: Range
) -> Result<(), &'static str>

Perform a bitwise AND operation on a range of bits

pub fn range_or(
    &mut self,
    a: Range,
    b: Range,
    out: Range
) -> Result<(), &'static str>

Perform a bitwise OR operation on a range of bits

pub fn range_xor(
    &mut self,
    a: Range,
    b: Range,
    out: Range
) -> Result<(), &'static str>

Perform a bitwise exclusive OR operation on a range of bits

pub fn range_not(&mut self, a: Range, out: Range) -> Result<(), &'static str>

pub fn lshift(
    &mut self,
    by: usize,
    a: Range,
    out: Range
) -> Result<(), &'static str>

pub fn rshift(&mut self, by: usize, a: Range, out: Range)

Perform an arithmetic (sign-preserving) right-shift on a range of bits and write the result to another range

pub fn is_set(&self, address: Address) -> bool

pub fn is_unset(&self, address: Address) -> bool