Struct VecObserver 

pub struct VecObserver<'ob, O, S: ?Sized, D = Zero> { /* private fields */ }

Observer implementation for Vec<T>.

Implementations

impl<'ob, O, S, D, T> VecObserver<'ob, O, S, D>

where D: Unsigned, S: AsDerefMut<D, Target = Vec<T>> + 'ob + ?Sized, O: Observer<'ob, InnerDepth = Zero, Head = T> + 'ob, T: 'ob,

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

See Vec::reserve.

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

See Vec::reserve_exact.

pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError>

See Vec::try_reserve.

pub fn try_reserve_exact( &mut self, additional: usize, ) -> Result<(), TryReserveError>

See Vec::try_reserve_exact.

pub fn shrink_to_fit(&mut self)

See Vec::shrink_to_fit.

pub fn shrink_to(&mut self, min_capacity: usize)

See Vec::shrink_to.

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

See Vec::as_slice.

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

See Vec::as_mut_slice.

impl<'ob, O, S, D, T> VecObserver<'ob, O, S, D>

where D: Unsigned, S: AsDerefMut<D, Target = Vec<T>> + 'ob + ?Sized, O: Observer<'ob, InnerDepth = Zero, Head = T> + 'ob, T: 'ob,

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

Available on crate feature append only.

See Vec::push.

pub fn append(&mut self, other: &mut Vec<T>)

Available on crate feature append only.

See Vec::append.

pub fn insert(&mut self, index: usize, element: T)

Available on crate feature append only.

See Vec::insert.

impl<'ob, O, S, D, T> VecObserver<'ob, O, S, D>

where D: Unsigned, S: AsDerefMut<D, Target = Vec<T>> + 'ob + ?Sized, O: Observer<'ob, InnerDepth = Zero, Head = T> + 'ob, T: 'ob,

pub fn clear(&mut self)

Available on crate features append or truncate only.

See Vec::clear.

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

Available on crate features append or truncate only.

See Vec::remove.

pub fn swap_remove(&mut self, index: usize) -> T

Available on crate features append or truncate only.

See Vec::swap_remove.

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

Available on crate features append or truncate only.

See Vec::pop.

pub fn pop_if(&mut self, predicate: impl FnOnce(&mut O) -> bool) -> Option<T>

Available on crate features append or truncate only.

See Vec::pop_if.

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

Available on crate features append or truncate only.

See Vec::truncate.

pub fn split_off(&mut self, at: usize) -> Vec<T>

Available on crate features append or truncate only.

See Vec::split_off.

pub fn resize_with<F>(&mut self, new_len: usize, f: F)

where F: FnMut() -> T,

Available on crate features append or truncate only.

See Vec::resize_with.

pub fn drain<R>(&mut self, range: R) -> Drain<'_, T>

where R: RangeBounds<usize>,

Available on crate features append or truncate only.

See Vec::drain.

pub fn splice<R, I>( &mut self, range: R, replace_with: I, ) -> Splice<'_, I::IntoIter>

where R: RangeBounds<usize>, I: IntoIterator<Item = T>,

Available on crate features append or truncate only.

See Vec::splice.

pub fn extract_if<F, R>(&mut self, range: R, filter: F) -> ExtractIf<'_, T, F>

where F: FnMut(&mut T) -> bool, R: RangeBounds<usize>,

Available on crate features append or truncate only.

See Vec::extract_if.

impl<'ob, O, S, D, T> VecObserver<'ob, O, S, D>

where D: Unsigned, S: AsDerefMut<D, Target = Vec<T>> + 'ob + ?Sized, O: Observer<'ob, InnerDepth = Zero, Head = T> + 'ob, T: Clone + 'ob,

pub fn extend_from_slice(&mut self, other: &[T])

Available on crate feature append only.

See Vec::extend_from_slice.

pub fn extend_from_within<R>(&mut self, src: R)

where R: RangeBounds<usize>,

Available on crate feature append only.

See Vec::extend_from_within.

impl<'ob, O, S, D, T> VecObserver<'ob, O, S, D>

where D: Unsigned, S: AsDerefMut<D, Target = Vec<T>> + 'ob + ?Sized, O: Observer<'ob, InnerDepth = Zero, Head = T> + 'ob, T: Clone + 'ob,

pub fn resize(&mut self, new_len: usize, value: T)

Available on crate features append or truncate only.

See Vec::resize.

Methods from Deref<Target = SliceObserver<'ob, UnsafeCell<Vec<O>>, TruncateAppend, S, Succ<D>>>

