Struct memflow::types::pointer::Pointer

#[repr(transparent)]
pub struct Pointer<U: Sized, T: ?Sized = ()> {
    pub inner: U,
    /* private fields */
}

This type can be used in structs that are being read from the target memory. It holds a phantom type that can be used to describe the proper type of the pointer and to read it in a more convenient way.

This module is a direct adaption of CasualX’s great IntPtr crate.

Generally the generic Type should implement the Pod trait to be read into easily. See here for more information on the Pod trait.

Examples

use memflow::types::Pointer64;
use memflow::mem::MemoryView;
use memflow::dataview::Pod;

#[repr(C)]
#[derive(Clone, Debug, Pod)]
struct Foo {
    pub some_value: i64,
}

#[repr(C)]
#[derive(Clone, Debug, Pod)]
struct Bar {
    pub foo_ptr: Pointer64<Foo>,
}

fn read_foo_bar(mem: &mut impl MemoryView) {
    let bar: Bar = mem.read(0x1234.into()).unwrap();
    let foo = bar.foo_ptr.read(mem).unwrap();
    println!("value: {}", foo.some_value);
}

use memflow::types::Pointer64;
use memflow::mem::MemoryView;
use memflow::dataview::Pod;

#[repr(C)]
#[derive(Clone, Debug, Pod)]
struct Foo {
    pub some_value: i64,
}

#[repr(C)]
#[derive(Clone, Debug, Pod)]
struct Bar {
    pub foo_ptr: Pointer64<Foo>,
}

fn read_foo_bar(mem: &mut impl MemoryView) {
    let bar: Bar = mem.read(0x1234.into()).unwrap();
    let foo = mem.read_ptr(bar.foo_ptr).unwrap();
    println!("value: {}", foo.some_value);
}

Fields

inner: U

Implementations

impl<U: PrimitiveAddress, T: ?Sized> Pointer<U, T>

pub fn null() -> Self

Returns a pointer64 with a value of zero.

Examples

use memflow::types::Pointer64;

println!("pointer: {}", Pointer64::<()>::null());

pub fn is_null(self) -> bool

Returns true if the pointer64 is null.

Examples

use memflow::types::Pointer32;

let ptr = Pointer32::<()>::from(0x1000u32);
assert!(!ptr.is_null());

pub fn non_null(self) -> Option<Pointer<U, T>>

Converts the pointer64 to an Option that is None when it is null

Examples

use memflow::types::Pointer64;

assert_eq!(Pointer64::<()>::null().non_null(), None);
assert_eq!(Pointer64::<()>::from(0x1000u64).non_null(), Some(Pointer64::from(0x1000u64)));

pub fn to_umem(self) -> umem

Converts the pointer into a raw umem value.

Examples

use memflow::types::{Pointer64, umem};

let ptr = Pointer64::<()>::from(0x1000u64);
let ptr_umem: umem = ptr.to_umem();
assert_eq!(ptr_umem, 0x1000);

pub fn address(&self) -> Address

impl<U: PrimitiveAddress, T: Sized> Pointer<U, T>

pub fn offset(self, count: imem) -> Self

Calculates the offset from a pointer64

count is in units of T; e.g., a count of 3 represents a pointer offset of 3 * size_of::<T>() bytes.

Panics

This function panics if T is a Zero-Sized Type (“ZST”). This function also panics when offset * size_of::<T>() causes overflow of a signed 64-bit integer.

Examples:

use memflow::types::Pointer64;

let ptr = Pointer64::<u16>::from(0x1000u64);

println!("{:?}", ptr.offset(3));

pub fn offset_from(self, origin: Self) -> imem

Calculates the distance between two pointers. The returned value is in units of T: the distance in bytes is divided by mem::size_of::<T>().

This function is the inverse of offset.

Panics

This function panics if T is a Zero-Sized Type (“ZST”).

Examples:

use memflow::types::Pointer64;

let ptr1 = Pointer64::<u16>::from(0x1000u64);
let ptr2 = Pointer64::<u16>::from(0x1008u64);

