Struct pelite::pe64::Ptr

pub struct Ptr<T: ?Sized = ()>(_, _);

Typed virtual address.

Implementations

impl<T: ?Sized> Ptr<T>

pub fn null() -> Ptr<T>

Creates a null pointer.

pub fn is_null(self) -> bool

Returns true if the pointer is null.

pub fn cast<U: ?Sized>(self) -> Ptr<U>

Casts the pointer to a different type keeping the pointer address fixed.

pub fn shift<U: ?Sized>(self, offset: Va) -> Ptr<U>

Offset and cast the pointer.

Access nearby values (such as data members) by offsetting and casting the pointer.

Because the type of the current and the target may be unrelated, this is a byte offset.

Examples

use pelite::pe64::Ptr;

#[repr(C)]
struct Composite {
	int: i32,
	float: f32,
}

let p: Ptr<Composite> = Ptr::from(0x2000);
let target: Ptr<f32> = p.shift(4);

assert_eq!(target, Ptr::from(0x2004));

pub fn fmt(self) -> [u8; 18]

Simply formats the pointer.

Examples

use std::str;
use pelite::pe32::Ptr;

let p: Ptr<i32> = Ptr::from(0x1f00);
let fmts = p.fmt();

// Guaranteed to be safe
let s = unsafe { str::from_utf8_unchecked(&fmts) };
assert_eq!(s, "0x00001f00");

Trait Implementations

impl<T: Pod> Add<i64> for Ptr<[T]>

type Output = Ptr<T>

The resulting type after applying the + operator.

fn add(self, rhs: SignedVa) -> Ptr<T>

Performs the + operation.

impl<T: Pod> Add<i64> for Ptr<T>

type Output = Ptr<T>

The resulting type after applying the + operator.

fn add(self, rhs: SignedVa) -> Ptr<T>

Performs the + operation.

impl<T: ?Sized> AsMut<u64> for Ptr<T>

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

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

impl<T: ?Sized> AsRef<u64> for Ptr<T>

fn as_ref(&self) -> &Va

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

impl<T: ?Sized> Clone for Ptr<T>

fn clone(&self) -> Ptr<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: ?Sized> Debug for Ptr<T>

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

Formats the value using the given formatter.

impl<T: ?Sized> Default for Ptr<T>

fn default() -> Ptr<T>

Returns the “default value” for a type.

impl<T: ?Sized> Display for Ptr<T>

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

Formats the value using the given formatter.

impl<T: ?Sized> From<Ptr<T>> for Va

fn from(ptr: Ptr<T>) -> Va

Converts to this type from the input type.

impl<T: ?Sized> From<u64> for Ptr<T>

fn from(va: Va) -> Ptr<T>

Converts to this type from the input type.

impl<T: ?Sized> Ord for Ptr<T>

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

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl<T: ?Sized> PartialEq<Ptr<T>> for Ptr<T>

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

fn partial_cmp(&self, rhs: &Ptr<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<T: ?Sized + 'static> Pod for Ptr<T>

fn as_bytes(&self) -> &[u8]

fn as_bytes_mut(&mut self) -> &mut [u8]

impl<T: ?Sized> Serialize for Ptr<T>

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl<T: Pod> Sub<i64> for Ptr<[T]>

type Output = Ptr<T>

The resulting type after applying the - operator.

fn sub(self, rhs: SignedVa) -> Ptr<T>

Performs the - operation.

impl<T: Pod> Sub<i64> for Ptr<T>

type Output = Ptr<T>

The resulting type after applying the - operator.

fn sub(self, rhs: SignedVa) -> Ptr<T>

Performs the - operation.

impl<T: ?Sized> Copy for Ptr<T>

impl<T: ?Sized> Eq for Ptr<T>

impl<T: ?Sized> Send for Ptr<T>

impl<T: ?Sized> Sync for Ptr<T>