Struct NonEmptyMutSlice

pub struct NonEmptyMutSlice<'a, T: Sized> { /* private fields */ }

A non-empty mutable slice type, counterpart of &mut [T].

Implementations

impl<'a, T: Sized> NonEmptyMutSlice<'a, T>

pub fn from_mut(e: &'a mut T) -> Self

Converts a &T into a NonEmptyMutSlice.

pub fn from_slice(slice: &'a mut [T]) -> Self

Converts a &[T] into a NonEmptyMutSlice.

Panics

This function will panic if the passed slice is empty.

pub fn from_slice_checked(slice: &'a mut [T]) -> Option<Self>

Converts a &[T] into a NonEmptyMutSlice. Returns None if the passed slice is empty.

pub fn as_ptr(&self) -> *const T

Returns a raw pointer to the slice’s buffer.

pub fn as_mut_ptr(&mut self) -> *mut T

Returns an unsafe mutable pointer to the slice’s buffer.

The caller must ensure that the slice outlives the pointer this function returns, or else it will end up pointing to garbage.

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

Returns a &[T] containing entire NonEmptyMutSlice.

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

Returns a mutable slice from this type.

pub fn len(&self) -> NonZeroUsize

Returns the number of elements in the slice.

pub fn is_empty(&self) -> bool

Always returns false because the slice is non-empty.

pub fn first(&self) -> &T

Returns the first element of the slice.

let arr = &mut [10, 40, 30];
let s = NonEmptyMutSlice::from_slice(arr);
assert_eq!(s.first(), &10);

pub fn first_mut(&mut self) -> &mut T

Returns a mutable pointer to the first element of the slice.

let arr = &mut [10, 40, 30];
let mut s = NonEmptyMutSlice::from_slice(arr);
*s.first_mut() = 42;
assert_eq!(arr, &[42, 40, 30]);

pub fn last(&self) -> &T

Returns the last element of the slice.

let arr = &mut [10, 40, 30];
let s = NonEmptyMutSlice::from_slice(arr);
assert_eq!(s.last(), &30);

pub fn last_mut(&mut self) -> &mut T

Returns the last element of the slice.

let arr = &mut [10, 40, 30];
let mut s = NonEmptyMutSlice::from_slice(arr);
*s.last_mut() = 42;
assert_eq!(arr, &[10, 40, 42]);

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

Returns the first and all the rest of the elements of the slice.

let arr = &mut [10, 40, 30];
let s = NonEmptyMutSlice::from_slice(arr);
assert_eq!(s.split_first(), (&10, &[40, 30][..]));

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

Returns the first and all the rest of the elements of the slice.

let arr = &mut [0, 1, 2];
let mut s = NonEmptyMutSlice::from_slice(arr);
let (first, rest) = s.split_first_mut();
*first = 3;
rest[0] = 4;
rest[1] = 5;
assert_eq!(arr, &[3, 4, 5]);

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

Returns the last and all the rest of the elements of the slice.

let arr = &mut [10, 40, 30];
let s = NonEmptyMutSlice::from_slice(arr);
assert_eq!(s.split_last(), (&30, &[10, 40][..]));

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

Returns the last and all the rest of the elements of the slice.

let arr = &mut [0, 1, 2];
let mut s = NonEmptyMutSlice::from_slice(arr);
let (last, rest) = s.split_last_mut();
*last = 3;
rest[0] = 4;
rest[1] = 5;
assert_eq!(arr, &[4, 5, 3]);

Trait Implementations

impl<'a, T> AsRef<[T]> for NonEmptyMutSlice<'a, T>

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

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

impl<'a, T: Ord> Ord for NonEmptyMutSlice<'a, T>

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<'a, T: PartialEq> PartialEq for NonEmptyMutSlice<'a, T>

fn eq(&self, other: &Self) -> 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<'a, T: PartialOrd> PartialOrd for NonEmptyMutSlice<'a, T>

fn partial_cmp(&self, other: &Self) -> 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<'a, T: Eq> Eq for NonEmptyMutSlice<'a, T>