assert_eq!(ptr2.offset_from(ptr1), 4);
assert_eq!(ptr1.offset_from(ptr2), -4);

pub fn add(self, count: umem) -> Self

Calculates the offset from a pointer (convenience for .offset(count as i64)).

count is in units of T; e.g., a count of 3 represents a pointer offset of 3 * size_of::<T>() bytes.

Panics

This function panics if T is a Zero-Sized Type (“ZST”).

Examples

Basic usage:

use memflow::types::Pointer64;

let ptr = Pointer64::<u16>::from(0x1000u64);

println!("{:?}", ptr.add(3));

pub fn sub(self, count: umem) -> Self

Calculates the offset from a pointer (convenience for .offset((count as isize).wrapping_neg())).

count is in units of T; e.g., a count of 3 represents a pointer offset of 3 * size_of::<T>() bytes.

Panics

This function panics if T is a Zero-Sized Type (“ZST”).

Examples

Basic usage:

use memflow::types::Pointer64;

let ptr = Pointer64::<u16>::from(0x1000u64);

println!("{:?}", ptr.sub(3));

impl<U: PrimitiveAddress, T: Pod + ?Sized> Pointer<U, T>

Implement special phys/virt read/write for Pod types

pub fn read_into<M: MemoryView>( self, mem: &mut M, out: &mut T ) -> PartialResult<()>

impl<U: PrimitiveAddress, T: Pod + Sized> Pointer<U, T>

pub fn read<M: MemoryView>(self, mem: &mut M) -> PartialResult<T>

pub fn write<M: MemoryView>(self, mem: &mut M, data: &T) -> PartialResult<()>

impl<U: PrimitiveAddress> Pointer<U, ReprCString>

Implement special phys/virt read/write for CReprStr

pub fn read_string<M: MemoryView>( self, mem: &mut M ) -> PartialResult<ReprCString>

impl<U: PrimitiveAddress, T> Pointer<U, [T]>

pub fn decay(self) -> Pointer<U, T>

pub fn at(self, i: umem) -> Pointer<U, T>

Trait Implementations

impl<U: PrimitiveAddress, T> Add<u64> for Pointer<U, T>

type Output = Pointer<U, T>

The resulting type after applying the + operator.

fn add(self, other: umem) -> Pointer<U, T>

Performs the + operation.

impl<U: PrimitiveAddress, T> Add<usize> for Pointer<U, T>

type Output = Pointer<U, T>

The resulting type after applying the + operator.

fn add(self, other: usize) -> Pointer<U, T>

Performs the + operation.

impl<U: PrimitiveAddress, T: ?Sized> AsMut<U> for Pointer<U, T>

fn as_mut(&mut self) -> &mut U

Converts this type into a mutable reference of the (usually inferred) input type.

impl<U: PrimitiveAddress, T: ?Sized> AsRef<U> for Pointer<U, T>

fn as_ref(&self) -> &U

Converts this type into a shared reference of the (usually inferred) input type.

impl<U: PrimitiveAddress, T: ?Sized + 'static> ByteSwap for Pointer<U, T>

fn byte_swap(&mut self)

impl<U: PrimitiveAddress, T: ?Sized> Clone for Pointer<U, T>

fn clone(&self) -> Pointer<U, T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<U: PrimitiveAddress, T: ?Sized> Debug for Pointer<U, T>

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

Formats the value using the given formatter.

impl<U: PrimitiveAddress, T: ?Sized> Default for Pointer<U, T>

fn default() -> Pointer<U, T>

Returns the “default value” for a type.

impl<U: PrimitiveAddress, T: ?Sized> Display for Pointer<U, T>

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

Formats the value using the given formatter.

impl<U: PrimitiveAddress, T: ?Sized> From<Pointer<U, T>> for Address

Converts any Pointer into an Address.

fn from(ptr: Pointer<U, T>) -> Self

Converts to this type from the input type.

impl<U: PrimitiveAddress, T: ?Sized> From<Pointer<U, T>> for PhysicalAddress

fn from(ptr: Pointer<U, T>) -> Self

Converts to this type from the input type.

