Enum VectorDiff

pub enum VectorDiff<T> {
    Append {
        values: Vector<T>,
    },
    Clear,
    PushFront {
        value: T,
    },
    PushBack {
        value: T,
    },
    PopFront,
    PopBack,
    Insert {
        index: usize,
        value: T,
    },
    Set {
        index: usize,
        value: T,
    },
    Remove {
        index: usize,
    },
    Truncate {
        length: usize,
    },
    Reset {
        values: Vector<T>,
    },
}

A change to an ObservableVector.

Variants

Append

Multiple elements were appended.

Fields

values: Vector<T>

The appended elements.

Clear

The vector was cleared.

PushFront

An element was added at the front.

Fields

value: T

The new element.

PushBack

An element was added at the back.

Fields

value: T

The new element.

PopFront

The element at the front was removed.

PopBack

The element at the back was removed.

Insert

An element was inserted at the given position.

Fields

index: usize

The index of the new element.

The element that was previously at that index as well as all the ones after it were shifted to the right.

value: T

The new element.

Set

A replacement of the previous value at the given position.

Fields

index: usize

The index of the element that was replaced.

value: T

The new element.

Remove

Removal of an element.

Fields

index: usize

The index that the removed element had.

Truncate

Truncation of the vector.

Fields

length: usize

The number of elements that remain.

Reset

The subscriber lagged too far behind, and the next update that should have been received has already been discarded from the internal buffer.

Fields

values: Vector<T>

The full list of elements.

Implementations

impl<T: Clone> VectorDiff<T>

pub fn map<U: Clone>(self, f: impl FnMut(T) -> U) -> VectorDiff<U>

Transform VectorDiff<T> into VectorDiff<U> by applying the given function to any contained items.

pub fn apply(self, vec: &mut Vector<T>)

Applies this VectorDiff to a vector.

This is useful to keep two vectors in sync, with potentially one containing data mapped from the other.

Panics

When inserting/setting/removing elements past the end.

Trait Implementations

impl<T: Clone> Clone for VectorDiff<T>

fn clone(&self) -> VectorDiff<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for VectorDiff<T>

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

Formats the value using the given formatter.

impl<T: PartialEq> PartialEq for VectorDiff<T>

fn eq(&self, other: &VectorDiff<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Eq> Eq for VectorDiff<T>

impl<T> StructuralPartialEq for VectorDiff<T>