Struct array_section::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 indices 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 const fn try_as_full_array(&self) -> Option<&[T; N]>

Returns a 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 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 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.

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 copy 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, 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<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 + PartialOrd,

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

This method tests for self and other values to be equal, and is used by ==.

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

This method 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

This method tests for self and other values to be equal, and is used by ==.

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

This method 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

This method tests for self and other values to be equal, and is used by ==.

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

This method 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

This method tests for self and other values to be equal, and is used by ==.

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

This method 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

This method tests for self and other values to be equal, and is used by ==.

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

This method 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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method 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>