Struct swim_structure::item::Record

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

Value variant representing a collection of Items.

Methods

impl<'a> Record<'a>

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

pub fn hold_slice<'b>(hold: &dyn Hold<'a>, data: &[Item<'b>]) -> Record<'a>

pub fn from_slice<'b>(data: &[Item<'b>]) -> Record<'a>

pub fn is_empty(&self) -> bool

pub fn len(&self) -> usize

pub fn cap(&self) -> usize

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

Upcasts this Record reference to a Value reference.

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

Upcasts this Record reference to a mutable Value reference.

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

Upcasts this Record to a Value.

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

Upcasts this Record to an Item.

pub fn as_slice(&self) -> &[Item<'a>]

pub fn as_mut_slice(&mut self) -> &mut [Item<'a>]

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, item: Item<'a>) -> Result<(), HoldError>

pub fn push(&mut self, item: Item<'a>)

pub fn try_insert(
    &mut self,
    index: usize,
    item: Item<'a>
) -> Result<(), HoldError>

pub fn insert(&mut self, index: usize, item: Item<'a>)

pub fn pop(&mut self) -> Option<Item<'a>>

pub fn remove(&mut self, index: usize) -> Item<'a>

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

pub fn clear(&mut self)

Trait Implementations

impl<'a> PartialEq<Record<'a>> for Record<'a>

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

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

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

This method tests for !=.

impl<'a> Eq for Record<'a>

impl<'a> Ord for Record<'a>

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

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

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

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

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

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

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

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

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

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

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

impl<'a> Deref for Record<'a>

type Target = [Item<'a>]

The resulting type after dereferencing.

fn deref(&self) -> &[Item<'a>]

Dereferences the value.

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

fn from(record: Record<'a>) -> Item<'a>

Performs the conversion.

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

fn from(record: Record<'a>) -> Value<'a>

Performs the conversion.

impl<'a> Debug for Record<'a>

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

Formats the value using the given formatter.

impl<'a> DerefMut for Record<'a>

fn deref_mut(&mut self) -> &mut [Item<'a>]

Mutably dereferences the value.

impl<'a> Drop for Record<'a>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, Idx: SliceIndex<[Item<'a>]> + 'a> Index<Idx> for Record<'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<[Item<'a>]> + 'a> IndexMut<Idx> for Record<'a>

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

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

impl<'a> Hash for Record<'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 Record<'a>

fn clone(&self) -> Record<'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 Record<'a>

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

Performs the conversion.

impl<'a> AsMut<[Item<'a>]> for Record<'a>

fn as_mut(&mut self) -> &mut [Item<'a>]

Performs the conversion.

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

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

Performs the conversion.

impl<'a> AsRef<[Item<'a>]> for Record<'a>

fn as_ref(&self) -> &[Item<'a>]

Performs the conversion.

impl<'a> Holder<'a> for Record<'a>

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

Returns the Hold that allocated this object.

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

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

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

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

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

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