Struct stackdump_core::memory_region::VecMemoryRegion

pub struct VecMemoryRegion { /* private fields */ }

A memory region that is backed by a stack allocated array

Implementations

impl VecMemoryRegion

pub fn new(start_address: u64, data: Vec<u8>) -> Self

Creates a new memory region starting at the given address with the given data

pub fn bytes(&self) -> MemoryRegionIterator<'_>

Get a byte iterator for this region.

This iterator can be used to store the region as bytes or to stream over a network. The iterated bytes include the length so that if you use the FromIterator implementation, it consumes only the bytes that are part of the collection. This means you can chain multiple of these iterators after each other.

use arrayvec::ArrayVec;
use stackdump_core::memory_region::{ArrayMemoryRegion, MemoryRegion};

let region1 = ArrayMemoryRegion::<4>::new(0, ArrayVec::from([1, 2, 3, 4]));
let region2 = ArrayMemoryRegion::<4>::new(100, ArrayVec::from([5, 6, 7, 8]));

let mut intermediate_buffer = Vec::new();

intermediate_buffer.extend(region1.bytes());
intermediate_buffer.extend(region2.bytes());

let mut intermediate_iter = intermediate_buffer.iter();

assert_eq!(region1, ArrayMemoryRegion::<4>::from_iter(&mut intermediate_iter));
assert_eq!(region2, ArrayMemoryRegion::<4>::from_iter(&mut intermediate_iter));

pub unsafe fn copy_from_memory(&mut self, data_ptr: *const u8, data_len: usize)

Clears the existing memory data and copies the new data from the given pointer

If the data_len is greater than the capacity of this memory region, then this function will panic.

Safety

The entire block of memory from data_ptr .. data_ptr + data_len must be readable. (A memcpy must be possible with the pointer as source)

Trait Implementations

impl Clone for VecMemoryRegion

fn clone(&self) -> VecMemoryRegion

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for VecMemoryRegion

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for VecMemoryRegion

fn default() -> VecMemoryRegion

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for VecMemoryRegion

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a> FromIterator<&'a u8> for VecMemoryRegion

fn from_iter<T: IntoIterator<Item = &'a u8>>(iter: T) -> Self

Creates a value from an iterator.

impl FromIterator<u8> for VecMemoryRegion

fn from_iter<T: IntoIterator<Item = u8>>(iter: T) -> Self

Creates a value from an iterator.

impl MemoryRegion for VecMemoryRegion

fn read(&self, index: Range<u64>) -> Result<Option<Vec<u8>>, MemoryReadError>

Returns the slice of memory that can be found at the given address_range. If the given address range is not fully within the captured region, then None is returned.

fn read_u8(&self, address: u64) -> Result<Option<u8>, MemoryReadError>

Reads a byte from the given address if it is present in the region

fn read_u32( &self, address: u64, endianness: RunTimeEndian ) -> Result<Option<u32>, MemoryReadError>

Reads a u32 from the given address if it is present in the region

impl PartialEq<VecMemoryRegion> for VecMemoryRegion

fn eq(&self, other: &VecMemoryRegion) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for VecMemoryRegion

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for VecMemoryRegion

impl StructuralEq for VecMemoryRegion

impl StructuralPartialEq for VecMemoryRegion