Struct FixedVecSlice 

pub struct FixedVecSlice<V> { /* private fields */ }

A zero-copy view into a contiguous portion of a FixedVec.

A slice is a view that allows for operations on a sub-region of a FixedVec without copying the underlying data. It can be created from both immutable and mutable vectors.

This struct is generic over V, the type of reference to the parent vector, which can be &FixedVec (for an immutable slice) or &mut FixedVec (for a mutable slice).

Implementations

impl<T, W, E, B, V> FixedVecSlice<V>

where T: Storable<W>, W: Word, E: Endianness, B: AsRef<[W]>, V: Deref<Target = FixedVec<T, W, E, B>>,

pub fn len(&self) -> usize

Returns the number of elements in the slice.

pub fn is_empty(&self) -> bool

Returns true if the slice is empty.

pub fn get(&self, index: usize) -> Option<T>

Returns the element at index relative to the start of the slice.

Returns None if index is out of bounds of the slice.

pub unsafe fn get_unchecked(&self, index: usize) -> T

Returns the element at index without bounds checking.

The index is relative to the start of the slice.

Safety

Calling this method with an out-of-bounds index is undefined behavior.

pub fn iter(&self) -> FixedVecSliceIter<'_, T, W, E, B, V>

Returns an iterator over the elements in the slice.

pub fn binary_search(&self, value: &T) -> Result<usize, usize>

where T: Ord,

Binary searches this slice for a given element.

If the value is found, returns Ok(usize) with the index of the matching element within the slice. If the value is not found, returns Err(usize) with the index where the value could be inserted to maintain order.

impl<T, W, E, B, V> FixedVecSlice<V>

where T: Storable<W>, W: Word, E: Endianness, B: AsRef<[W]> + AsMut<[W]>, V: Deref<Target = FixedVec<T, W, E, B>> + DerefMut,

pub fn at_mut(&mut self, index: usize) -> Option<MutProxy<'_, T, W, E, B>>

Returns a mutable proxy for an element at index within the slice.

This allows for syntax like *slice.at_mut(i).unwrap() = new_value;.

Returns None if the index is out of bounds of the slice.

Trait Implementations

impl<V: Debug> Debug for FixedVecSlice<V>

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

Formats the value using the given formatter.

impl<T, W, E, B, T2, V> PartialEq<&[T2]> for FixedVecSlice<V>

where T: Storable<W> + PartialEq<T2>, W: Word, E: Endianness, B: AsRef<[W]>, T2: Clone, V: Deref<Target = FixedVec<T, W, E, B>>,

fn eq(&self, other: &&[T2]) -> 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, W, E, B, B2, V> PartialEq<&FixedVec<T, W, E, B2>> for FixedVecSlice<V>

where T: Storable<W> + PartialEq, W: Word, E: Endianness, B: AsRef<[W]>, B2: AsRef<[W]>, V: Deref<Target = FixedVec<T, W, E, B>>,

fn eq(&self, other: &&FixedVec<T, W, E, B2>) -> 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, W, E, B, B2, V> PartialEq<FixedVec<T, W, E, B2>> for FixedVecSlice<V>

where T: Storable<W> + PartialEq, W: Word, E: Endianness, B: AsRef<[W]>, B2: AsRef<[W]>, V: Deref<Target = FixedVec<T, W, E, B>>,

fn eq(&self, other: &FixedVec<T, W, E, B2>) -> 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, W, E, B, B2, V> PartialEq<FixedVecSlice<V>> for FixedVec<T, W, E, B>

where T: Storable<W> + PartialEq, W: Word, E: Endianness, B: AsRef<[W]>, B2: AsRef<[W]>, V: Deref<Target = FixedVec<T, W, E, B2>>,

fn eq(&self, other: &FixedVecSlice<V>) -> 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, W, E, B, V1, V2> PartialEq<FixedVecSlice<V2>> for FixedVecSlice<V1>

where T: Storable<W> + PartialEq, W: Word, E: Endianness, B: AsRef<[W]>, V1: Deref<Target = FixedVec<T, W, E, B>>, V2: Deref<Target = FixedVec<T, W, E, B>>,

fn eq(&self, other: &FixedVecSlice<V2>) -> 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, W, E, B, V> Eq for FixedVecSlice<V>

where T: Storable<W> + Eq, W: Word, E: Endianness, B: AsRef<[W]>, V: Deref<Target = FixedVec<T, W, E, B>>,