Trait slice_utils::SliceOwned

pub trait SliceOwned: Slice {
    // Required method
    fn get_owned(&self, index: usize) -> Option<Self::Output>;

    // Provided methods
    fn array_chunks<const N: usize>(self) -> ArrayChunksOwned<Self, N> 
       where Self: Sized { ... }
    fn array_windows<const N: usize>(self) -> ArrayWindowsOwned<Self, N> 
       where Self: Sized { ... }
    fn chunks(&self, size: usize) -> ChunksOwned<'_, Self>  { ... }
    fn map<F: Fn(Self::Output) -> R, R>(self, f: F) -> MapOwned<Self, F>
       where Self: Sized { ... }
    fn iter(self) -> IterOwned<Self> 
       where Self: Sized { ... }
    fn windows(&self, size: usize) -> WindowsOwned<'_, Self>  { ... }
}

A Slice that can return owned values.

Required Methods

fn get_owned(&self, index: usize) -> Option<Self::Output>

Index the slice, returning an owned value.

Provided Methods

fn array_chunks<const N: usize>(self) -> ArrayChunksOwned<Self, N>

where Self: Sized,

Return an iterator over arrays covering consecutive portions of the slice.

Analagous to slice::array_chunks.

Panics

If N == 0, panics.

Examples

let slice = [1, 2, 3, 4, 5];
let mut iter = slice.array_chunks::<2>();

assert_eq!(iter.next(), Some([1, 2]));
assert_eq!(iter.next(), Some([3, 4]));
assert!(iter.next().is_none());
assert_eq!(iter.remainder(), [5]);

fn array_windows<const N: usize>(self) -> ArrayWindowsOwned<Self, N>

where Self: Sized,

Return an iterator over arrays covering overlapping portions of the slice.

Analagous to slice::array_windows.

Panics

If N == 0, panics.

Examples

let slice = [1, 2, 3, 4, 5];
let mut iter = slice.array_windows::<3>();

assert_eq!(iter.next(), Some([1, 2, 3]));
assert_eq!(iter.next(), Some([2, 3, 4]));
assert_eq!(iter.next(), Some([3, 4, 5]));
assert!(iter.next().is_none());

fn chunks(&self, size: usize) -> ChunksOwned<'_, Self>

Return an iterator over slices covering consecutive portions of the slice.

Analagous to slice::chunks.

Panics

If size == 0, panics.

Examples

let slice = [1, 2, 3, 4, 5];
let mut iter = slice.chunks(2);

assert_eq!(iter.next().unwrap(), [1, 2]);
assert_eq!(iter.next().unwrap(), [3, 4]);
assert_eq!(iter.next().unwrap(), [5]);
assert!(iter.next().is_none());

fn map<F: Fn(Self::Output) -> R, R>(self, f: F) -> MapOwned<Self, F>

where Self: Sized,

Call a closure on index, returning a new type.

Analagous to Iterator::map.

Examples

let slice = [0, 1, 2].map(|x| x != 0);
assert_eq!(slice, [false, true, true]);

fn iter(self) -> IterOwned<Self>

where Self: Sized,

Creates an iterator over the slice.

Examples

let slice = [1, 2].chain([3]);
let mut iter = slice.iter();
assert_eq!(iter.next(), Some(1));
assert_eq!(iter.next(), Some(2));
assert_eq!(iter.next(), Some(3));
assert!(iter.next().is_none());

fn windows(&self, size: usize) -> WindowsOwned<'_, Self>

Return an iterator over slices covering overlapping portions of the slice. The last window may be smaller than the rest.

Analagous to slice::windows.

Panics

If size == 0, panics.

Examples

let slice = [1, 2, 3, 4, 5];
let mut iter = slice.windows(3);

assert_eq!(iter.next().unwrap(), [1, 2, 3]);
assert_eq!(iter.next().unwrap(), [2, 3, 4]);
assert_eq!(iter.next().unwrap(), [3, 4, 5]);
assert!(iter.next().is_none());

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl<'a, S> SliceOwned for &'a S

where S: SliceOwned + ?Sized,

fn get_owned(&self, index: usize) -> Option<Self::Output>

impl<'a, S> SliceOwned for &'a mut S

where S: SliceOwned + ?Sized,

fn get_owned(&self, index: usize) -> Option<Self::Output>

impl<T> SliceOwned for [T]

where T: Copy,

fn get_owned(&self, index: usize) -> Option<Self::Output>

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

where T: Copy,

fn get_owned(&self, index: usize) -> Option<Self::Output>

Implementors

impl<A> SliceOwned for SliceOf<A>

where A: SliceOwned,

impl<S1, S2> SliceOwned for Chain<S1, S2>

where S1: SliceOwned, S2: SliceOwned<Output = S1::Output>,

impl<S1, S2> SliceOwned for Interleave<S1, S2>

where S1: SliceOwned, S2: SliceOwned<Output = S1::Output>,

impl<S> SliceOwned for Cycle<S>

where S: SliceOwned,

impl<S> SliceOwned for Reverse<S>

where S: SliceOwned,

impl<S, F, U> SliceOwned for MapBorrowed<S, F>

where S: SliceBorrowed, F: Fn(&S::Output) -> U,

impl<S, F, U> SliceOwned for MapOwned<S, F>

where S: SliceOwned, F: Fn(S::Output) -> U,