Struct futures_intrusive::buffer::ArrayRingBuf

pub struct ArrayRingBuf<T, A> where
    A: AsMut<[T]> + AsRef<[T]> + RealArray<T>,  { /* fields omitted */ }

An array-backed Ring Buffer

A is the type of the backing array. The backing array must be a real array. In order to verify this it must satisfy the RealArray constraint. In order to create a Ring Buffer backed by an array of 5 integer elements, the following code can be utilized:

use futures_intrusive::buffer::{ArrayRingBuf, RingBuf};

type Buffer5 = ArrayRingBuf<i32, [i32; 5]>;
let buffer = Buffer5::new();

Trait Implementations

impl<T, A> RingBuf for ArrayRingBuf<T, A> where
    A: AsMut<[T]> + AsRef<[T]> + RealArray<T>, 

type Item = T

The type of stored items inside the Ring Buffer

fn new() -> Self

Creates a new instance of the Ring Buffer

fn with_capacity(_cap: usize) -> Self

Creates a new instance of the Ring Buffer with the given capacity. RingBuf implementations are allowed to ignore the capacity hint and utilize their default capacity.

fn capacity(&self) -> usize

The capacity of the buffer

fn len(&self) -> usize

The amount of stored items in the buffer

fn can_push(&self) -> bool

Returns true if there is enough space in the buffer to store another item.

fn push(&mut self, value: Self::Item)

Stores the item at the end of the buffer. Panics if there is not enough free space.

fn pop(&mut self) -> Self::Item

Returns the oldest item inside the buffer. Panics if there is no available item.

fn is_empty(&self) -> bool

Returns true if no item is stored inside the buffer.

impl<T, A> Drop for ArrayRingBuf<T, A> where
    A: AsMut<[T]> + AsRef<[T]> + RealArray<T>, 

fn drop(&mut self)

Executes the destructor for this type.

impl<T, A> Debug for ArrayRingBuf<T, A> where
    A: AsMut<[T]> + AsRef<[T]> + RealArray<T>, 

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

Formats the value using the given formatter.