[−][src]Struct tranche::Tranche

pub struct Tranche<'a, T> { /* fields omitted */ }

A tranche of T.

Tranches are like slices but represented of a start pointer and an end pointer. They are geared towards being mutably slicing from their start or end, and thus don't implement indexing.

Methods

`impl<'a, T> Tranche<'a, T>`[src]

`pub fn new(slice: &'a impl AsRef<[T]> + ?Sized) -> Self`[src]

Creates a new tranche of T.

Examples

let parisien = Tranche::new(&[
    "baguette",
    "jambon",
    "beurre",
]);

`pub fn len(&self) -> usize`[src]

Returns the number of elements in the tranche.

Examples

let a = Tranche::new(&[1, 2, 3]);
assert_eq!(a.len(), 3);

`pub fn is_empty(&self) -> bool`[src]

Returns true if the tranche has a length of 0.

Examples

let a = Tranche::new(&[1, 2, 3][..]);
assert!(!a.is_empty());

`pub fn take_first(&mut self) -> Result<&'a T, UnexpectedEndError>`[src]

Takes the first element out of the tranche.

Returns the first element of self, or Err(_) if it is empty.

Examples

let mut v = Tranche::new(&[10, 40, 30]);
assert_eq!(v.take_first().unwrap(), &10);
assert_eq!(v.as_slice(), &[40, 30]);

let mut w = <Tranche<i32>>::new(&[]);
let err = w.take_first().unwrap_err();
assert_eq!(err.needed(), 1);
assert_eq!(err.len(), 0);

`pub fn take_front(&mut self, n: usize) -> Result<Self, UnexpectedEndError>`[src]

Takes the first n elements out of the tranche.

Returns a new tranche with the first n elements of self, or Err(_) if it is not long enough.

Examples

let mut v = Tranche::new(&[10, 40, 30]);
assert_eq!(v.take_front(2).unwrap().as_slice(), &[10, 40]);
assert_eq!(v.as_slice(), &[30]);

let err = v.take_front(3).unwrap_err();
assert_eq!(err.needed(), 3);
assert_eq!(err.len(), 1);

`pub fn as_slice(&self) -> &'a [T]`[src]

Views the tranche's buffer as a slice.

This has the same lifetime as the original buffer, and so the tranche can continue to be used while this exists.

Examples

let mut tranche = Tranche::new(&[1, 2, 3]);
assert_eq!(tranche.as_slice(), &[1, 2, 3]);

assert!(tranche.take_first().is_ok());
assert_eq!(tranche.as_slice(), &[2, 3]);

`pub const fn as_ptr(&self) -> *const T`[src]

Returns a raw pointer to the tranche's buffer.

Examples

let tranche = Tranche::new(&[1, 2, 3]);
let ptr = tranche.as_ptr();

`impl<'a> Tranche<'a, u8>`[src]

`pub fn take_front_as<T>( &mut self, n: usize ) -> Result<Tranche<'a, T>, UnexpectedEndError> where T: AlwaysAligned + AlwaysValid + Immutable,` [src]

Takes the first n elements of type T out of the tranche.

Returns a new tranche with the first n elements of self viewed as a tranche of T values, or Err(_) if it is not long enough. The error details are expressed in terms of the size of T, not the size of u8.

Examples

let mut v = BufTranche::new(&[1, 2, 3, 4, 5, 6, 7, 8, 9]);
let four_pairs = v.take_front_as::<[u8; 2]>(4).unwrap();
assert_eq!(four_pairs.as_slice(), &[[1, 2], [3, 4], [5, 6], [7, 8]]);
assert_eq!(v.as_slice(), &[9]);

let err = v.take_front_as::<[u8; 2]>(1).unwrap_err();
assert_eq!(err.needed(), 1);
assert_eq!(err.len(), 0);