Struct swap_buffer_queue::buffer::BufferSlice

pub struct BufferSlice<'a, B, N>where
    B: Buffer,{ /* private fields */ }

Buffer slice returned by Queue::try_dequeue (see Buffer::Slice).

Buffer is released when the slice is dropped, so the other buffer will be dequeued next, unless BufferSlice::requeue/BufferSlice::into_iter is called.

Examples

let queue: Queue<VecBuffer<usize>> = Queue::with_capacity(42);
queue.try_enqueue(0).unwrap();
queue.try_enqueue(1).unwrap();

let slice = queue.try_dequeue().unwrap();
assert_eq!(slice.deref(), &[0, 1]);
assert_eq!(slice.into_iter().collect::<Vec<_>>(), vec![0, 1]);

Implementations

impl<'a, B, N> BufferSlice<'a, B, N>where B: Buffer,

pub fn requeue(self)

Reinsert the buffer at the beginning queue.

It will thus de dequeued again next.

Examples

let queue: Queue<VecBuffer<usize>> = Queue::with_capacity(42);
queue.try_enqueue(0).unwrap();
queue.try_enqueue(1).unwrap();

let slice = queue.try_dequeue().unwrap();
assert_eq!(slice.deref(), &[0, 1]);
slice.requeue();
let slice = queue.try_dequeue().unwrap();
assert_eq!(slice.deref(), &[0, 1]);

Trait Implementations

impl<'a, B, N> Debug for BufferSlice<'a, B, N>where B: Buffer, B::Slice<'a>: Debug,

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

Formats the value using the given formatter.

impl<'a, B, N> Deref for BufferSlice<'a, B, N>where B: Buffer,

type Target = <B as Buffer>::Slice<'a>

The resulting type after dereferencing.

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

Dereferences the value.

impl<'a, B, N> DerefMut for BufferSlice<'a, B, N>where B: Buffer,

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

Mutably dereferences the value.

impl<'a, B, N> Drop for BufferSlice<'a, B, N>where B: Buffer,

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, B, N> IntoIterator for BufferSlice<'a, B, N>where B: Buffer + Drain,

type Item = <B as Drain>::Value

The type of the elements being iterated over.

type IntoIter = BufferIter<&'a Queue<B, N>, B, N>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.