[][src]Struct sized_chunks::ring_buffer::RingBuffer

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

A fixed capacity ring buffer.

A ring buffer is an array where the first logical index is at some arbitrary location inside the array, and the indices wrap around to the start of the array once they overflow its bounds.

This gives us the ability to push to either the front or the end of the array in constant time, at the cost of losing the ability to get a single contiguous slice reference to the contents.

It differs from the Chunk in that the latter will have mostly constant time pushes, but may occasionally need to shift its contents around to make room. They both have constant time pop, and they both have linear time insert and remove.

The RingBuffer offers its own Slice and SliceMut types to compensate for the loss of being able to take a slice, but they're somewhat less efficient, so the general rule should be that you shouldn't choose a RingBuffer if you really need to take slices - but if you don't, it's probably a marginally better choice overall than Chunk.

Methods

impl<A, N> RingBuffer<A, N> where
    N: ChunkLength<A>, 
[src]

pub const CAPACITY: usize[src]

The capacity of this ring buffer, as a usize.

#[must_use] pub fn new() -> Self[src]

Construct an empty ring buffer.

#[must_use] pub fn unit(value: A) -> Self[src]

Construct a ring buffer with a single item.

#[must_use] pub fn pair(value1: A, value2: A) -> Self[src]

Construct a ring buffer with two items.

#[must_use] pub fn drain_from(other: &mut Self) -> Self[src]

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>, 
[src]

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[src]

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[src]

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[src]

Get the length of the ring buffer.

#[must_use] pub fn is_empty(&self) -> bool[src]

Test if the ring buffer is empty.

#[must_use] pub fn is_full(&self) -> bool[src]

Test if the ring buffer is full.

#[must_use] pub fn iter(&self) -> Iter<A, N>[src]

Get an iterator over references to the items in the ring buffer in order.

#[must_use] pub fn iter_mut(&mut self) -> IterMut<A, N>[src]

Get an iterator over mutable references to the items in the ring buffer in order.

#[must_use] pub fn slice<R: RangeBounds<usize>>(&self, range: R) -> Slice<A, N>[src]

Get a Slice for a subset of the ring buffer.

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

Get a SliceMut for a subset of the ring buffer.

#[must_use] pub fn get(&self, index: usize) -> Option<&A>[src]

Get a reference to the value at a given index.

#[must_use] pub fn get_mut(&mut self, index: usize) -> Option<&mut A>[src]

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

#[must_use] pub fn first(&self) -> Option<&A>[src]

Get a reference to the first value in the buffer.

#[must_use] pub fn first_mut(&mut self) -> Option<&mut A>[src]

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

#[must_use] pub fn last(&self) -> Option<&A>[src]

Get a reference to the last value in the buffer.

#[must_use] pub fn last_mut(&mut self) -> Option<&mut A>[src]

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

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

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)[src]

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>[src]

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>[src]

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)[src]

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)[src]

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[src]

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)[src]

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)[src]

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)[src]

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[src]

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)[src]

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[src]

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

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

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

pub fn clear(&mut self)[src]

Discard the contents of the buffer.

Time: O(n)

Trait Implementations

impl<A, N> Arbitrary for RingBuffer<A, N> where
    A: Arbitrary,
    N: ChunkLength<A> + 'static, 
[src]

impl<A: Clone, N: ChunkLength<A>> Clone for RingBuffer<A, N>[src]

impl<A: Debug, N: ChunkLength<A>> Debug for RingBuffer<A, N>[src]

impl<A, N: ChunkLength<A>> Default for RingBuffer<A, N>[src]

impl<A, N: ChunkLength<A>> Drop for RingBuffer<A, N>[src]

impl<A: Eq, N: ChunkLength<A>> Eq for RingBuffer<A, N>[src]

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

impl<A, N: ChunkLength<A>> Extend<A> for RingBuffer<A, N>[src]

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

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

impl<A, N: ChunkLength<A>> FromIterator<A> for RingBuffer<A, N>[src]

impl<A: Hash, N: ChunkLength<A>> Hash for RingBuffer<A, N>[src]

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

type Output = A

The returned type after indexing.

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

impl<A, N: ChunkLength<A>> IntoIterator for RingBuffer<A, N>[src]

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?

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

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?

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

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?

impl<A: Ord, N: ChunkLength<A>> Ord for RingBuffer<A, N>[src]

impl<A: PartialEq, N: ChunkLength<A>> PartialEq<RingBuffer<A, N>> for RingBuffer<A, N>[src]

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

impl<A: PartialOrd, N: ChunkLength<A>> PartialOrd<RingBuffer<A, N>> for RingBuffer<A, N>[src]

impl<A, N> PoolClone for RingBuffer<A, N> where
    A: Clone,
    N: ChunkLength<A>, 
[src]

impl<A, N> PoolDefault for RingBuffer<A, N> where
    N: ChunkLength<A>, 
[src]

impl<N: ChunkLength<u8>> Read for RingBuffer<u8, N>[src]

impl<N: ChunkLength<u8>> Write for RingBuffer<u8, N>[src]

Auto Trait Implementations

impl<A, N> RefUnwindSafe for RingBuffer<A, N> where
    A: RefUnwindSafe,
    N: RefUnwindSafe,
    <N as ChunkLength<A>>::SizedType: RefUnwindSafe

impl<A, N> Send for RingBuffer<A, N> where
    A: Send,
    N: Send,
    <N as ChunkLength<A>>::SizedType: Send

impl<A, N> Sync for RingBuffer<A, N> where
    A: Sync,
    N: Sync,
    <N as ChunkLength<A>>::SizedType: Sync

impl<A, N> Unpin for RingBuffer<A, N> where
    A: Unpin,
    N: Unpin,
    <N as ChunkLength<A>>::SizedType: Unpin

impl<A, N> UnwindSafe for RingBuffer<A, N> where
    A: UnwindSafe,
    N: UnwindSafe,
    <N as ChunkLength<A>>::SizedType: UnwindSafe

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<I> IntoIterator for I where
    I: Iterator
[src]

type Item = <I as Iterator>::Item

The type of the elements being iterated over.

type IntoIter = I

Which kind of iterator are we turning this into?

impl<A> PoolClone for A where
    A: PoolDefaultImpl + Clone

impl<A> PoolDefault for A where
    A: PoolDefaultImpl, 

impl<T> Same<T> for T[src]

type Output = T

Should always be Self

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.