impl<U: Into<Address>, T: ?Sized> From<Pointer<U, T>> for umem

fn from(ptr: Pointer<U, T>) -> umem

Converts to this type from the input type.

impl<T: ?Sized> From<Pointer<i16, T>> for Address

fn from(ptr: Pointer<i16, T>) -> Self

Converts to this type from the input type.

impl<T: ?Sized> From<Pointer<i16, T>> for PhysicalAddress

fn from(ptr: Pointer<i16, T>) -> Self

Converts to this type from the input type.

impl<T: ?Sized> From<Pointer<i32, T>> for Address

fn from(ptr: Pointer<i32, T>) -> Self

Converts to this type from the input type.

impl<T: ?Sized> From<Pointer<i32, T>> for PhysicalAddress

fn from(ptr: Pointer<i32, T>) -> Self

Converts to this type from the input type.

impl<T: ?Sized> From<Pointer<i64, T>> for Address

fn from(ptr: Pointer<i64, T>) -> Self

Converts to this type from the input type.

impl<T: ?Sized> From<Pointer<i64, T>> for PhysicalAddress

fn from(ptr: Pointer<i64, T>) -> Self

Converts to this type from the input type.

impl<T: ?Sized> From<Pointer<i8, T>> for Address

fn from(ptr: Pointer<i8, T>) -> Self

Converts to this type from the input type.

impl<T: ?Sized> From<Pointer<i8, T>> for PhysicalAddress

fn from(ptr: Pointer<i8, T>) -> Self

Converts to this type from the input type.

impl<T: ?Sized> From<Pointer<u8, T>> for Address

fn from(ptr: Pointer<u8, T>) -> Self

Converts to this type from the input type.

impl<T: ?Sized> From<Pointer<u8, T>> for PhysicalAddress

fn from(ptr: Pointer<u8, T>) -> Self

Converts to this type from the input type.

impl<T: ?Sized> From<Pointer<usize, T>> for Address

fn from(ptr: Pointer<usize, T>) -> Self

Converts to this type from the input type.

impl<T: ?Sized> From<Pointer<usize, T>> for PhysicalAddress

fn from(ptr: Pointer<usize, T>) -> Self

Converts to this type from the input type.

impl<U: PrimitiveAddress, T: ?Sized> From<U> for Pointer<U, T>

fn from(address: U) -> Pointer<U, T>

Converts to this type from the input type.

impl<U: PrimitiveAddress, T: ?Sized> Hash for Pointer<U, T>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<U: PrimitiveAddress, T: ?Sized> LowerHex for Pointer<U, T>

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

Formats the value using the given formatter.

impl<U: PrimitiveAddress, T: ?Sized> Ord for Pointer<U, T>

fn cmp(&self, rhs: &Pointer<U, T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl<U: PrimitiveAddress, T: ?Sized> PartialEq for Pointer<U, T>

fn eq(&self, rhs: &Pointer<U, T>) -> 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<U: PrimitiveAddress, T: ?Sized> PartialOrd for Pointer<U, T>

fn partial_cmp(&self, rhs: &Pointer<U, T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<U, T: ?Sized> Serialize for Pointer<U, T>

where U: Serialize + Sized,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<U: PrimitiveAddress, T> Sub<u64> for Pointer<U, T>

type Output = Pointer<U, T>

The resulting type after applying the - operator.

fn sub(self, other: umem) -> Pointer<U, T>

Performs the - operation.

impl<U: PrimitiveAddress, T> Sub<usize> for Pointer<U, T>

type Output = Pointer<U, T>

The resulting type after applying the - operator.

fn sub(self, other: usize) -> Pointer<U, T>

Performs the - operation.

impl<U: PrimitiveAddress, T: ?Sized> UpperHex for Pointer<U, T>

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

Formats the value using the given formatter.

impl<U: PrimitiveAddress, T: ?Sized> Copy for Pointer<U, T>

impl<U: PrimitiveAddress, T: ?Sized> Eq for Pointer<U, T>

impl<U: Pod, T: ?Sized + 'static> Pod for Pointer<U, T>