Struct swim_mem::lease::Raw

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

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

Methods

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub unsafe fn from_raw_meta(data: *mut R::Data, meta: R::Meta) -> Raw<'a, R>

pub unsafe fn into_raw_meta(this: Raw<'a, R>) -> (*mut R::Data, R::Meta)

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

impl<'a, R: Resident<Meta = ()>> Raw<'a, R>

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

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

Trait Implementations

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

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

Returns the Hold that allocated this object.

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

fn try_stow_from(
    src: Raw<'a, R>,
    hold: &dyn Hold<'b>
) -> Result<Raw<'b, R>, (Raw<'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, Raw<'a, R>, Raw<'b, R>>> Stow<'b, Raw<'b, R>> for Raw<'a, R>

unsafe fn stow(
    src: *mut Raw<'a, R>,
    dst: *mut Raw<'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 Raw<'a, R>, _dst: *mut Raw<'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<Raw<'a, R>, Raw<'a, R>>> TryClone for Raw<'a, R>

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

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

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

fn try_clone_into_hold(
    &self,
    hold: &dyn Hold<'a>
) -> Result<Raw<'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 Raw<'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 Raw<'a, R>

unsafe fn resize(&mut self, 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.

unsafe fn realloc(&mut self, 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.

impl<'a, R: ResidentPartialEq<Raw<'a, R>, T>, T: ?Sized> PartialEq<T> for Raw<'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<Raw<'a, R>>> Eq for Raw<'a, R>

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

fn cmp(&self, other: &Raw<'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<Raw<'a, R>, T>, T: ?Sized> PartialOrd<T> for Raw<'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<Raw<'a, R>>> Deref for Raw<'a, R>

type Target = R::Target

The resulting type after dereferencing.

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

Dereferences the value.

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

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

Formats the value using the given formatter.

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

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

Formats the value using the given formatter.

impl<'a, R: ResidentAdd<Raw<'a, R>, Rhs>, Rhs> Add<Rhs> for Raw<'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<Raw<'a, R>, Rhs>, Rhs> AddAssign<Rhs> for Raw<'a, R>

fn add_assign(&mut self, rhs: Rhs)

Performs the += operation.

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

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

Mutably dereferences the value.

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

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, R: ResidentIndex<Raw<'a, R>, Idx>, Idx> Index<Idx> for Raw<'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<Raw<'a, R>, Idx>, Idx> IndexMut<Idx> for Raw<'a, R>

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

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

impl<'a, R: ResidentHash<Raw<'a, R>>> Hash for Raw<'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 Raw<'a, R> where
    R::Data: Sync,
    R::Meta: Sync, 

impl<'a, R: ResidentIntoIterator<Raw<'a, R>>> IntoIterator for Raw<'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, Raw<'a, R>>> IntoIterator for &'a Raw<'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, Raw<'a, R>>> IntoIterator for &'a mut Raw<'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 Raw<'a, R> where
    R::Data: Send,
    R::Meta: Send, 

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

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

Formats the value using the given formatter.

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

fn clone(&self) -> Raw<'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<Raw<'a, R>, T>, T: ?Sized> AsMut<T> for Raw<'a, R>

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

Performs the conversion.

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

fn as_ref(&self) -> &T

Performs the conversion.