Struct futures_intrusive::buffer::GrowingHeapBuf

pub struct GrowingHeapBuf<T> { /* fields omitted */ }

A Ring Buffer which stores all items on the heap but grows dynamically.

A GrowingHeapBuf does not allocate the capacity ahead of time, as opposed to the FixedHeapBuf. This makes it a good fit when you have unpredictable latency between two components, when you want to amortize your allocation costs or when you are using an external back-pressure mechanism.

Trait Implementations

impl<T> Debug for GrowingHeapBuf<T>

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

Formats the value using the given formatter.

impl<T> RingBuf for GrowingHeapBuf<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(limit: 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.