Struct holodeque::slice_deque::SliceDeque

pub struct SliceDeque<'a, T> where
    T: Default,  { /* fields omitted */ }

A double-ended queue with fixed capacity, backed by a slice.

The capacity of the deque is determined by the length of the slice.

Implementations

impl<'a, T> SliceDeque<'a, T> where
    T: Default, 

pub fn new_in(slice: &'a mut [T]) -> SliceDeque<'a, T>

Creates an empty SliceDeque backed by the provided slice.

The elements in the slice are dropped and replaced with the default value of T.

Example

let mut slice = ["these", "values", "will", "disappear"];
let mut deque = SliceDeque::new_in(&mut slice);

assert!(deque.is_empty());
assert_eq!(deque.capacity(), 4);

pub fn capacity(&self) -> usize

Returns the maximum number of elements the deque may hold.

This is the length of the backing slice.

Example

let mut slice = [(), (), (), ()];
let mut deque = SliceDeque::new_in(&mut slice);

assert_eq!(deque.capacity(), 4);

pub fn len(&self) -> usize

Returns the number of elements in the deque.

Example

let mut slice = [0, 0, 0];
let mut deque = SliceDeque::new_in(&mut slice);

assert_eq!(deque.len(), 0);
deque.push_back(1)?;
deque.push_back(2)?;
deque.push_back(3)?;
assert_eq!(deque.len(), 3);

pub fn is_empty(&self) -> bool

Returns true if the deque contains no elements.

Example

let mut slice = [0, 0, 0];
let mut deque = SliceDeque::new_in(&mut slice);

deque.push_back(42)?;
assert!(!deque.is_empty());
deque.pop_front();
assert!(deque.is_empty());

pub fn is_full(&self) -> bool

Returns true if the deque is at capacity.

Example

let mut slice = [0, 0, 0, 0];
let mut deque = SliceDeque::new_in(&mut slice);

deque.push_back(1)?;
deque.push_back(2)?;
deque.push_back(3)?;
assert!(!deque.is_full());

deque.push_back(4)?;
assert!(deque.is_full());

pub fn front(&self) -> Option<&T>

Returns a reference to the first element in the deque.

If the deque is empty, None is returned.

Example

let mut slice = ['\0', '\0', '\0'];
let mut deque = SliceDeque::new_in(&mut slice);

deque.push_back('a')?;
deque.push_back('b')?;
deque.push_back('c')?;

assert_eq!(deque.front(), Some(&'a'));

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

Returns a mutable reference to the first element in the deque.

If the deque is empty, None is returned.

Example

let mut slice = ["", "", "", ""];
let mut deque = SliceDeque::new_in(&mut slice);

deque.push_front("old")?;
deque.front_mut().map(|mut val| {
    *val = "new";
});

assert_eq!(deque.front(), Some(&"new"));

pub fn back(&self) -> Option<&T>

Returns a reference to the last element in the deque.

If the deque is empty, None is returned.

Example

let mut slice = ['\0', '\0', '\0'];
let mut deque = SliceDeque::new_in(&mut slice);

deque.push_back('a')?;
deque.push_back('b')?;
deque.push_back('c')?;

assert_eq!(deque.back(), Some(&'c'));

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

Returns a mutable reference to the last element in the deque.

If the deque is empty, None is returned.

Example

let mut slice = ["", "", "", ""];
let mut deque = SliceDeque::new_in(&mut slice);

deque.push_back("old")?;
deque.back_mut().map(|mut val| {
    *val = "new";
});

assert_eq!(deque.back(), Some(&"new"));

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

Returns a pair of slices which contain, in order, the elements of the SliceDeque.

Example

let mut slice = [0, 0, 0, 0, 0, 0];
let mut deque = SliceDeque::new_in(&mut slice);

deque.push_front(3)?;
deque.push_front(6)?;
deque.push_front(9)?;
deque.push_back(5)?;
deque.push_back(10)?;
deque.push_back(15)?;

let (first, second) = deque.as_slices();
assert_eq!(first, &[9, 6, 3]);
assert_eq!(second, &[5, 10, 15]);

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

Returns a pair of mutable slices which contain, in order, the elements of the SliceDeque.

Example

let mut slice = [0, 0, 0, 0, 0, 0];
let mut deque = SliceDeque::new_in(&mut slice);

deque.push_front(3)?;
deque.push_front(6)?;
deque.push_front(9)?;
deque.push_back(5)?;
deque.push_back(10)?;
deque.push_back(15)?;

let (first_mut, second_mut) = deque.as_mut_slices();
for item in first_mut {
    *item -= 1;
}
for item in second_mut {
    *item += 1;
}

let (first, second) = deque.as_slices();
assert_eq!(first, &[8, 5, 2]);
assert_eq!(second, &[6, 11, 16]);

pub fn push_front(&mut self, item: T) -> Result<(), CapacityError<T>>

Prepends an element to the deque.

If the deque is at capacity, an Err containing the pushed value is returned.

Example

let mut slice = [0, 0, 0];
let mut deque = SliceDeque::new_in(&mut slice);

deque.push_front(1)?;
deque.push_front(2)?;
deque.push_front(3)?;

assert_eq!(deque.front(), Some(&3));
assert_eq!(deque.back(), Some(&1));

// Another element would exceed capacity, so this fails.
let err = deque.push_front(4).unwrap_err();
assert_eq!(err.into_inner(), 4);

pub fn push_back(&mut self, item: T) -> Result<(), CapacityError<T>>

Appends an element to the deque.

If the deque is at capacity, an Err containing the pushed value is returned.

Example

let mut slice = [0, 0, 0];
let mut deque = SliceDeque::new_in(&mut slice);

deque.push_back(1)?;
deque.push_back(2)?;
deque.push_back(3)?;

assert_eq!(deque.front(), Some(&1));
assert_eq!(deque.back(), Some(&3));

// Another element would exceed capacity, so this fails.
let err = deque.push_back(4).unwrap_err();
assert_eq!(err.into_inner(), 4);

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

Removes and returns the first element of the deque.

If the deque is empty, None is returned.

Example

let mut slice = [0, 0, 0];
let mut deque = SliceDeque::new_in(&mut slice);

deque.push_back(1)?;
deque.push_back(2)?;
deque.push_back(3)?;

assert_eq!(deque.pop_front(), Some(1));
assert_eq!(deque.pop_front(), Some(2));
assert_eq!(deque.pop_front(), Some(3));
assert_eq!(deque.pop_front(), None);

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

Removes and returns the last element of the deque.

If the deque is empty, None is returned.

Example

let mut slice = [0, 0, 0];
let mut deque = SliceDeque::new_in(&mut slice);

deque.push_back(1)?;
deque.push_back(2)?;
deque.push_back(3)?;

assert_eq!(deque.pop_back(), Some(3));
assert_eq!(deque.pop_back(), Some(2));
assert_eq!(deque.pop_back(), Some(1));
assert_eq!(deque.pop_back(), None);

pub fn clear(&mut self)

Clears the SliceDeque, removing all values.

Example

let mut slice = [0, 0, 0, 0, 0, 0, 0, 0];
let mut deque = SliceDeque::new_in(&mut slice);

for i in 0..deque.capacity() / 2 {
    deque.push_front(i)?;
    deque.push_back(i)?;
}

assert_eq!(deque.len(), 8);
deque.clear();
assert!(deque.is_empty());

pub fn truncate(&mut self, len: usize)

Shortens the SliceDeque, keeping the first len elements and dropping the rest.

If len is greater than the SliceDeque’s current length, this has no effect.

Example

let mut slice = [0, 0, 0, 0, 0, 0, 0, 0];
let mut deque = SliceDeque::new_in(&mut slice);

deque.push_back(5)?;
deque.push_back(10)?;
deque.push_back(15)?;
deque.push_back(20)?;
deque.push_back(25)?;

assert_eq!(deque.len(), 5);
deque.truncate(2);
assert_eq!(deque.len(), 2);

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

Returns an iterator over the elements of the deque.

Example

let mut slice = ["", "", "", "", ""];
let mut deque = SliceDeque::new_in(&mut slice);

deque.push_back("ideas")?;
deque.push_front("green")?;
deque.push_back("sleep")?;
deque.push_front("colorless")?;
deque.push_back("furiously")?;

let sentence = deque.iter().cloned().collect::<Vec<_>>();

assert_eq!(
    sentence,
    &["colorless", "green", "ideas", "sleep", "furiously"],
);

pub fn drain_front(&mut self, n: usize) -> Option<DrainFront<'_, 'a, T>>

Drains n elements from the front of the deque.

If n exceeds self.len(), None is returned.

When this method is called, n elements are immediately removed from the front of the deque. If the returned iterator is dropped before yielding all its items, they are dropped along with it.

If the returned iterator is leaked (e.g. with mem::forget), the drained elements will not be dropped immediately. They may be dropped as a result of subsequent operations on the deque; otherwise, they will be dropped when the deque itself is dropped.

Example

let mut slice = [0, 0, 0, 0, 0];
let mut deque = SliceDeque::new_in(&mut slice);

deque.push_back(0)?;
deque.push_back(1)?;
deque.push_back(2)?;
deque.push_back(3)?;
deque.push_back(4)?;

let mut drain = deque.drain_front(3).unwrap();

assert_eq!(drain.next(), Some(0));
assert_eq!(drain.next(), Some(1));
assert_eq!(drain.next(), Some(2));
assert_eq!(drain.next(), None);
drop(drain);

assert_eq!(deque.len(), 2);

pub fn drain_back(&mut self, n: usize) -> Option<DrainBack<'_, 'a, T>>

Drains n elements from the back of the deque.

If n exceeds self.len(), None is returned.

When this method is called, n elements are immediately removed from the back of the deque. If the returned iterator is dropped before yielding all its items, they are dropped along with it.

If the returned iterator is leaked (e.g. with mem::forget), the drained elements will not be dropped immediately. They may be dropped as a result of subsequent operations on the deque; otherwise, they will be dropped when the deque itself is dropped.

Example

let mut slice = [0, 0, 0, 0, 0];
let mut deque = SliceDeque::new_in(&mut slice);

deque.push_back(0)?;
deque.push_back(1)?;
deque.push_back(2)?;
deque.push_back(3)?;
deque.push_back(4)?;

let mut drain = deque.drain_back(3).unwrap();

assert_eq!(drain.next(), Some(4));
assert_eq!(drain.next(), Some(3));
assert_eq!(drain.next(), Some(2));
assert_eq!(drain.next(), None);
drop(drain);

assert_eq!(deque.len(), 2);

impl<'a, 'de, T> SliceDeque<'a, T> where
    T: Deserialize<'de> + Default, 

pub fn extend_deserialize<D>(&mut self, deserializer: D) -> Result<(), D::Error> where
    D: Deserializer<'de>, 

Extends the deque with the contents of a deserializer.

Trait Implementations

impl<'a, T: Debug> Debug for SliceDeque<'a, T> where
    T: Default, 

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

Formats the value using the given formatter.

impl<'a, T> Serialize for SliceDeque<'a, T> where
    T: Serialize + Default, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.