Struct swim_mem::lease::Ptr

pub struct Ptr<'a, R: Resident> { /* fields omitted */ }

An exclusive reference to a Resident occupying an owned, Hold-allocated memory block, with resident metadata stored within the allocation.

Methods

impl<'a, R: Resident> Ptr<'a, R>

pub fn try_hold_new_meta<T, M>(
    hold: &dyn Hold<'a>,
    data: T,
    meta: M
) -> Result<Ptr<'a, R>, HoldError> where
    R: ResidentFromValue<Ptr<'a, R>, T, M>, 

pub fn try_hold_clone_meta<T: ?Sized, M>(
    hold: &dyn Hold<'a>,
    data: &T,
    meta: M
) -> Result<Ptr<'a, R>, HoldError> where
    R: ResidentFromClone<Ptr<'a, R>, T, M>, 

pub unsafe fn try_hold_clone_unchecked_meta<T: ?Sized, M>(
    hold: &dyn Hold<'a>,
    data: &T,
    meta: M
) -> Result<Ptr<'a, R>, HoldError> where
    R: ResidentFromCloneUnchecked<Ptr<'a, R>, T, M>, 

pub fn try_hold_copy_meta<T: ?Sized, M>(
    hold: &dyn Hold<'a>,
    data: &T,
    meta: M
) -> Result<Ptr<'a, R>, HoldError> where
    R: ResidentFromCopy<Ptr<'a, R>, T, M>, 

pub unsafe fn try_hold_copy_unchecked_meta<T: ?Sized, M>(
    hold: &dyn Hold<'a>,
    data: &T,
    meta: M
) -> Result<Ptr<'a, R>, HoldError> where
    R: ResidentFromCopyUnchecked<Ptr<'a, R>, T, M>, 

pub fn try_hold_empty_meta<M>(
    hold: &dyn Hold<'a>,
    meta: M
) -> Result<Ptr<'a, R>, HoldError> where
    R: ResidentFromEmpty<Ptr<'a, R>, M>, 

pub fn try_hold_cap_meta<M>(
    hold: &dyn Hold<'a>,
    cap: usize,
    meta: M
) -> Result<Ptr<'a, R>, HoldError> where
    R: ResidentWithCapacity<Ptr<'a, R>, M>, 

pub fn try_hold_new<T>(
    hold: &dyn Hold<'a>,
    data: T
) -> Result<Ptr<'a, R>, HoldError> where
    R: ResidentFromValue<Ptr<'a, R>, T>, 

pub fn try_hold_clone<T: ?Sized>(
    hold: &dyn Hold<'a>,
    data: &T
) -> Result<Ptr<'a, R>, HoldError> where
    R: ResidentFromClone<Ptr<'a, R>, T>, 

pub unsafe fn try_hold_clone_unchecked<T: ?Sized>(
    hold: &dyn Hold<'a>,
    data: &T
) -> Result<Ptr<'a, R>, HoldError> where
    R: ResidentFromCloneUnchecked<Ptr<'a, R>, T>, 

pub fn try_hold_copy<T: ?Sized>(
    hold: &dyn Hold<'a>,
    data: &T
) -> Result<Ptr<'a, R>, HoldError> where
    R: ResidentFromCopy<Ptr<'a, R>, T>, 

pub unsafe fn try_hold_copy_unchecked<T: ?Sized>(
    hold: &dyn Hold<'a>,
    data: &T
) -> Result<Ptr<'a, R>, HoldError> where
    R: ResidentFromCopyUnchecked<Ptr<'a, R>, T>, 