pub fn first_mut(&mut self) -> Option<&mut O>

See slice::first_mut.

pub fn split_first_mut(&mut self) -> Option<(&mut O, &mut [O])>

See slice::split_first_mut.

pub fn split_last_mut(&mut self) -> Option<(&mut O, &mut [O])>

See slice::split_last_mut.

pub fn last_mut(&mut self) -> Option<&mut O>

See slice::last_mut.

pub fn first_chunk_mut<const N: usize>(&mut self) -> Option<&mut [O; N]>

See slice::first_chunk_mut.

pub fn split_first_chunk_mut<const N: usize>( &mut self, ) -> Option<(&mut [O; N], &mut [O])>

See slice::split_first_chunk_mut.

pub fn split_last_chunk_mut<const N: usize>( &mut self, ) -> Option<(&mut [O], &mut [O; N])>

See slice::split_last_chunk_mut.

pub fn last_chunk_mut<const N: usize>(&mut self) -> Option<&mut [O; N]>

See slice::last_chunk_mut.

pub fn get_mut(&mut self, index: usize) -> Option<&mut O>

See slice::get_mut.

pub fn swap(&mut self, a: usize, b: usize)

See slice::swap.

pub fn iter_mut(&mut self) -> IterMut<'_, O>

See slice::iter_mut.

pub fn chunks_mut(&mut self, chunk_size: usize) -> ChunksMut<'_, O>

See slice::chunks_mut.

pub fn chunks_exact_mut(&mut self, chunk_size: usize) -> ChunksExactMut<'_, O>

See slice::chunks_exact_mut.

pub fn as_chunks_mut<const N: usize>(&mut self) -> (&mut [[O; N]], &mut [O])

See slice::as_chunks_mut.

pub fn as_rchunks_mut<const N: usize>(&mut self) -> (&mut [O], &mut [[O; N]])

See slice::as_rchunks_mut.

pub fn rchunks_mut(&mut self, chunk_size: usize) -> RChunksMut<'_, O>

See slice::rchunks_mut.

pub fn rchunks_exact_mut(&mut self, chunk_size: usize) -> RChunksExactMut<'_, O>

See slice::rchunks_exact_mut.

pub fn chunk_by_mut<F>(&mut self, pred: F) -> ChunkByMut<'_, O, F>

where F: FnMut(&O, &O) -> bool,

See slice::chunk_by_mut.

pub fn split_at_mut(&mut self, mid: usize) -> (&mut [O], &mut [O])

See slice::split_at_mut.

pub fn split_at_mut_checked( &mut self, mid: usize, ) -> Option<(&mut [O], &mut [O])>

See slice::split_at_mut_checked.

pub fn split_mut<F>(&mut self, pred: F) -> SplitMut<'_, O, F>

where F: FnMut(&O) -> bool,

See slice::split_mut.

pub fn split_inclusive_mut<F>(&mut self, pred: F) -> SplitInclusiveMut<'_, O, F>

where F: FnMut(&O) -> bool,

See slice::split_inclusive_mut.

pub fn rsplit_mut<F>(&mut self, pred: F) -> RSplitMut<'_, O, F>

where F: FnMut(&O) -> bool,

See slice::rsplit_mut.

pub fn splitn_mut<F>(&mut self, n: usize, pred: F) -> SplitNMut<'_, O, F>

where F: FnMut(&O) -> bool,

See slice::splitn_mut.

pub fn rsplitn_mut<F>(&mut self, n: usize, pred: F) -> RSplitNMut<'_, O, F>

where F: FnMut(&O) -> bool,

See slice::rsplitn_mut.

Trait Implementations

impl<'ob, O, S: ?Sized, D> AsNormalized for VecObserver<'ob, O, S, D>

type OuterDepth = Succ<Succ<Zero>>

The number of outer dereference layers to reach the normalized value.

fn as_normalized_ref(&self) -> &Self::Target

Returns a normalized reference to the underlying value.

fn as_normalized_mut(&mut self) -> &mut Self::Target

where Self: AsDerefMutCoinductive<Self::OuterDepth>,

Returns a normalized mutable reference to the underlying value.

impl<'ob, O, S, D, T> Debug for VecObserver<'ob, O, S, D>

where D: Unsigned, S: AsDerefMut<D, Target = Vec<T>> + ?Sized, O: Observer<'ob, InnerDepth = Zero, Head = T>, T: Debug,

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

Formats the value using the given formatter.

