Struct loaf::LoafVec

#[repr(transparent)]pub struct LoafVec<T> { /* fields omitted */ }

Implementations

impl<T> LoafVec<T>

pub fn from_vec(vec: Vec<T>) -> Result<Self, Vec<T>>

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

pub fn as_loaf(&self) -> &Loaf<T>

pub fn as_mut_loaf(&mut self) -> &mut Loaf<T>

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

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

pub fn pop(&mut self) -> Option<T>

pub fn into_boxed_loaf(self) -> Box<Loaf<T>>

Methods from Deref<Target = Loaf<T>>

pub fn len(&self) -> usize

Returns length of the underlying slice

let slice = &[0u8, 1, 2, 3, 4];
let loaf = Loaf::from_slice(slice).unwrap();
assert_eq!(loaf.len(), slice.len());

pub fn first(&self) -> &T

Returns a reference to the first element

let slice = &[0u8, 1, 2, 3, 4];
let loaf = Loaf::from_slice(slice).unwrap();
assert_eq!(*loaf.first(), 0);

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

Returns a mutable reference to the first element

let slice = &mut [0u8, 1, 2, 3, 4];
let loaf = Loaf::from_slice_mut(slice).unwrap();
*loaf.first_mut() = 42;
assert_eq!(*loaf.first(), 42);

pub fn last(&self) -> &T

Returns a reference to the last element

let slice = &[0u8, 1, 2, 3, 4];
let loaf = Loaf::from_slice(slice).unwrap();
assert_eq!(*loaf.last(), 4);

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

Returns a mutable reference to the last element

let slice = &mut [0u8, 1, 2, 3, 4];
let loaf = Loaf::from_slice_mut(slice).unwrap();
*loaf.last_mut() = 42;
assert_eq!(*loaf.last(), 42);

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

Returns a reference to the first element and the rest of slice

let slice = &[0u8, 1, 2, 3, 4];
let loaf = Loaf::from_slice(slice).unwrap();
let (first, rest) = loaf.split_first();
assert_eq!(*first, 0);
assert_eq!(rest, &[1, 2, 3, 4]);

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

Returns a mutable reference to the first element and the rest of slice

let slice = &mut [0u8, 1, 2, 3, 4];
let loaf = Loaf::from_slice_mut(slice).unwrap();
let (first, rest) = loaf.split_first_mut();
*first = 40;
rest[0] = 41;
// slice[0] = 0; // this line does not compile, because slice is borrowed mutably
assert_eq!(*first, 40);
assert_eq!(rest, &[41, 2, 3, 4]);

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

Casts &Loaf<T> into &[T]

let slice = &[0u8, 1, 2, 3, 4];
let loaf = Loaf::from_slice(slice).unwrap();
assert_eq!(loaf.as_slice(), &[0u8, 1, 2, 3, 4]);

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

Casts &mut Loaf<T> into &mut [T]

let slice = &mut [0u8, 1, 2, 3, 4];
let loaf = Loaf::from_slice_mut(slice).unwrap();
loaf.loaf[0] = 42;
loaf.rest[3] = 14;
assert_eq!(loaf.as_slice(), &[42u8, 1, 2, 3, 14]);

Trait Implementations

impl<T: Clone> Clone for LoafVec<T>

fn clone(&self) -> LoafVec<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Deref for LoafVec<T>

type Target = Loaf<T>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T> DerefMut for LoafVec<T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.