Struct sized_chunks::ring_buffer::RingBuffer

pub struct RingBuffer<A, N = U64> where
    N: ChunkLength<A>,  { /* fields omitted */ }

Methods

impl<A, N> RingBuffer<A, N> where
    N: ChunkLength<A>, 

pub const CAPACITY: usize

#[must_use]

pub fn new() -> Self

Construct an empty ring buffer.

#[must_use]

pub fn unit(value: A) -> Self

Construct a ring buffer with a single item.

#[must_use]

pub fn pair(value1: A, value2: A) -> Self

Construct a ring buffer with two items.

#[must_use]

pub fn drain_from(other: &mut Self) -> Self

Construct a new ring buffer and move every item from other into the new buffer.

Time: O(n)

#[must_use]

pub fn collect_from<I>(iter: &mut I, count: usize) -> Self where
    I: Iterator<Item = A>, 

Construct a new ring buffer and populate it by taking count items from the iterator iter.

Panics if the iterator contains less than count items.

Time: O(n)

#[must_use]

pub fn from_front(other: &mut Self, count: usize) -> Self

Construct a new ring buffer and populate it by taking count items from the front of other.

Time: O(n) for the number of items moved

#[must_use]

pub fn from_back(other: &mut Self, count: usize) -> Self

Construct a new ring buffer and populate it by taking count items from the back of other.

Time: O(n) for the number of items moved

#[must_use]

pub fn len(&self) -> usize

Get the length of the ring buffer.

#[must_use]

pub fn is_empty(&self) -> bool

Test if the ring buffer is empty.

#[must_use]

pub fn is_full(&self) -> bool

Test if the ring buffer is full.

Important traits for Iter<'a, A, N>

impl<'a, A, N> Iterator for Iter<'a, A, N> where
    N: ChunkLength<A>,  type Item = &'a A;

#[must_use]

pub fn iter(&self) -> Iter<A, N>

Important traits for IterMut<'a, A, N>

impl<'a, A, N> Iterator for IterMut<'a, A, N> where
    N: ChunkLength<A>,  type Item = &'a mut A;

#[must_use]

pub fn iter_mut(&mut self) -> IterMut<A, N>

#[must_use]

pub fn slice<R: RangeBounds<usize>>(&self, range: R) -> Slice<A, N>

#[must_use]

pub fn slice_mut<R: RangeBounds<usize>>(&mut self, range: R) -> SliceMut<A, N>

#[must_use]

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

Get the value at a given index.

#[must_use]

pub fn get_mut(&mut self, index: usize) -> Option<&mut A>

Get a mutable reference to the value at a given index.

#[must_use]

pub fn first(&self) -> Option<&A>

Get the first value in the buffer.

#[must_use]

pub fn first_mut(&mut self) -> Option<&mut A>

Get a mutable reference to the first value in the buffer.

#[must_use]

pub fn last(&self) -> Option<&A>

Get the last value in the buffer.

#[must_use]

pub fn last_mut(&mut self) -> Option<&mut A>

Get a mutable reference to the last value in the buffer.

pub fn push_back(&mut self, value: A)

Push a value to the back of the buffer.

Panics if the capacity of the buffer is exceeded.

Time: O(1)

pub fn push_front(&mut self, value: A)

Push a value to the front of the buffer.

Panics if the capacity of the buffer is exceeded.

Time: O(1)

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

Pop a value from the back of the buffer.

Returns None if the buffer is empty.

Time: O(1)

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

Pop a value from the front of the buffer.

Returns None if the buffer is empty.

Time: O(1)

pub fn drop_left(&mut self, index: usize)

Discard all items up to but not including index.

Panics if index is out of bounds.

Time: O(n) for the number of items dropped

pub fn drop_right(&mut self, index: usize)

Discard all items from index onward.

Panics if index is out of bounds.

Time: O(n) for the number of items dropped

#[must_use]

pub fn split_off(&mut self, index: usize) -> Self

Split a buffer into two, the original buffer containing everything up to index and the returned buffer containing everything from index onwards.

Panics if index is out of bounds.

Time: O(n) for the number of items in the new buffer

pub fn append(&mut self, other: &mut Self)

Remove all items from other and append them to the back of self.

Panics if the capacity of self is exceeded.

other will be an empty buffer after this operation.

Time: O(n) for the number of items moved

pub fn drain_from_front(&mut self, other: &mut Self, count: usize)

Remove count items from the front of other and append them to the back of self.

Panics if self doesn't have count items left, or if other has fewer than count items.

Time: O(n) for the number of items moved

pub fn drain_from_back(&mut self, other: &mut Self, count: usize)

Remove count items from the back of other and append them to the front of self.

Panics if self doesn't have count items left, or if other has fewer than count items.

Time: O(n) for the number of items moved

pub fn set(&mut self, index: usize, value: A) -> A

Update the value at index index, returning the old value.

Panics if index is out of bounds.

Time: O(1)

pub fn insert(&mut self, index: usize, value: A)

Insert a new value at index index, shifting all the following values to the right.

Panics if the index is out of bounds.

