Enum VecEvent 

pub enum VecEvent<T> {
    Push(T),
    Pop,
    Insert(usize, T),
    Set(usize, T),
    Remove(usize),
    SwapRemove(usize),
    Fill(T),
    Resize(usize, T),
    Truncate(usize),
    Retain(HashSet<usize>),
    RetainNot(HashSet<usize>),
    Clear,
    ShrinkToFit,
    Done,
    InitialComplete,
}

Available on crate feature robs only.

A vector change event.

Variants

Push(T)

An item was added at the end.

Pop

The last item was removed.

Insert(usize, T)

An item was inserted at the given index.

Set(usize, T)

The specified item was modified.

Remove(usize)

The specified item was removed.

SwapRemove(usize)

The specified element was removed and replaced by the last element.

Fill(T)

All vector elements have been set to the specified value.

Resize(usize, T)

The vector has been resized to the specified length.

Truncate(usize)

The vector has been truncated to the specified length.

Retain(HashSet<usize>)

Retain the specified elements.

RetainNot(HashSet<usize>)

Retain the inverse of the specified elements.

Clear

All items were removed.

ShrinkToFit

Shrink capacity to fit.

Done

The vector has reached its final state and no further events will occur.

InitialComplete

The incremental subscription has reached the value of the observed vector at the time it was subscribed.

Trait Implementations

impl<T: Clone> Clone for VecEvent<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for VecEvent<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for VecEvent<T>

where T: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: PartialEq> PartialEq for VecEvent<T>

fn eq(&self, other: &VecEvent<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> Serialize for VecEvent<T>

where T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Eq> Eq for VecEvent<T>

impl<T> StructuralPartialEq for VecEvent<T>