Struct sample::ring_buffer::Fixed
[−]
[src]
pub struct Fixed<S> { /* fields omitted */ }
A ring buffer with a fixed length.
AKA Circular buffer, cyclic buffer, FIFO queue.
Elements are pushed and popped from the buffer simultaneously in order to retain a consistent length.
A Fixed
ring buffer can be created around any type with a slice to write to.
extern crate sample; fn main() { // From a fixed size array. sample::ring_buffer::Fixed::from([1, 2, 3, 4]); // From a Vec. sample::ring_buffer::Fixed::from(vec![1, 2, 3, 4]); // From a Boxed slice. sample::ring_buffer::Fixed::from(vec![1, 2, 3].into_boxed_slice()); // From a mutably borrowed slice. let mut slice = [1, 2, 3, 4]; sample::ring_buffer::Fixed::from(&mut slice[..]); // An immutable ring buffer from an immutable slice. let slice = [1, 2, 3, 4]; sample::ring_buffer::Fixed::from(&slice[..]); }
Methods
impl<S> Fixed<S> where
S: Slice,
[src]
S: Slice,
fn len(&self) -> usize
[src]
The fixed length of the buffer.
extern crate sample; use sample::ring_buffer; fn main() { let rb = ring_buffer::Fixed::from([0; 4]); assert_eq!(rb.len(), 4); }
fn push(&mut self, item: S::Element) -> S::Element where
S: SliceMut,
[src]
S: SliceMut,
Push the given item onto the back of the queue and return the item at the front of the queue, ensuring that the length is retained.
extern crate sample; use sample::ring_buffer; fn main() { let mut rb = ring_buffer::Fixed::from([0, 1, 2, 3]); assert_eq!(rb.push(4), 0); assert_eq!(rb.push(5), 1); assert_eq!(rb.push(6), 2); assert_eq!(rb.push(7), 3); assert_eq!(rb.push(8), 4); assert_eq!([rb[0], rb[1], rb[2], rb[3]], [5, 6, 7, 8]); }
fn get(&self, index: usize) -> &S::Element
[src]
Borrows the item at the given index.
If index
is out of range it will be looped around the length of the data slice.
extern crate sample; use sample::ring_buffer; fn main() { let mut rb = ring_buffer::Fixed::from([0, 1, 2]); assert_eq!(*rb.get(0), 0); assert_eq!(*rb.get(1), 1); assert_eq!(*rb.get(2), 2); assert_eq!(*rb.get(3), 0); assert_eq!(*rb.get(4), 1); assert_eq!(*rb.get(5), 2); }
fn get_mut(&mut self, index: usize) -> &mut S::Element where
S: SliceMut,
[src]
S: SliceMut,
Mutably borrows the item at the given index.
If index
is out of range it will be looped around the length of the data slice.
fn set_first(&mut self, index: usize)
[src]
Sets the index of the first element within the data slice.
If index
is out of range it will be looped around the length of the data slice.
extern crate sample; use sample::ring_buffer; fn main() { let mut rb = ring_buffer::Fixed::from([0, 1, 2, 3]); assert_eq!(rb[0], 0); rb.set_first(2); assert_eq!(rb[0], 2); rb.set_first(5); assert_eq!(rb[0], 1); }
fn slices(&self) -> (&[S::Element], &[S::Element])
[src]
The start and end slices that make up the ring buffer.
These two slices chained together represent all elements within the buffer in order.
The first slice is always aligned contiguously behind the second slice.
extern crate sample; fn main() { let mut ring_buffer = sample::ring_buffer::Fixed::from([0; 4]); assert_eq!(ring_buffer.slices(), (&[0, 0, 0, 0][..], &[][..])); ring_buffer.push(1); ring_buffer.push(2); assert_eq!(ring_buffer.slices(), (&[0, 0][..], &[1, 2][..])); ring_buffer.push(3); ring_buffer.push(4); assert_eq!(ring_buffer.slices(), (&[1, 2, 3, 4][..], &[][..])); }
fn slices_mut(&mut self) -> (&mut [S::Element], &mut [S::Element]) where
S: SliceMut,
[src]
S: SliceMut,
The same as the slices
method, but returns mutable slices instead.
fn iter_loop(&self) -> Skip<Cycle<Iter<S::Element>>>
[src]
Produce an iterator that repeatedly yields a reference to each element in the buffer.
fn iter(&self) -> Take<Skip<Cycle<Iter<S::Element>>>>
[src]
Produce an iterator that yields a reference to each element in the buffer.
fn iter_mut(&mut self) -> Chain<IterMut<S::Element>, IterMut<S::Element>> where
S: SliceMut,
[src]
S: SliceMut,
Produce an iterator that yields a mutable reference to each element in the buffer.
fn from_raw_parts(first: usize, data: S) -> Self
[src]
Creates a Fixed
ring buffer from its starting index and data buffer type.
Panic!s if the given index is out of range of the given data slice.
Note: This method should only be necessary if you require specifying a first index.
Please see the ring_buffer::Fixed::from
function for a simpler constructor that does not
require a first
index.
unsafe fn from_raw_parts_unchecked(first: usize, data: S) -> Self
[src]
Creates a Fixed
ring buffer from its starting index and data buffer type.
This method is unsafe as there is no guarantee that first
< data.slice().len()
.
fn into_raw_parts(self) -> (usize, S)
[src]
Consumes the Fixed
ring buffer and returns its parts:
usize
is an index into the first element of the buffer.S
is the buffer data.
Trait Implementations
impl<S: Copy> Copy for Fixed<S>
[src]
impl<S: Clone> Clone for Fixed<S>
[src]
fn clone(&self) -> Fixed<S>
[src]
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
1.0.0[src]
Performs copy-assignment from source
. Read more
impl<S: Debug> Debug for Fixed<S>
[src]
impl<S: PartialEq> PartialEq for Fixed<S>
[src]
fn eq(&self, __arg_0: &Fixed<S>) -> bool
[src]
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, __arg_0: &Fixed<S>) -> bool
[src]
This method tests for !=
.
impl<S: Eq> Eq for Fixed<S>
[src]
impl<S: Hash> Hash for Fixed<S>
[src]
fn hash<__HS: Hasher>(&self, __arg_0: &mut __HS)
[src]
Feeds this value into the given [Hasher
]. Read more
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
Feeds a slice of this type into the given [Hasher
]. Read more
impl<S> From<S> for Fixed<S> where
S: Slice,
[src]
S: Slice,
fn from(data: S) -> Self
[src]
Construct a Fixed
ring buffer from the given data slice.
Panic!s if the given data
buffer is empty.
impl<S, T> FromIterator<T> for Fixed<S> where
S: Slice<Element = T> + FromIterator<T>,
[src]
S: Slice<Element = T> + FromIterator<T>,
fn from_iter<I>(iter: I) -> Self where
I: IntoIterator<Item = T>,
[src]
I: IntoIterator<Item = T>,
Creates a value from an iterator. Read more
impl<S> Index<usize> for Fixed<S> where
S: Slice,
[src]
S: Slice,
type Output = S::Element
The returned type after indexing.
fn index(&self, index: usize) -> &Self::Output
[src]
Performs the indexing (container[index]
) operation.
impl<S> IndexMut<usize> for Fixed<S> where
S: SliceMut,
[src]
S: SliceMut,