Struct swim_mem::resident::Buf

pub struct Buf<T, M = ()> { /* fields omitted */ }

A resizeable array of values, residing in a memory Lease. A Buf is a Resident typeclass; it doesn't store any data in its internal structure. Rather, Buf 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 Buf type.

Lease implementations commonly composed with a Buf include:

• Own<Buf<T>>: the exclusive owner of a relocatable, resizeable array.
• Mut<Buf<T>>: a mutably dereferenceable strong owner of an unrelocatable, resizeable array.
• Ref<Buf<T>>: an immutably dereferenceable strong owner of an unrelocatable, resizeable array.
• Hard<Buf<T>>: an undereferenceable strong owner of a relocatable array.
• Soft<Buf<T>>: an undereferenceable weak owner of a relocatable array.

Buf implements LeaseDeref, and LeaseDerefMut, which enables deref coercions from Own<Buf<T>>, Mut<Buf<T>>, and Ref<Buf<T>> to &BufLease<L, T>. BufLease in turn deref coerces to &[T] and &mut [T]. This makes leased bufs "feel" like they contain a slice, even though Buf is just a typeclass for accessing the slice stored in the composing memory Lease. Most buffer operations are defined on BufLease; Buf can't do much on its own since it doesn't actually contain any data.

Trait Implementations

impl<T, M> Resident for Buf<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 = BufHeader<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 BufHeader<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 BufHeader<M>)

Drops the Resident with the given data and meta data.

impl<'a, L: Lease<Data = T, Meta = BufHeader<M>> + Holder<'a>, T, U: CloneIntoHold<'a, T>, M> ResidentFromClone<L, [U], M> for Buf<T, M>

fn new_resident_layout(data: &[U], _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: &[U], _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: &[U], meta: M)

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

impl<L: Lease<Data = T, Meta = BufHeader<M>>, T: Copy, M> ResidentFromCopy<L, [T], M> for Buf<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 = u8, Meta = BufHeader<M>>, M> ResidentFromCopy<L, str, M> for Buf<u8, 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 u8

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<Data = T, Meta = BufHeader<M>>, T, M> ResidentFromEmpty<L, M> for Buf<T, M>

fn new_resident_layout(_meta: &M) -> Layout

Returns the memory layout for an empty resident with the given meta data.

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

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

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

Initializes the lease with an empty resident from the given meta data.

impl<L: Lease<Data = T, Meta = BufHeader<M>>, T, M> ResidentWithCapacity<L, M> for Buf<T, M>

fn new_resident_layout(cap: usize, _meta: &M) -> Result<Layout, LayoutError>

Returns the memory layout for an empty resident with the given pre-allocated capacity and meta data.

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

Converts a raw pointer into a Data pointer for an empty resident with the given preallocated capacity and meta data.

fn new_resident(lease: &mut L, cap: usize, meta: M)

Initializes the lease with an empty resident from the given pre-allocated capacity and meta data.

impl<L: Lease<Data = T, Meta = BufHeader<M>>, T, M> ResidentDeref<L> for Buf<T, M>

type Target = BufLease<L, T, M>

The type the resident dereferences to.

fn resident_deref(lease: &L) -> &BufLease<L, T, M>

Immutably dereferences the resident of the lease.

impl<L: Lease<Data = T, Meta = BufHeader<M>>, T, M> ResidentDerefMut<L> for Buf<T, M>

fn resident_deref_mut(lease: &mut L) -> &mut BufLease<L, T, M>

Mutably dereferences the resident of the lease.

impl<L: Lease<Data = T, Meta = BufHeader<M>>, T, M> ResidentAsRef<L, [T]> for Buf<T, M>

fn resident_as_ref(lease: &L) -> &[T]

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

impl<L: Lease<Data = T, Meta = BufHeader<M>>, T, M> ResidentAsMut<L, [T]> for Buf<T, M>

fn resident_as_mut(lease: &mut L) -> &mut [T]

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

impl<L: Lease<Meta = BufHeader<M>>, Idx: SliceIndex<[L::Data]>, M> ResidentIndex<L, Idx> for Buf<L::Data, M> where
    L::Data: Sized, 

type Output = Idx::Output

The type of values indexed by the resident for the parameterized Idx type.

fn resident_index(lease: &L, index: Idx) -> &Idx::Output

Returns an immutable reference to the value at the given index of the resident of the lease.

impl<L: Lease<Meta = BufHeader<M>>, Idx: SliceIndex<[L::Data]>, M> ResidentIndexMut<L, Idx> for Buf<L::Data, M> where
    L::Data: Sized, 

fn resident_index_mut(lease: &mut L, index: Idx) -> &mut Idx::Output

Returns a mutable reference to the value at the given index of the resident of the lease.

impl<L: Lease<Data = T, Meta = BufHeader<M>>, T, M> ResidentIntoIterator<L> for Buf<T, M>

type Item = T

The type of element to iterator over.

type IntoIter = BufIter<L, T, M>

The type of iterator to return.

Important traits for BufIter<L, T, M>

impl<L: Lease<Data = T, Meta = BufHeader<M>>, T, M> Iterator for BufIter<L, T, M> type Item = T;

fn resident_into_iter(lease: L) -> BufIter<L, T, M>

Returns a new Iterator that consumes the elements of the lease.

impl<'a, L: Lease<Data = T, Meta = BufHeader<M>>, T: 'a, M> ResidentIntoRefIterator<'a, L> for Buf<T, M>

type Item = &'a T

The type of element to iterator over.

type IntoIter = Iter<'a, T>

The type of iterator to return.

fn resident_into_iter(lease: &'a L) -> Iter<'a, T>

Returns a new Iterator that consumes the elements of the lease.

impl<'a, L: Lease<Data = T, Meta = BufHeader<M>>, T: 'a, M> ResidentIntoMutIterator<'a, L> for Buf<T, M>

type Item = &'a mut T

The type of element to iterator over.

type IntoIter = IterMut<'a, T>

The type of iterator to return.

fn resident_into_iter(lease: &'a mut L) -> IterMut<'a, T>

Returns a new Iterator that consumes the elements of the lease.

impl<L: Lease<Data = T, Meta = BufHeader<M>>, T: PartialEq, M> ResidentPartialEq<L, L> for Buf<T, M>

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<Data = T, Meta = BufHeader<M>>, T: Eq, M> ResidentEq<L> for Buf<T, M>

impl<L: Lease<Data = T, Meta = BufHeader<M>>, T: PartialOrd, M> ResidentPartialOrd<L, L> for Buf<T, M>

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<Data = T, Meta = BufHeader<M>>, T: Ord, M> ResidentOrd<L> for Buf<T, M>

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<Data = T, Meta = BufHeader<M>>, T: Hash, M> ResidentHash<L> for Buf<T, M>

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

Hashes the resident of the lease.

impl<L: Lease<Data = T, Meta = BufHeader<M>>, T: Debug, M> ResidentDebug<L> for Buf<T, M>

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

Formats the resident of the lease for debugging.

impl<L1, L2, T, M> ResidentClone<L1, L2> for Buf<T, M> where
    L1: Lease<Data = T, Meta = BufHeader<M>>,
    L2: Lease<Data = T, Meta = BufHeader<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<'b, L1, L2, T, M> ResidentStow<'b, L1, L2> for Buf<T, M> where
    L1: Lease<Data = T, Meta = BufHeader<M>>,
    L2: Lease<Data = T, Meta = BufHeader<M>>,
    T: TryClone,
    M: TryClone, 

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 Buf<T, M>

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