Struct RevSlice

pub struct RevSlice<T>(/* private fields */);

A reversed view of a slice.

The RevSlice is a random accessible range of elements; it wraps a regular slice but presents the underlying elements in reverse order.

Example

use odds::slice::RevSlice;

let mut data = [0; 8];

{
    let mut rev = <&mut RevSlice<_>>::from(&mut data);
    for (i, elt) in rev.iter_mut().enumerate() {
        *elt = i;
    }

    assert_eq!(&rev[..4], &[0, 1, 2, 3][..]);
}
assert_eq!(&data, &[7, 6, 5, 4, 3, 2, 1, 0]);

Not visible in rustdoc:

• A boxed slice can be reversed too: impl<T> From<Box<[T]>> for Box<RevSlice<T>>.

Implementations

impl<T> RevSlice<T>

pub fn len(&self) -> usize

Return the length of the slice.

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

Get element at index i.

See also indexing notation: &foo[i].

pub fn get_mut(&mut self, i: usize) -> Option<&mut T>

Get element at index i.

See also indexing notation: &mut foo[i].

pub fn inner_ref(&self) -> &[T]

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

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

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

Return a by-reference iterator

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

Return a by-mutable-reference iterator

pub fn split_at(&self, i: usize) -> (&Self, &Self)

pub fn split_at_mut(&mut self, i: usize) -> (&mut Self, &mut Self)

Trait Implementations

impl<T: Debug> Debug for RevSlice<T>

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

Formats the value using the given formatter.

impl<'a, T> Default for &'a RevSlice<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'a, T> Default for &'a mut RevSlice<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'a, T, Slice> From<&'a Slice> for &'a RevSlice<T>

where Slice: AsRef<[T]> + ?Sized,

fn from(slc: &'a Slice) -> Self

Converts to this type from the input type.

impl<'a, T, Slice> From<&'a mut Slice> for &'a mut RevSlice<T>

where Slice: AsMut<[T]> + ?Sized,

fn from(slc: &'a mut Slice) -> Self

Converts to this type from the input type.

impl<T> From<Box<[T]>> for Box<RevSlice<T>>

fn from(slc: Box<[T]>) -> Self

Converts to this type from the input type.

impl<T> Hash for RevSlice<T>

where T: Hash,

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

Feeds this value into the given Hasher.

impl<T, R> Index<R> for RevSlice<T>

where R: IndexRange,

type Output = RevSlice<T>

The returned type after indexing.

fn index(&self, index: R) -> &RevSlice<T>

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for RevSlice<T>

type Output = T

The returned type after indexing.

fn index(&self, i: usize) -> &T

Performs the indexing (container[index]) operation.

impl<T, R> IndexMut<R> for RevSlice<T>

where R: IndexRange,

fn index_mut(&mut self, index: R) -> &mut RevSlice<T>

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

impl<T> IndexMut<usize> for RevSlice<T>

fn index_mut(&mut self, i: usize) -> &mut T

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

impl<'a, T> IntoIterator for &'a RevSlice<T>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Rev<Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut RevSlice<T>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = Rev<IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, U> PartialEq<[U]> for RevSlice<T>

where T: PartialEq<U>,

RevSlice compares by logical element sequence.

fn eq(&self, rhs: &[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<T, U> PartialEq<RevSlice<U>> for RevSlice<T>

where T: PartialEq<U>,

fn eq(&self, rhs: &RevSlice<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<T> SliceFind for RevSlice<T>

type Item = T

fn find<U: ?Sized>(&self, elt: &U) -> Option<usize>

where Self::Item: PartialEq<U>,

Linear search for the first occurrence elt in the slice.

fn rfind<U: ?Sized>(&self, elt: &U) -> Option<usize>

where Self::Item: PartialEq<U>,

Linear search for the last occurrence elt in the slice.

impl<T: Eq> Eq for RevSlice<T>