Struct RawRelPtr

pub struct RawRelPtr<O> { /* private fields */ }

Available on crate feature dep_rkyv only.

An untyped pointer which resolves relative to its position in memory.

This is the most fundamental building block in rkyv. It allows the construction and use of pointers that can be safely relocated as long as the source and target are moved together. This is what allows memory to be moved from disk into memory and accessed without decoding.

Regular pointers are absolute, meaning that the pointer can be moved without being invalidated. However, the pointee cannot be moved, otherwise the pointer is invalidated.

Relative pointers are relative, meaning that the pointer can be moved with the pointee without invalidating the pointer. However, if either the pointer or the pointee move independently, the pointer will be invalidated.

Implementations

impl<O> RawRelPtr<O>

where O: Offset,

pub fn try_emplace_invalid<E>(out: Place<RawRelPtr<O>>) -> Result<(), E>

where E: Source,

Attempts to create an invalid RawRelPtr in-place.

pub fn emplace_invalid(out: Place<RawRelPtr<O>>)

Creates an invalid RawRelPtr in-place.

Panics

• If an offset of 1 does not fit in an isize
• If an offset of 1 exceeds the offset storage

pub fn try_emplace<E>(to: usize, out: Place<RawRelPtr<O>>) -> Result<(), E>

where E: Source,

Attempts to create a new RawRelPtr in-place between the given from and to positions.

pub fn emplace(to: usize, out: Place<RawRelPtr<O>>)

Creates a new RawRelPtr in-place between the given from and to positions.

Panics

• If the offset between out and to does not fit in an isize
• If the offset between out and to exceeds the offset storage

pub fn base_raw(this: *mut RawRelPtr<O>) -> *mut u8

Gets the base pointer for the pointed-to relative pointer.

pub unsafe fn offset_raw(this: *mut RawRelPtr<O>) -> isize

Gets the offset of the pointed-to relative pointer from its base.

Safety

this must be non-null, properly-aligned, and point to a valid RawRelPtr.

pub unsafe fn as_ptr_raw(this: *mut RawRelPtr<O>) -> *mut ()

Calculates the memory address being pointed to by the pointed-to relative pointer.

Safety

• this must be non-null, properly-aligned, and point to a valid RawRelPtr.
• The offset of this relative pointer, when added to its base, must be located in the same allocated object as it.

pub unsafe fn as_ptr_wrapping_raw(this: *mut RawRelPtr<O>) -> *mut ()

Calculates the memory address being pointed to by the pointed-to relative pointer using wrapping methods.

This method is a safer but potentially slower version of as_ptr_raw.

Safety

this must be non-null, properly-aligned, and point to a valid RawRelPtr.

pub unsafe fn is_invalid_raw(this: *mut RawRelPtr<O>) -> bool

Gets whether the offset of the pointed-to relative pointer is invalid.

Safety

this must be non-null, properly-aligned, and point to a valid RawRelPtr.

pub fn base(&self) -> *const u8

Gets the base pointer for the relative pointer.

pub fn base_mut(this: Seal<'_, RawRelPtr<O>>) -> *mut u8

Gets the mutable base pointer for the relative pointer.

pub fn offset(&self) -> isize

Gets the offset of the relative pointer from its base.

pub fn is_invalid(&self) -> bool

Gets whether the offset of the relative pointer is invalid.

pub unsafe fn as_ptr(&self) -> *const ()

Calculates the memory address being pointed to by this relative pointer.

Safety

The offset of this relative pointer, when added to its base, must be located in the same allocated object as it.

pub unsafe fn as_mut_ptr(this: Seal<'_, RawRelPtr<O>>) -> *mut ()

Calculates the mutable memory address being pointed to by this relative pointer.

Safety

The offset of this relative pointer, when added to its base, must be located in the same allocated object as it.

pub fn as_ptr_wrapping(&self) -> *const ()

Calculates the memory address being pointed to by this relative pointer using wrapping methods.

This method is a safer but potentially slower version of as_ptr.

pub fn as_mut_ptr_wrapping(this: Seal<'_, RawRelPtr<O>>) -> *mut ()

Calculates the mutable memory address being pointed to by this relative pointer using wrapping methods.

This method is a safer but potentially slower version of as_mut_ptr.

Trait Implementations

impl<O, __C> CheckBytes<__C> for RawRelPtr<O>

where __C: Fallible + ?Sized, <__C as Fallible>::Error: Trace, O: CheckBytes<__C>, PhantomPinned: CheckBytes<__C>,

unsafe fn check_bytes( value: *const RawRelPtr<O>, context: &mut __C, ) -> Result<(), <__C as Fallible>::Error>

Checks whether the given pointer points to a valid value within the given context.

impl<O> Debug for RawRelPtr<O>

where O: Debug,

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

Formats the value using the given formatter.

impl<O> Pointer for RawRelPtr<O>

where O: Offset,

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

Formats the value using the given formatter.

impl<O> Portable for RawRelPtr<O>

where O: Portable, PhantomPinned: Portable,