Struct ArrayObserver 

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

Observer implementation for arrays [T; N].

Implementations

impl<'ob, const N: usize, O, S, D, T> ArrayObserver<'ob, N, O, S, D>

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

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

See array::as_slice.

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

See array::as_mut_slice.

pub fn each_ref(&self) -> [&O; N]

See array::each_ref.

pub fn each_mut(&mut self) -> [&mut O; N]

See array::each_mut.

Methods from Deref<Target = SliceObserver<'ob, [O; N], (), S, 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, const N: usize, O, S: ?Sized, D> AsNormalized for ArrayObserver<'ob, N, 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, const N: usize, O, S, D, T> Debug for ArrayObserver<'ob, N, O, S, D>

where D: Unsigned, S: AsDerefMut<D, Target = [T; N]> + ?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, const N: usize, O, S: ?Sized, D> Deref for ArrayObserver<'ob, N, O, S, D>

type Target = SliceObserver<'ob, [O; N], (), S, D>

The resulting type after dereferencing.

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

Dereferences the value.

impl<'ob, const N: usize, O, S: ?Sized, D> DerefMut for ArrayObserver<'ob, N, O, S, D>

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

Mutably dereferences the value.

impl<'ob, const N: usize, O, S, D, T, I> Index<I> for ArrayObserver<'ob, N, 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, const N: usize, O, S, D, T, I> IndexMut<I> for ArrayObserver<'ob, N, 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, const N: usize, O, S, D, T> Observer<'ob> for ArrayObserver<'ob, N, O, S, D>

where D: Unsigned, S: AsDerefMut<D, Target = [T; N]> + '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, const N: usize, O, S, D, T, U> PartialEq<U> for ArrayObserver<'ob, N, O, S, D>

where D: Unsigned, S: AsDerefMut<D, Target = [T; N]> + ?Sized, O: Observer<'ob, InnerDepth = Zero, Head = T>, [T; N]: 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, const N: usize, O, S, D, T, U> PartialOrd<U> for ArrayObserver<'ob, N, O, S, D>

where D: Unsigned, S: AsDerefMut<D, Target = [T; N]> + ?Sized, O: Observer<'ob, InnerDepth = Zero, Head = T>, [T; N]: 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, const N: usize, O, S, D, T> SerializeObserver<'ob> for ArrayObserver<'ob, N, O, S, D>

where D: Unsigned, S: AsDerefMut<D, Target = [T; N]> + '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.