Struct memory_manager::common::Address

pub struct Address<'a> { /* fields omitted */ }

Memory address with a valid lifetime.

We need this because raw pointers does not have a lifetime attached. Note that an Address can be constructed from a raw pointer, and the lifetime attached is ARBITRARY, so it is on the caller to guarantee the correct lifetime is specified.

Construct from raw pointer

use memory_manager::common::Address;
let raw_p = 0xDEAD_BEEF as *mut ();
let addr = Address::from(raw_p);

Debug format

assert_eq!(format!("{:?}", addr), "Address(0xdeadbeef)");

Implementations

impl<'a> Address<'a>

pub fn as_ptr<T>(&self) -> *mut T

Convert an Address to a raw pointer of some type T.

Note that raw pointers do not have lifetime attached, so the lifetime is dropped after converting to a raw pointer. This should not give rise to any unsafety, as long as the Address was constructed correctly.

Panics

This function assert! that the memory address is properly aligned for T. See also assert_aligned.

The following use would panic:

use memory_manager::common::Address;
let addr = Address::from(0xDEAD_BEEF as *mut ());
let raw_p = addr.as_ptr::<usize>();

pub unsafe fn offset(&self, count: isize) -> Self

Add an offset to an Address.

This method is analogous to *mut T::offset.

use memory_manager::common::Address;
let addr = Address::from(0x1000 as *mut ());
assert_eq!(unsafe { addr.offset(4isize) }, Address::from(0x1004 as *mut ()));

Trait Implementations

impl<'a> Clone for Address<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for Address<'a>

impl<'a> Debug for Address<'a>

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

Formats the value using the given formatter.

impl<'a> Eq for Address<'a>

impl<'a, T> From<*mut T> for Address<'a>

fn from(address: *mut T) -> Self

Performs the conversion.

impl<'a> From<Address<'a>> for Object<'a>

fn from(address: Address<'a>) -> Self

Performs the conversion.

impl<'a> Ord for Address<'a>

fn cmp(&self, other: &Address<'a>) -> Ordering

This method returns an [Ordering] between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl<'a> PartialEq<Address<'a>> for Address<'a>

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

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

fn ne(&self, other: &Address<'a>) -> bool

This method tests for !=.

impl<'a> PartialOrd<Address<'a>> for Address<'a>

fn partial_cmp(&self, other: &Address<'a>) -> Option<Ordering>

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

fn lt(&self, other: &Address<'a>) -> bool

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

fn le(&self, other: &Address<'a>) -> bool

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

fn gt(&self, other: &Address<'a>) -> bool

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

fn ge(&self, other: &Address<'a>) -> bool

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

impl<'a> StructuralEq for Address<'a>

impl<'a> StructuralPartialEq for Address<'a>