Struct matrix_sdk::ring_buffer::RingBuffer

pub struct RingBuffer<T> { /* private fields */ }

A simple fixed-size ring buffer implementation.

A size is provided on creation, and the ring buffer reserves that much space, and never reallocates.

Implementations

impl<T> RingBuffer<T>

pub fn new(size: NonZero<usize>) -> RingBuffer<T>

Create a ring buffer with the supplied capacity, reserving it so we never need to reallocate.

pub fn len(&self) -> usize

Returns the number of items that are stored in this ring buffer.

This is the dynamic size indicating how many items are held in the buffer, not the fixed capacity.

pub fn is_empty(&self) -> bool

Returns true if the ring buffer contains no elements.

pub fn get(&self, index: usize) -> Option<&T>

Provides a reference to the element at the given index.

Element at index zero is the “front” i.e. one that will be returned if we call pop().

pub fn push(&mut self, value: T)

Appends an element to the back of the ring buffer

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

Removes the first element and returns it, or None if the ring buffer is empty.

pub fn remove(&mut self, index: usize) -> Option<T>

Removes and returns one specific element at index if it exists, otherwise it returns None.

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

Returns an iterator that provides elements in front-to-back order, i.e. the same order you would get if you repeatedly called pop().

pub fn drain<R>(&mut self, range: R) -> Drain<'_, T>

where R: RangeBounds<usize>,

Returns an iterator that drains its items.

pub fn clear(&mut self)

Clears the ring buffer, removing all values. This does not affect the capacity.

pub fn capacity(&self) -> usize

Returns the total number of elements the RingBuffer can hold.

pub fn retain<F>(&mut self, predicate: F)

where F: FnMut(&T) -> bool,

Retains only the elements specified by the predicate.

Trait Implementations

impl<T> Clone for RingBuffer<T>

where T: Clone,

fn clone(&self) -> RingBuffer<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Debug for RingBuffer<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for RingBuffer<T>

where T: Deserialize<'de>,

fn deserialize<__D>( __deserializer: __D ) -> Result<RingBuffer<T>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<U> Extend<U> for RingBuffer<U>

fn extend<T>(&mut self, iter: T)

where T: IntoIterator<Item = U>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<T> PartialEq for RingBuffer<T>

where T: PartialEq,

fn eq(&self, other: &RingBuffer<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Serialize for RingBuffer<T>

where T: Serialize,

fn serialize<__S>( &self, __serializer: __S ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> StructuralPartialEq for RingBuffer<T>