pub fn try_hold_empty(hold: &dyn Hold<'a>) -> Result<Ptr<'a, R>, HoldError> where
    R: ResidentFromEmpty<Ptr<'a, R>>, 

pub fn try_hold_cap(
    hold: &dyn Hold<'a>,
    cap: usize
) -> Result<Ptr<'a, R>, HoldError> where
    R: ResidentWithCapacity<Ptr<'a, R>>, 

pub fn hold_new<T>(hold: &dyn Hold<'a>, data: T) -> Ptr<'a, R> where
    R: ResidentFromValue<Ptr<'a, R>, T>, 

pub fn hold_clone<T: ?Sized>(hold: &dyn Hold<'a>, data: &T) -> Ptr<'a, R> where
    R: ResidentFromClone<Ptr<'a, R>, T>, 

pub unsafe fn hold_clone_unchecked<T: ?Sized>(
    hold: &dyn Hold<'a>,
    data: &T
) -> Ptr<'a, R> where
    R: ResidentFromCloneUnchecked<Ptr<'a, R>, T>, 

pub fn hold_copy<T: ?Sized>(hold: &dyn Hold<'a>, data: &T) -> Ptr<'a, R> where
    R: ResidentFromCopy<Ptr<'a, R>, T>, 

pub unsafe fn hold_copy_unchecked<T: ?Sized>(
    hold: &dyn Hold<'a>,
    data: &T
) -> Ptr<'a, R> where
    R: ResidentFromCopyUnchecked<Ptr<'a, R>, T>, 

pub fn hold_empty(hold: &dyn Hold<'a>) -> Ptr<'a, R> where
    R: ResidentFromEmpty<Ptr<'a, R>>, 

pub fn hold_cap(hold: &dyn Hold<'a>, cap: usize) -> Ptr<'a, R> where
    R: ResidentWithCapacity<Ptr<'a, R>>, 

pub fn new<T>(data: T) -> Ptr<'a, R> where
    R: ResidentFromValue<Ptr<'a, R>, T>, 

pub fn from_clone<T: ?Sized>(data: &T) -> Ptr<'a, R> where
    R: ResidentFromClone<Ptr<'a, R>, T>, 

pub unsafe fn from_clone_unchecked<T: ?Sized>(data: &T) -> Ptr<'a, R> where
    R: ResidentFromCloneUnchecked<Ptr<'a, R>, T>, 

pub fn from_copy<T: ?Sized>(data: &T) -> Ptr<'a, R> where
    R: ResidentFromCopy<Ptr<'a, R>, T>, 

pub unsafe fn from_copy_unchecked<T: ?Sized>(data: &T) -> Ptr<'a, R> where
    R: ResidentFromCopyUnchecked<Ptr<'a, R>, T>, 

pub fn empty() -> Ptr<'a, R> where
    R: ResidentFromEmpty<Ptr<'a, R>>, 

pub fn with_cap(cap: usize) -> Ptr<'a, R> where
    R: ResidentWithCapacity<Ptr<'a, R>>, 

pub unsafe fn from_raw(data: *mut R::Data) -> Ptr<'a, R>

Constructs a Ptr lease from a raw pointer returned by Ptr::into_raw.

pub fn metadata<'b>(this: &'b Ptr<'a, R>) -> &'b R::Meta

Returns a reference to the user-provided metadata associated with the owned resident.

pub fn metadata_mut<'b>(this: &'b mut Ptr<'a, R>) -> &'b mut R::Meta

Returns a mutable reference to the user-provided metadata associated with the owned resident.

pub unsafe fn into_raw(this: Ptr<'a, R>) -> *mut R::Data

Converts this Ptr lease into a raw pointer to the owned resident. Use Ptr::from_raw to reconstitute the returned pointer back into a Ptr lease.

Safety

A memory leak will occur unless the returned pointer is eventually converted back into an Ptr lease, with the same metadata type, and dropped.

pub fn unwrap(this: Ptr<'a, R>) -> R::Target where
    R: ResidentUnwrap<Ptr<'a, R>>, 

Consumes this Ptr lease, and returns the owned resident.

Trait Implementations

impl<'a, R: Resident> Holder<'a> for Ptr<'a, R>

fn holder(&self) -> &'a dyn Hold<'a>

Returns the Hold that allocated this object.

impl<'a, 'b, R: ResidentStow<'b, Ptr<'a, R>, Ptr<'b, R>>> StowFrom<'b, Ptr<'a, R>> for Ptr<'b, R>

fn try_stow_from(
    src: Ptr<'a, R>,
    hold: &dyn Hold<'b>
) -> Result<Ptr<'b, R>, (Ptr<'a, R>, HoldError)>

Converts a value into Self, allocating in hold as needed.

fn stow_from(value: T, hold: &dyn Hold<'b>) -> Self

impl<'a, 'b, R: ResidentStow<'b, Ptr<'a, R>, Ptr<'b, R>>> Stow<'b, Ptr<'b, R>> for Ptr<'a, R>

unsafe fn stow(
    src: *mut Ptr<'a, R>,
    dst: *mut Ptr<'b, R>,
    hold: &dyn Hold<'b>
) -> Result<(), HoldError>

Moves the value at the src pointer to the dst pointer, recursively moving all child values into the hold. If a child stow operation fails, then any already completed child stow operations get reverted by calling unstow on the child.

unsafe fn unstow(_src: *mut Ptr<'a, R>, _dst: *mut Ptr<'b, R>)

Reverts the most recent stow operation by moving the value at the dst pointer back to the src pointer from whence it came. The memory at the src address will be in the same state the stow operation left it in.

impl<'a, R: ResidentClone<Ptr<'a, R>, Ptr<'a, R>>> TryClone for Ptr<'a, R>

fn try_clone(&self) -> Result<Ptr<'a, R>, HoldError>

Returns a clone of self; returns an error if the clone fails.

impl<'a, 'b, R: ResidentClone<Ptr<'b, R>, Ptr<'a, R>>> CloneIntoHold<'a, Ptr<'a, R>> for Ptr<'b, R>

fn try_clone_into_hold(
    &self,
    hold: &dyn Hold<'a>
) -> Result<Ptr<'a, R>, HoldError>

Returns a clone of self allocated in hold; returns an error if the clone fails.

fn clone_into_hold(&self, hold: &dyn Hold<'a>) -> T

Returns a clone of self allocated in hold.

impl<'a, R: Resident> Lease for Ptr<'a, R>

type Data = R::Data

The type of pointed-to data stored in leased memory blocks. The size of leased memory blocks must be a positive multiple of the Data size.

type Meta = R::Meta

The type of metadata stored with leased memory blocks. Meta data must contain sufficient information to resolve the size of any resided-in memory Lease.

fn data(&self) -> *mut R::Data

Returns a pointer to the leased memory block. The size of the pointed-to memory block is an implementation-defined multiple of the size of the Data type. The Lease makes no guarantees about the initinialization state of the pointed-to data; the resident of the Lease takes full responsibility for managing its own data.

fn meta(&self) -> *mut R::Meta

Returns a pointer to the metadata associated with the leased memory block. The Lease makes no guarantees about the initialization state of the pointed-to metadata; the resident of the Lease takes full responsibility for managing its own metadata.

impl<'a, R: Resident> DynamicLease<'a> for Ptr<'a, R>

unsafe fn realloc(&mut self, new_layout: Layout) -> Result<(), HoldError>

Reallocates the leased memory block to fit the new layout; leaves the existing memory block in its original state on failure.

unsafe fn resize(&mut self, new_layout: Layout) -> Result<(), HoldError>

Resizes the leased memory block in place to fit the new layout, leaves the existing memory block in its original state on failure.

impl<'a, R: ResidentPartialEq<Ptr<'a, R>, T>, T: ?Sized> PartialEq<T> for Ptr<'a, R>

fn eq(&self, other: &T) -> bool

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

fn ne(&self, other: &T) -> bool

This method tests for !=.

impl<'a, R: ResidentEq<Ptr<'a, R>>> Eq for Ptr<'a, R>

impl<'a, R: ResidentOrd<Ptr<'a, R>>> Ord for Ptr<'a, R>

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

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

default 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, R: ResidentPartialOrd<Ptr<'a, R>, T>, T: ?Sized> PartialOrd<T> for Ptr<'a, R>

fn partial_cmp(&self, other: &T) -> Option<Ordering>

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

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

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

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

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

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

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

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

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

impl<'a, R: ResidentDeref<Ptr<'a, R>>> Deref for Ptr<'a, R>

type Target = R::Target

The resulting type after dereferencing.

fn deref(&self) -> &R::Target

Dereferences the value.

impl<'a, R: ResidentDisplay<Ptr<'a, R>>> Display for Ptr<'a, R>

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

Formats the value using the given formatter.

impl<'a, R: ResidentDebug<Ptr<'a, R>>> Debug for Ptr<'a, R>

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

Formats the value using the given formatter.

impl<'a, R: ResidentAdd<Ptr<'a, R>, Rhs>, Rhs> Add<Rhs> for Ptr<'a, R>

type Output = R::Output

The resulting type after applying the + operator.

fn add(self, rhs: Rhs) -> R::Output

Performs the + operation.

impl<'a, R: ResidentAddAssign<Ptr<'a, R>, Rhs>, Rhs> AddAssign<Rhs> for Ptr<'a, R>

fn add_assign(&mut self, rhs: Rhs)

Performs the += operation.

impl<'a, R: ResidentDerefMut<Ptr<'a, R>>> DerefMut for Ptr<'a, R>

fn deref_mut(&mut self) -> &mut R::Target

Mutably dereferences the value.

impl<'a, R: Resident> Drop for Ptr<'a, R>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, R: ResidentIndex<Ptr<'a, R>, Idx>, Idx> Index<Idx> for Ptr<'a, R>

type Output = R::Output

The returned type after indexing.

fn index(&self, index: Idx) -> &R::Output

Performs the indexing (container[index]) operation.

impl<'a, R: ResidentIndexMut<Ptr<'a, R>, Idx>, Idx> IndexMut<Idx> for Ptr<'a, R>

fn index_mut(&mut self, index: Idx) -> &mut R::Output

Performs the mutable indexing (container[index]) operation.

impl<'a, R: ResidentHash<Ptr<'a, R>>> Hash for Ptr<'a, R>

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

Feeds this value into the given [Hasher].

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

Feeds a slice of this type into the given [Hasher].

impl<'a, R: Resident> Sync for Ptr<'a, R> where
    R::Data: Sync,
    R::Meta: Sync, 

impl<'a, R: ResidentIntoIterator<Ptr<'a, R>>> IntoIterator for Ptr<'a, R>

type Item = R::Item

The type of the elements being iterated over.

type IntoIter = R::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> R::IntoIter

Creates an iterator from a value.

impl<'a, R: ResidentIntoRefIterator<'a, Ptr<'a, R>>> IntoIterator for &'a Ptr<'a, R>

type Item = R::Item

The type of the elements being iterated over.

type IntoIter = R::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> R::IntoIter

Creates an iterator from a value.

impl<'a, R: ResidentIntoMutIterator<'a, Ptr<'a, R>>> IntoIterator for &'a mut Ptr<'a, R>

type Item = R::Item

The type of the elements being iterated over.

type IntoIter = R::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> R::IntoIter

Creates an iterator from a value.

impl<'a, R: Resident> Send for Ptr<'a, R> where
    R::Data: Send,
    R::Meta: Send, 

impl<'a, R: Resident> Pointer for Ptr<'a, R>

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

Formats the value using the given formatter.

impl<'a, R: ResidentClone<Ptr<'a, R>, Ptr<'a, R>>> Clone for Ptr<'a, R>

fn clone(&self) -> Ptr<'a, R>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, R: ResidentAsMut<Ptr<'a, R>, T>, T: ?Sized> AsMut<T> for Ptr<'a, R>

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

Performs the conversion.

impl<'a, R: ResidentAsRef<Ptr<'a, R>, T>, T: ?Sized> AsRef<T> for Ptr<'a, R>

fn as_ref(&self) -> &T

Performs the conversion.