Struct primordial::Address

#[repr(transparent)]
pub struct Address<T, U>(_, _);

An address

This newtype is used to represent addresses of a given type. The most important invariant of this type is that the address is always properly aligned for the given type U. The only way to convert between addresses of different types is to choose a new alignment (raise or lower).

This type does not, however, track lifetime. You’re on your own.

Unlike the naked underlying types, you can infallibly convert between, for example, an Address<usize, ()> and an Address<u64, ()> wherever such a conversion is lossless given the target CPU architecture.

Implementations

impl<T: Zero, U> Address<T, U>

pub const NULL: Address<T, U>

The NULL address

impl<U> Address<usize, U>

pub const fn new(value: usize) -> Self

Creates a new address

Panics if the value is not properly aligned.

impl<T, U> Address<T, U>

pub const unsafe fn unchecked(value: T) -> Self

Creates a new Address from a raw inner type without checking

Safety

This function is unsafe because it does not enforce the main constraint of this type that the address stored is properly aligned to the type.

For a safe version of this constructor, first create an Address<T, ()> from the raw value and then align to the type you want.

pub fn raw(self) -> T

Converts an Address to its raw inner type

impl<T, U> Address<T, U> where
    Self: Into<Address<usize, U>>, 

pub fn as_ptr(self) -> *const U

Returns a raw pointer to its inner type

Safety

Behavior is undefined, if the pointer is used and is not aligned or points to uninitialized memory.

pub fn as_mut_ptr(self) -> *mut U

Returns a raw pointer to its inner type

Safety

Behavior is undefined, if the pointer is used and is not aligned or points to uninitialized memory.

impl<T, U> Address<T, U> where
    Self: Into<Address<usize, U>>,
    Self: From<Address<usize, U>>, 

pub fn try_cast<V>(self) -> Result<Address<T, V>, AlignmentError>

Try casting an existing Address into an Address of a different type

Succeeds only, if they have compatible alignment

impl<T, U> Address<T, U> where
    Offset<usize, ()>: Into<Offset<T, ()>>,
    T: Add<T, Output = T>,
    T: Sub<T, Output = T>,
    T: Mul<T, Output = T>,
    T: Div<T, Output = T>,
    T: One, 

pub fn raise<V>(self) -> Address<T, V>

Cast an existing Address into an Address of a different type by aligning up

pub fn lower<V>(self) -> Address<T, V>

Cast an existing Address into an Address of a different type by aligning down

Trait Implementations

impl<T, U> Add<Offset<T, U>> for Address<T, U> where
    Offset<usize, ()>: Into<Offset<T, ()>>,
    T: Mul<T, Output = T>,
    T: Add<T, Output = T>, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: Offset<T, U>) -> Self::Output

Performs the + operation.

impl<T, U> AddAssign<Offset<T, U>> for Address<T, U> where
    Offset<usize, ()>: Into<Offset<T, ()>>,
    T: Mul<T, Output = T>,
    T: AddAssign<T>, 

fn add_assign(&mut self, rhs: Offset<T, U>)

Performs the += operation.

impl<T: Binary, U> Binary for Address<T, U>

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

Formats the value using the given formatter.

impl<T: Clone, U: Clone> Clone for Address<T, U>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: LowerHex, U> Debug for Address<T, U>

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

Formats the value using the given formatter.

impl<T: Default, U: Default> Default for Address<T, U>

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

Returns the “default value” for a type.

impl<T: Display, U> Display for Address<T, U>

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

Formats the value using the given formatter.

impl<T, U> From<&'_ U> for Address<T, U> where
    Address<usize, U>: Into<Address<T, U>>, 

Convert a reference to an Address with the same type

fn from(value: &U) -> Self

Converts to this type from the input type.

impl<T, U> From<*const U> for Address<T, U> where
    Address<usize, U>: Into<Address<T, U>>, 

Convert a const pointer to an Address with the same type

fn from(value: *const U) -> Self

Converts to this type from the input type.

impl<T, U> From<*mut U> for Address<T, U> where
    Address<usize, U>: Into<Address<T, U>>, 

Convert a mutable pointer to an Address with the same type

fn from(value: *mut U) -> Self

Converts to this type from the input type.

impl<T, U> From<Address<T, U>> for Register<T> where
    Register<T>: From<T>, 

fn from(value: Address<T, U>) -> Self

Converts to this type from the input type.

impl<U> From<Address<u32, U>> for Address<usize, U>

fn from(value: Address<u32, U>) -> Self

Converts to this type from the input type.

impl<U> From<Address<u64, U>> for Address<usize, U>

fn from(value: Address<u64, U>) -> Self

Converts to this type from the input type.

impl<U> From<Address<usize, U>> for Address<u64, U>

fn from(value: Address<usize, U>) -> Self

Converts to this type from the input type.

impl<T: From<Register<T>>> From<Register<T>> for Address<T, ()>

fn from(value: Register<T>) -> Self

Converts to this type from the input type.

impl<T> From<T> for Address<T, ()>

Convert a raw address value to an untyped Address

fn from(value: T) -> Self

Converts to this type from the input type.

impl<T: LowerHex, U> LowerHex for Address<T, U>

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

Formats the value using the given formatter.

impl<T: Ord, U> Ord for Address<T, U>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

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

Restrict a value to a certain interval.

impl<T: PartialEq, U> PartialEq<Address<T, U>> for Address<T, U>

fn eq(&self, other: &Self) -> 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 !=.

impl<T: PartialOrd, U> PartialOrd<Address<T, U>> for Address<T, U>

fn partial_cmp(&self, other: &Self) -> 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, U> Pointer for Address<T, U> where
    Self: Into<Address<usize, U>>,
    Self: Copy, 

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

Formats the value using the given formatter.

impl<T, U> Sub<Address<T, U>> for Address<T, U> where
    Offset<usize, ()>: Into<Offset<T, ()>>,
    T: Mul<T, Output = T>,
    T: Sub<T, Output = T>,
    T: Div<T, Output = T>,
    T: One, 

type Output = Offset<T, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Address<T, U>) -> Self::Output

Performs the - operation.

impl<T, U> Sub<Offset<T, U>> for Address<T, U> where
    Offset<usize, ()>: Into<Offset<T, ()>>,
    T: Mul<T, Output = T>,
    T: Sub<T, Output = T>, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: Offset<T, U>) -> Self::Output

Performs the - operation.

impl<T, U> SubAssign<Offset<T, U>> for Address<T, U> where
    Offset<usize, ()>: Into<Offset<T, ()>>,
    T: Mul<T, Output = T>,
    T: SubAssign<T>, 

fn sub_assign(&mut self, rhs: Offset<T, U>)

Performs the -= operation.

impl<T: UpperHex, U> UpperHex for Address<T, U>

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

Formats the value using the given formatter.

impl<T: Copy, U: Copy> Copy for Address<T, U>

impl<T: Eq, U> Eq for Address<T, U>