Struct DelayedPhysicalMemoryBuilder 

pub struct DelayedPhysicalMemoryBuilder<T> { /* private fields */ }

The builder interface for constructing a DelayedPhysicalMemory object.

Implementations

impl<T> DelayedPhysicalMemoryBuilder<T>

where T: PhysicalMemory,

pub fn new(mem: T) -> DelayedPhysicalMemoryBuilder<T>

Creates a new DelayedPhysicalMemory builder. The memory object is mandatory as the DelayedPhysicalMemory struct wraps around it.

Without further adjustments this function creates a middleware with a delay of 10 milliseconds for each read and write.

It is also possible to either let the DelayedPhysicalMemory object own or just borrow the underlying memory object.

Examples

Moves ownership of a mem object and retrieves it back:

use memflow::architecture::x86::x64;
use memflow::mem::{PhysicalMemory, DelayedPhysicalMemory, MemoryView};

fn build<T: PhysicalMemory>(mem: T) {
    let mut middleware = DelayedPhysicalMemory::builder(mem)
        .build()
        .unwrap();

    middleware.phys_write(0.into(), &MAGIC_VALUE);

    let mut mem = middleware.into_inner();

    let value: u64 = mem.phys_view().read(0.into()).unwrap();
    assert_eq!(value, MAGIC_VALUE);
}

Borrowing a mem object:

use memflow::architecture::x86::x64;
use memflow::mem::{PhysicalMemory, DelayedPhysicalMemory, MemoryView};
use memflow::cglue::{Fwd, ForwardMut};

fn build<T: PhysicalMemory>(mem: Fwd<&mut T>)
    -> impl PhysicalMemory + '_ {
    DelayedPhysicalMemory::builder(mem)
        .build()
        .unwrap()
}

let mut middleware = build(mem.forward_mut());

let value: u64 = middleware.phys_view().read(0.into()).unwrap();
assert_eq!(value, MAGIC_VALUE);

middleware.phys_write(0.into(), &0u64).unwrap();

// We drop the cache and are able to use mem again
std::mem::drop(middleware);

let value: u64 = mem.phys_view().read(0.into()).unwrap();
assert_ne!(value, MAGIC_VALUE);

pub fn delay(self, delay: Duration) -> DelayedPhysicalMemoryBuilder<T>

Changes the delay of the middleware.

Examples

use memflow::types::size;
use memflow::mem::{PhysicalMemory, DelayedPhysicalMemory};
use std::time::Duration;

fn build<T: PhysicalMemory>(mem: T) {
    let middleware = DelayedPhysicalMemory::builder(mem)
        .delay(Duration::from_millis(10))
        .build()
        .unwrap();
}

pub fn build(self) -> Result<DelayedPhysicalMemory<T>, Error>

Builds the DelayedPhysicalMemory object or returns an error.