Struct SliceMemoryRegion

pub struct SliceMemoryRegion<'a> { /* private fields */ }

A memory region that is backed by a slice

Implementations

impl<'a> SliceMemoryRegion<'a>

pub fn new(data: &'a [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)

This function is especially unsafe. The memory region will reference the given data for its entire lifetime.

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)

You must not have another reference to this block of memory or any object that resides in this memory during the entire lifetime of the object

Trait Implementations

impl<'a> Clone for SliceMemoryRegion<'a>

fn clone(&self) -> SliceMemoryRegion<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for SliceMemoryRegion<'a>

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

Formats the value using the given formatter.

impl<'a> Default for SliceMemoryRegion<'a>

fn default() -> SliceMemoryRegion<'a>

Returns the “default value” for a type.

impl<'de: 'a, 'a> Deserialize<'de> for SliceMemoryRegion<'a>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a> MemoryRegion for SliceMemoryRegion<'a>

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<'a> PartialEq for SliceMemoryRegion<'a>

fn eq(&self, other: &SliceMemoryRegion<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<'a> Serialize for SliceMemoryRegion<'a>

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a> Eq for SliceMemoryRegion<'a>

impl<'a> StructuralPartialEq for SliceMemoryRegion<'a>