Struct ArraySection

pub struct ArraySection<T, const N: usize> { /* private fields */ }

An array where only a section of the data may be viewed, as the other data may e.g. not uphold some invariant.

Indexing into the ArraySection indexes only into the section:

//                                                     v  v
const AS: ArraySection<i32, 4> = ArraySection::new([0, 1, 2, 0], 1..3);
assert_eq![AS[0], 1];
assert_eq![AS[1], 2];

The other data is not considered in comparisons, ordering or hashing:

//                       v  v
const A1: [i32; 4] = [1, 3, 7, 1];
const A2: [i32; 5] = [0, 3, 7, 100, -5];
const AS1: ArraySection<i32, 4> = ArraySection::new(A1, 1..3);
const AS2: ArraySection<i32, 5> = ArraySection::new(A2, 1..3);

// Even though the arrays are different
assert_ne!(A1.as_slice(), A2.as_slice());
// The sections are the same
assert_eq!(AS1, AS2);

Implementations

impl<const N: usize, T> ArraySection<T, N>

pub const fn new(array: [T; N], section: Range<usize>) -> Self

Restrict an array so that only elements within the given range are visible.

Panics

Panics if the range of indices is out of bounds of the array.

pub const fn start(&self) -> usize

Returns the first index of the full underlying array that is part of the section. I.e. the section is the subrange start ..end.

pub const fn end(&self) -> usize

Returns the first index of the full underlying array that is outside the section (to the right). I.e. the section is the subrange start.. end.

pub fn change_section(&mut self, section: Range<usize>)

Changes the section of the array to the given one.

Panics

Panics if the start and/or end of the given section is out of bounds of the array.

pub const fn try_as_full_array(&self) -> Option<&[T; N]>

Returns a reference to the full underlying array if it is fully populated.

pub fn try_as_full_array_mut(&mut self) -> Option<&mut [T; N]>

Returns a mutable reference to the full underlying array if it is fully populated.

pub const fn as_full_array(&self) -> &[T; N]

Returns a reference to the full underlying array.

pub fn as_full_array_mut(&mut self) -> &mut [T; N]

Returns a mutable reference to the full underlying array.

pub const fn split_at_section(&self) -> (&[T], &[T], &[T])

Splits the underlying array into three slices: the part before the section, the section, and the part after the section.

pub fn split_at_section_mut(&mut self) -> (&mut [T], &mut [T], &mut [T])

Splits the underlying array into three mutable slices: the part before the section, the section, and the part after the seciton.

pub fn into_full_array(self) -> [T; N]

Converts self into the full underlying array.

If you wish to use this in const context the destructor of T must be trivial, use into_full_array_const

pub const fn as_slice(&self) -> &[T]

Returns the section of the array as a slice.

pub fn as_slice_mut(&mut self) -> &mut [T]

Returns the section of the array as a mutable slice.

pub const fn len(&self) -> usize

Returns the length of the array section.

pub const fn is_empty(&self) -> bool

Returns whether the array section is empty.

pub const fn section_is_full_array(&self) -> bool

Returns whether the section is just the entire array. If this is true it is completely fine to call as_full_array or into_full_array.

pub fn iter(&self) -> ArraySectionIter<'_, T>

Returns an iterator over the array section.

pub fn iter_mut(&mut self) -> ArraySectionIterMut<'_, T>

Returns a mutable iterator over the array section.

pub fn into_vec(self) -> Vec<T>

Available on crate features alloc or std only.

Converts the array section into a vector.

Example

//                                     v  v  v
let section = ArraySection::new([0, 0, 1, 2, 3, 0, 0], 2..5);

assert_eq!(section.into_vec(), vec![1, 2, 3]);

pub fn into_boxed_slice(self) -> Box<[T]>

Available on crate features alloc or std only.

Converts the array section into a boxed slice.

Example

//                                     v  v  v
let section = ArraySection::new([0, 0, 1, 2, 3, 0, 0], 2..5);

assert_eq!(
    section.into_boxed_slice(),
    Box::new([1, 2, 3]) as Box<[i32]>
);

impl<T: Clone, const N: usize> ArraySection<T, N>

pub fn to_vec(&self) -> Vec<T>

Available on crate features alloc or std only.

Clones the contents of the array section into a vector.