impl<'ob, O, S: ?Sized, D> Deref for VecObserver<'ob, O, S, D>

type Target = SliceObserver<'ob, UnsafeCell<Vec<O>>, TruncateAppend, S, Succ<D>>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'ob, O, S: ?Sized, D> DerefMut for VecObserver<'ob, O, S, D>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'ob, O, S, D, T, U> Extend<U> for VecObserver<'ob, O, S, D>

where D: Unsigned, S: AsDerefMut<D, Target = Vec<T>> + 'ob + ?Sized, O: Observer<'ob, InnerDepth = Zero, Head = T>, T: 'ob, Vec<T>: Extend<U>,

Available on crate feature append only.

fn extend<I: IntoIterator<Item = U>>(&mut self, other: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'ob, O, S, D, T, I> Index<I> for VecObserver<'ob, O, S, D>

where D: Unsigned, S: AsDerefMut<D, Target = Vec<T>> + 'ob + ?Sized, O: Observer<'ob, InnerDepth = Zero, Head = T> + 'ob, T: 'ob, I: SliceIndex<[O]> + SliceIndexImpl<[O], I::Output>,

type Output = <I as SliceIndex<[O]>>::Output

The returned type after indexing.

fn index(&self, index: I) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'ob, O, S, D, T, I> IndexMut<I> for VecObserver<'ob, O, S, D>

where D: Unsigned, S: AsDerefMut<D, Target = Vec<T>> + 'ob + ?Sized, O: Observer<'ob, InnerDepth = Zero, Head = T> + 'ob, T: 'ob, I: SliceIndex<[O]> + SliceIndexImpl<[O], I::Output>,

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

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

impl<'ob, O, S, D, T> Observer<'ob> for VecObserver<'ob, O, S, D>

where D: Unsigned, S: AsDerefMut<D, Target = Vec<T>> + 'ob + ?Sized, O: Observer<'ob, InnerDepth = Zero, Head = T>,

type InnerDepth = D

Type-level number of dereferences from Head to the observed type.

type Head = S

The head type of the dereference chain.

fn uninit() -> Self

Creates an uninitialized observer.

fn observe(value: &'ob mut Self::Head) -> Self

Creates a new observer for the given value.

unsafe fn refresh(this: &mut Self, value: &mut Self::Head)

Refreshes the observer’s internal pointer after the observed value has moved.

unsafe fn force(this: &mut Self, value: &'ob mut Self::Head)

Forces the observer into a valid state for the given value.

fn as_inner<'i>( this: &Self, ) -> &'i mut <Self::Head as AsDeref<Self::InnerDepth>>::Target

where Self::Head: AsDerefMut<Self::InnerDepth>, 'ob: 'i,

Gets a mutable reference to the inner observed value without triggering observation.

fn track_inner<'i>( this: &mut Self, ) -> &'i mut <Self::Head as AsDeref<Self::InnerDepth>>::Target

where Self::Head: AsDerefMut<Self::InnerDepth>, 'ob: 'i,

Gets a mutable reference to the inner observed value while triggering observation.

impl<'ob, O, S, D, T, U> PartialEq<U> for VecObserver<'ob, O, S, D>

where D: Unsigned, S: AsDerefMut<D, Target = Vec<T>> + ?Sized, O: Observer<'ob, InnerDepth = Zero, Head = T>, Vec<T>: PartialEq<U>,

fn eq(&self, other: &U) -> 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<'ob, O, S, D, T, U> PartialOrd<U> for VecObserver<'ob, O, S, D>

where D: Unsigned, S: AsDerefMut<D, Target = Vec<T>> + ?Sized, O: Observer<'ob, InnerDepth = Zero, Head = T>, Vec<T>: PartialOrd<U>,

fn partial_cmp(&self, other: &U) -> Option<Ordering>

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<'ob, O, S, D, T> SerializeObserver<'ob> for VecObserver<'ob, O, S, D>

where D: Unsigned, S: AsDerefMut<D, Target = Vec<T>> + 'ob + ?Sized, O: SerializeObserver<'ob, InnerDepth = Zero, Head = T>, T: Serialize,

unsafe fn flush_unchecked<A: Adapter>( this: &mut Self, ) -> Result<Mutations<A::Value>, A::Error>

Flushes and serializes all recorded mutations (unsafe version).

fn flush<A: Adapter>(this: &mut Self) -> Result<Mutations<A::Value>, A::Error>

Flushes and serializes all recorded mutations using the specified adapter.