Struct swim_mem::resident::Box

pub struct Box<T: ?Sized, M = ()> { /* fields omitted */ }

A single value, residing in a memory Lease. A Box is a Resident typeclass; it doesn't store any data in its internal structure. Rather, Box implements an access pattern for memory blocks managed by a Lease. A composing Lease type defines the memory allocation and ownership semantics of the composed Box type.

Lease implementations commonly composed with a Box include:

• Own<Box<T>>: the exclusive owner of a relocatable value.
• Mut<Box<T>>: a mutably dereferenceable strong owner of an unrelocatable, reference counted value.
• Ref<Box<T>>: an immutably dereferenceable strong owner of an unrelocatable, reference counted value.
• Hard<Box<T>>: an undereferenceable strong owner of a relocatable, reference counted value.
• Soft<Box<T>>: an undereferenceable weak owner of a relocatable, reference counted value.

Box implements LeaseDeref, and LeaseDerefMut, which enables deref coercions from Own<Box<T>> and Mut<Box<T>> to &T and &mut T, and from Ref<Box<T>> to &T. This makes leased boxes "feel" like they contain a value, even though Box is just a typeclass for accessing the value stored in the composing memory Lease.

Trait Implementations

impl<T: ?Sized, M> Resident for Box<T, M>

type Data = T

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 = M

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.

unsafe fn resident_size(data: *mut T, _meta: *mut M) -> usize

Returns the size in bytes of the Resident with the given data and meta data.

unsafe fn resident_drop(data: *mut T, _meta: *mut M)

Drops the Resident with the given data and meta data.

impl<L: Lease<Data = T, Meta = M>, T, M> ResidentFromValue<L, T, M> for Box<T, M>

fn new_resident_layout(data: &T, _meta: &M) -> Layout

Returns the memory layout for a resident with the given data and meta data.

fn new_resident_ptr(raw: *mut u8, _data: &T, _meta: &M) -> *mut T

Converts a raw pointer into a Data pointer for a resident with the given data and meta data.

fn new_resident(lease: &mut L, data: T, meta: M)

Initializes the lease with a resident from the given data and meta data.

impl<L: Lease<Data = [T], Meta = M>, T: Clone, M> ResidentFromClone<L, [T], M> for Box<[T], M>

fn new_resident_layout(data: &[T], _meta: &M) -> Layout

Returns the memory layout for a resident with a clone of the given data and meta data.

fn new_resident_ptr(raw: *mut u8, data: &[T], _meta: &M) -> *mut [T]

Converts a raw pointer into a Data pointer for a resident with a clone of the given data and meta data.

fn new_resident(lease: &mut L, data: &[T], meta: M)

Initializes the lease with a resident from a clone of the given data and meta data.

impl<L: Lease<Data = [T], Meta = M>, T: Copy, M> ResidentFromCopy<L, [T], M> for Box<[T], M>

fn new_resident_layout(data: &[T], _meta: &M) -> Layout

Returns the memory layout for a resident with a copy of the given data and meta data.

fn new_resident_ptr(raw: *mut u8, data: &[T], _meta: &M) -> *mut [T]

Converts a raw pointer into a Data pointer for a resident with a copy of the given data and meta data.

fn new_resident(lease: &mut L, data: &[T], meta: M)

Initializes the lease with a resident from a copy of the given data and meta data.

impl<L: Lease<Data = str, Meta = M>, M> ResidentFromCopy<L, str, M> for Box<str, M>

fn new_resident_layout(data: &str, _meta: &M) -> Layout

Returns the memory layout for a resident with a copy of the given data and meta data.

fn new_resident_ptr(raw: *mut u8, data: &str, _meta: &M) -> *mut str

Converts a raw pointer into a Data pointer for a resident with a copy of the given data and meta data.

fn new_resident(lease: &mut L, data: &str, meta: M)

Initializes the lease with a resident from a copy of the given data and meta data.

impl<L: Lease> ResidentUnwrap<L> for Box<L::Data, L::Meta> where
    L::Data: Sized, 

type Target = L::Data

The type the resident unwraps to.

fn resident_unwrap(lease: &L) -> L::Data

Returns the unwrapped value for the resident of the given lease, leaving the lease in an uninitialized state.

impl<L: Lease> ResidentDeref<L> for Box<L::Data, L::Meta>

type Target = L::Data

The type the resident dereferences to.

fn resident_deref(lease: &L) -> &L::Data

Immutably dereferences the resident of the lease.

impl<L: Lease> ResidentDerefMut<L> for Box<L::Data, L::Meta>

fn resident_deref_mut(lease: &mut L) -> &mut L::Data

Mutably dereferences the resident of the lease.

impl<L: Lease> ResidentAsRef<L, <L as Lease>::Data> for Box<L::Data, L::Meta>

fn resident_as_ref(lease: &L) -> &L::Data

Returns the resident of the lease as an immutable reference to type T.

impl<L: Lease> ResidentAsMut<L, <L as Lease>::Data> for Box<L::Data, L::Meta>

