Struct swim_structure::item::Data

#[repr(C)]
pub struct Data<'a> { /* fields omitted */ }

Value variant representing a byte buffer.

Methods

impl<'a> Data<'a>

pub fn try_hold_slice(
    hold: &dyn Hold<'a>,
    data: &[u8]
) -> Result<Data<'a>, HoldError>

pub fn hold_slice(hold: &dyn Hold<'a>, data: &[u8]) -> Data<'a>

pub fn from_slice(data: &[u8]) -> Data<'a>

pub fn is_empty(&self) -> bool

pub fn len(&self) -> usize

pub unsafe fn set_len(&mut self, new_len: usize)

pub fn cap(&self) -> usize

pub fn as_value(&self) -> &Value<'a>

Upcasts this Data reference to a Value reference.

pub fn as_mut_value(&mut self) -> &mut Value<'a>

Upcasts this Data reference to a mutable Value reference.

pub fn into_value(self) -> Value<'a>

Upcasts this Data to a Value.

pub fn into_item(self) -> Item<'a>

Upcasts this Data to an Item.

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

pub fn as_mut_ptr(&mut self) -> *mut u8

pub fn as_slice(&self) -> &[u8]

pub fn as_mut_slice(&mut self) -> &mut [u8]

pub fn try_reserve(&mut self, ext: usize) -> Result<(), HoldError>

pub fn reserve(&mut self, ext: usize)

pub fn try_reserve_exact(&mut self, ext: usize) -> Result<(), HoldError>

pub fn reserve_exact(&mut self, ext: usize)

pub fn try_reserve_in_place(&mut self, ext: usize) -> Result<(), HoldError>

pub fn try_reserve_in_place_exact(
    &mut self,
    ext: usize
) -> Result<(), HoldError>

pub fn try_push(&mut self, value: u8) -> Result<(), HoldError>

pub fn push(&mut self, value: u8)

pub fn try_insert(&mut self, index: usize, value: u8) -> Result<(), HoldError>

pub fn insert(&mut self, index: usize, value: u8)

pub fn try_insert_slice(
    &mut self,
    index: usize,
    slice: &[u8]
) -> Result<(), HoldError>

pub fn insert_slice(&mut self, index: usize, slice: &[u8])

pub fn pop(&mut self) -> Option<u8>

pub fn remove(&mut self, index: usize) -> u8

pub fn truncate(&mut self, new_len: usize)

pub fn clear(&mut self)

Trait Implementations

impl<'a> PartialEq<Data<'a>> for Data<'a>

fn eq(&self, that: &Data<'a>) -> bool

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

fn ne(&self, that: &Data<'a>) -> bool

This method tests for !=.

impl<'a> Eq for Data<'a>

impl<'a> Ord for Data<'a>

fn cmp(&self, other: &Data<'a>) -> 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> PartialOrd<Data<'a>> for Data<'a>

fn partial_cmp(&self, that: &Data<'a>) -> Option<Ordering>

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

fn lt(&self, that: &Data<'a>) -> bool

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

fn le(&self, that: &Data<'a>) -> bool

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

fn ge(&self, that: &Data<'a>) -> bool

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

fn gt(&self, that: &Data<'a>) -> bool

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

impl<'a> Deref for Data<'a>

type Target = [u8]

The resulting type after dereferencing.

fn deref(&self) -> &[u8]

Dereferences the value.

impl<'a> From<Data<'a>> for Item<'a>

fn from(data: Data<'a>) -> Item<'a>

Performs the conversion.

impl<'a> From<Data<'a>> for Value<'a>

fn from(data: Data<'a>) -> Value<'a>

Performs the conversion.

impl<'a> Debug for Data<'a>

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

Formats the value using the given formatter.

impl<'a> DerefMut for Data<'a>

fn deref_mut(&mut self) -> &mut [u8]

Mutably dereferences the value.

impl<'a> Drop for Data<'a>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, Idx: SliceIndex<[u8]>> Index<Idx> for Data<'a>

type Output = Idx::Output

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<'a, Idx: SliceIndex<[u8]>> IndexMut<Idx> for Data<'a>

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

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

impl<'a> Hash for Data<'a>

fn hash<H: Hasher>(&self, hasher: &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> Clone for Data<'a>

fn clone(&self) -> Data<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> AsMut<Value<'a>> for Data<'a>

fn as_mut(&mut self) -> &mut Value<'a>

Performs the conversion.

impl<'a> AsMut<[u8]> for Data<'a>

fn as_mut(&mut self) -> &mut [u8]

Performs the conversion.

impl<'a> AsRef<Value<'a>> for Data<'a>

fn as_ref(&self) -> &Value<'a>

Performs the conversion.

impl<'a> AsRef<[u8]> for Data<'a>

fn as_ref(&self) -> &[u8]

Performs the conversion.

impl<'a> Holder<'a> for Data<'a>

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

Returns the Hold that allocated this object.

impl<'a, 'b> Stow<'b, Data<'b>> for Data<'a>

unsafe fn stow(
    src: *mut Data<'a>,
    dst: *mut Data<'b>,
    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 Data<'a>, _dst: *mut Data<'b>)

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> TryClone for Data<'a>

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

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

impl<'a, 'b> CloneIntoHold<'a, Data<'a>> for Data<'b>

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

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

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

Returns a clone of self allocated in hold.