Time: O(n) for the number of items shifted

pub fn remove(&mut self, index: usize) -> A

Remove the value at index index, shifting all the following values to the left.

Returns the removed value.

Panics if the index is out of bounds.

Time: O(n) for the number of items shifted

Important traits for Drain<'a, A, N>

impl<'a, A: 'a, N: ChunkLength<A> + 'a> Iterator for Drain<'a, A, N> type Item = A;

pub fn drain(&mut self) -> Drain<A, N>

Construct an iterator that drains values from the front of the buffer.

pub fn clear(&mut self)

Discard the contents of the buffer.

Time: O(n)

Trait Implementations

impl<A: Clone, N: ChunkLength<A>> Clone for RingBuffer<A, N>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: PartialEq, N: ChunkLength<A>> PartialEq<RingBuffer<A, N>> for RingBuffer<A, N>

#[must_use]

fn eq(&self, other: &Self) -> bool

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

#[must_use]

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

This method tests for !=.

impl<A, N, Slice> PartialEq<Slice> for RingBuffer<A, N> where
    Slice: Borrow<[A]>,
    A: PartialEq,
    N: ChunkLength<A>, 

#[must_use]

fn eq(&self, other: &Slice) -> bool

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

#[must_use]

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

This method tests for !=.

impl<A: PartialOrd, N: ChunkLength<A>> PartialOrd<RingBuffer<A, N>> for RingBuffer<A, N>

#[must_use]

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]

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

This method tests less than (for self and other) and is used by the < operator.

#[must_use]

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]

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

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<A: Eq, N: ChunkLength<A>> Eq for RingBuffer<A, N>

impl<A, N: ChunkLength<A>> Extend<A> for RingBuffer<A, N>

fn extend<I: IntoIterator<Item = A>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

impl<'a, A: Clone + 'a, N: ChunkLength<A>> Extend<&'a A> for RingBuffer<A, N>

fn extend<I: IntoIterator<Item = &'a A>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

impl<A, N: ChunkLength<A>> Default for RingBuffer<A, N>

#[must_use]

fn default() -> Self

Returns the "default value" for a type.

impl<A, N: ChunkLength<A>> Drop for RingBuffer<A, N>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, A: 'a, N: ChunkLength<A> + 'a> From<&'a RingBuffer<A, N>> for Slice<'a, A, N>

#[must_use]

fn from(buffer: &'a RingBuffer<A, N>) -> Self

Performs the conversion.

impl<'a, A: 'a, N: ChunkLength<A> + 'a> From<&'a mut RingBuffer<A, N>> for SliceMut<'a, A, N>

#[must_use]

fn from(buffer: &'a mut RingBuffer<A, N>) -> Self

Performs the conversion.

impl<A: Ord, N: ChunkLength<A>> Ord for RingBuffer<A, N>

#[must_use]

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

default fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

default fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

default fn clamp(self, min: Self, max: Self) -> Self

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

Restrict a value to a certain interval.

impl<A, N: ChunkLength<A>> IntoIterator for RingBuffer<A, N>

type Item = A

The type of the elements being iterated over.

type IntoIter = OwnedIter<A, N>

Which kind of iterator are we turning this into?

#[must_use]

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, A, N: ChunkLength<A>> IntoIterator for &'a RingBuffer<A, N>

type Item = &'a A

The type of the elements being iterated over.

type IntoIter = Iter<'a, A, N>

Which kind of iterator are we turning this into?

#[must_use]

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, A, N: ChunkLength<A>> IntoIterator for &'a mut RingBuffer<A, N>

type Item = &'a mut A

The type of the elements being iterated over.

type IntoIter = IterMut<'a, A, N>

Which kind of iterator are we turning this into?

#[must_use]

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<A: Hash, N: ChunkLength<A>> Hash for RingBuffer<A, N>

fn hash<H: Hasher>(&self, hasher: &mut H)

Feeds this value into the given [Hasher].

default fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<A, N> Index<usize> for RingBuffer<A, N> where
    N: ChunkLength<A>, 

type Output = A

The returned type after indexing.

#[must_use]

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<A, N> IndexMut<usize> for RingBuffer<A, N> where
    N: ChunkLength<A>, 

#[must_use]

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<A, N: ChunkLength<A>> FromIterator<A> for RingBuffer<A, N>

#[must_use]

fn from_iter<I: IntoIterator<Item = A>>(iter: I) -> Self

Creates a value from an iterator.

impl<A: Debug, N: ChunkLength<A>> Debug for RingBuffer<A, N>

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

Formats the value using the given formatter.

impl<N: ChunkLength<u8>> Write for RingBuffer<u8, N>

fn write(&mut self, buf: &[u8]) -> Result<usize>

Write a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> Result<()>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

default fn write_vectored(&mut self, bufs: &[IoVec]) -> Result<usize, Error>

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

Like write, except that it writes from a slice of buffers.

default fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

default fn write_fmt(&mut self, fmt: Arguments) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

default fn by_ref(&mut self) -> &mut Self

Creates a "by reference" adaptor for this instance of Write.