fn resident_as_mut(lease: &mut L) -> &mut L::Data

Returns the resident of the lease as a mutable reference to type T.

impl<L: Lease> ResidentPartialEq<L, L> for Box<L::Data, L::Meta> where
    L::Data: PartialEq, 

fn resident_eq(lease: &L, other: &L) -> bool

Returns true if the resident of the lease equals some other value.

fn resident_ne(lease: &L, other: &L) -> bool

Returns false if the resident of the lease equals some other value.

impl<L: Lease> ResidentEq<L> for Box<L::Data, L::Meta> where
    L::Data: Eq, 

impl<L: Lease> ResidentPartialOrd<L, L> for Box<L::Data, L::Meta> where
    L::Data: PartialOrd, 

fn resident_partial_cmp(lease: &L, other: &L) -> Option<Ordering>

Returns the ordering of the resident of the lease relative to some other value, if comparable.

fn resident_lt(lease: &L, other: &L) -> bool

Returns true if the resident of the lease orders before some other value.

fn resident_le(lease: &L, other: &L) -> bool

Returns true if the resident of the lease orders before or the same as some other value.

fn resident_ge(lease: &L, other: &L) -> bool

Returns true if the resident of the lease orders the same as or after some other value.

fn resident_gt(lease: &L, other: &L) -> bool

Returns true if the resident of the lease orders after some other value.

impl<L: Lease> ResidentOrd<L> for Box<L::Data, L::Meta> where
    L::Data: Ord, 

fn resident_cmp(lease: &L, other: &L) -> Ordering

Returns the relative ordering of the residents occupying the given leases.

fn resident_lt(lease: &L, other: &L) -> bool

fn resident_le(lease: &L, other: &L) -> bool

fn resident_ge(lease: &L, other: &L) -> bool

fn resident_gt(lease: &L, other: &L) -> bool

impl<L: Lease> ResidentHash<L> for Box<L::Data, L::Meta> where
    L::Data: Hash, 

fn resident_hash<H: Hasher>(lease: &L, state: &mut H)

Hashes the resident of the lease.

impl<L: Lease> ResidentDisplay<L> for Box<L::Data, L::Meta> where
    L::Data: Display, 

fn resident_fmt(lease: &L, f: &mut Formatter) -> Result

Formats the resident of the lease for display.

impl<L: Lease> ResidentDebug<L> for Box<L::Data, L::Meta> where
    L::Data: Debug, 

fn resident_fmt(lease: &L, f: &mut Formatter) -> Result

Formats the resident of the lease for debugging.

impl<L1, L2, T: ?Sized, M> ResidentClone<L1, L2> for Box<T, M> where
    L1: Lease<Data = T, Meta = M>,
    L2: Lease<Data = T, Meta = M>,
    T: TryClone,
    M: TryClone, 

fn new_resident_layout(lease: &L1) -> Layout

Returns the preferred memory layout of a clone destination for the resident of the lease.

fn resident_clone(src: &L1, dst: &mut L2) -> Result<(), HoldError>

Clones the resident of the src lease into the dst lease.

impl<L1, L2, T, M> ResidentClone<L1, L2> for Box<[T], M> where
    L1: Lease<Data = [T], Meta = M>,
    L2: Lease<Data = [T], Meta = M>,
    T: TryClone,
    M: TryClone, 

fn new_resident_layout(lease: &L1) -> Layout

Returns the preferred memory layout of a clone destination for the resident of the lease.

fn resident_clone(src: &L1, dst: &mut L2) -> Result<(), HoldError>

Clones the resident of the src lease into the dst lease.

impl<L1, L2, M> ResidentClone<L1, L2> for Box<str, L1::Meta> where
    L1: Lease<Data = str, Meta = M>,
    L2: Lease<Data = str, Meta = M>,
    M: TryClone, 

fn new_resident_layout(lease: &L1) -> Layout

Returns the preferred memory layout of a clone destination for the resident of the lease.

fn resident_clone(src: &L1, dst: &mut L2) -> Result<(), HoldError>

Clones the resident of the src lease into the dst lease.

impl<'b, L1: Lease, L2: Lease> ResidentStow<'b, L1, L2> for Box<L1::Data, L1::Meta> where
    L1::Data: Stow<'b, L2::Data>,
    L1::Meta: Stow<'b, L2::Meta>, 

fn new_resident_layout(lease: &L1) -> Layout

Returns the preferred memory layout of a move destination for the resident of the lease.

unsafe fn resident_stow(
    src: &mut L1,
    dst: &mut L2,
    hold: &dyn Hold<'b>
) -> Result<(), HoldError>

Relocates the resident from the src lease to the dst lease. Leaves the src lase in its original state on failure.

unsafe fn resident_unstow(src: &mut L1, dst: &mut L2)

Reverts the most recent resident_stow operation by relocating the resident of the dst lease back to the src lease.

impl<T: Sync, M: Sync> Sync for Box<T, M>

impl<T: Send, M: Send> Send for Box<T, M>