pub fn to_boxed_slice(&self) -> Box<[T]>

Available on crate features alloc or std only.

Clones the contents of the array section into a boxed slice.

impl<T: Copy, const N: usize> ArraySection<T, N>

pub const fn into_full_array_const(self) -> [T; N]

Converts self into the full underlying array.

Trait Implementations

impl<const N: usize, T> AsRef<[T]> for ArraySection<T, N>

fn as_ref(&self) -> &[T]

Converts this type into a shared reference of the (usually inferred) input type.

impl<T: Clone, const N: usize> Clone for ArraySection<T, N>

fn clone(&self) -> ArraySection<T, N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug, const N: usize> Debug for ArraySection<T, N>

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

Formats the value using the given formatter.

impl<const N: usize, T> From<[T; N]> for ArraySection<T, N>

fn from(value: [T; N]) -> Self

Converts to this type from the input type.

impl<T: Clone, const N: usize> From<ArraySection<T, N>> for Box<[T]>

Available on crate features alloc or std only.

fn from(value: ArraySection<T, N>) -> Box<[T]>

Clones the contents of the section into a Boxed slice.

impl<T: Clone, const N: usize> From<ArraySection<T, N>> for Vec<T>

Available on crate features alloc or std only.

fn from(value: ArraySection<T, N>) -> Vec<T>

Clones the contents of the section into a Vec.

impl<T, const N: usize> From<TryFromArraySectionError<T, N>> for ArraySection<T, N>

fn from(value: TryFromArraySectionError<T, N>) -> Self

Converts to this type from the input type.

impl<const N: usize, T: Hash> Hash for ArraySection<T, N>

Only hashes the data in the section, and not the full array.

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<const N: usize, T, I: SliceIndex<[T]>> Index<I> for ArraySection<T, N>

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

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<'a, const N: usize, T> IntoIterator for &'a ArraySection<T, N>

type IntoIter = ArraySectionIter<'a, T>

Which kind of iterator are we turning this into?

type Item = <ArraySectionIter<'a, T> as Iterator>::Item

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, const N: usize, T> IntoIterator for &'a mut ArraySection<T, N>

type IntoIter = ArraySectionIter<'a, T>

Which kind of iterator are we turning this into?

type Item = <ArraySectionIter<'a, T> as Iterator>::Item

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<const N: usize, T> IntoIterator for ArraySection<T, N>

type IntoIter = ArraySectionIntoIter<T, N>

Which kind of iterator are we turning this into?

type Item = <ArraySectionIntoIter<T, N> as Iterator>::Item

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<const N: usize, T: Ord> Ord for ArraySection<T, N>

Only compares the data in the sections and not the full arrays.

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<const N: usize, const M: usize, T, U> PartialEq<[T; N]> for ArraySection<U, M>

where [U]: PartialEq<[T]>,

fn eq(&self, other: &[T; N]) -> 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<const N: usize, T, U> PartialEq<[U]> for ArraySection<T, N>

where U: PartialEq<T>,

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<const N: usize, T, U> PartialEq<ArraySection<T, N>> for [U]

where U: PartialEq<T>,

fn eq(&self, other: &ArraySection<T, N>) -> 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<const N: usize, const M: usize, T, U> PartialEq<ArraySection<T, N>> for ArraySection<U, M>

where [U]: PartialEq<[T]>,

fn eq(&self, other: &ArraySection<T, N>) -> 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<const N: usize, const M: usize, T, U> PartialEq<ArraySection<U, M>> for [T; N]

where [T]: PartialEq<[U]>,

fn eq(&self, other: &ArraySection<U, M>) -> 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<const N: usize, const M: usize, T: PartialOrd> PartialOrd<ArraySection<T, M>> for ArraySection<T, N>

Only checks the data in the sections, and not the full arrays.

fn partial_cmp(&self, other: &ArraySection<T, M>) -> 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<const N: usize, T> TryFrom<ArraySection<T, N>> for [T; N]

Converts the ArraySection into an array if the section is actually the entire array.

type Error = TryFromArraySectionError<T, N>

The type returned in the event of a conversion error.

fn try_from(value: ArraySection<T, N>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T: Copy, const N: usize> Copy for ArraySection<T, N>

impl<T: Eq, const N: usize> Eq for ArraySection<T, N>