[−][src]Struct dasp::ring_buffer::Fixed
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.
fn main() { // From a fixed size array. dasp_ring_buffer::Fixed::from([1, 2, 3, 4]); // From a Vec. dasp_ring_buffer::Fixed::from(vec![1, 2, 3, 4]); // From a Boxed slice. dasp_ring_buffer::Fixed::from(vec![1, 2, 3].into_boxed_slice()); // From a mutably borrowed slice. let mut slice = [1, 2, 3, 4]; dasp_ring_buffer::Fixed::from(&mut slice[..]); // An immutable ring buffer from an immutable slice. let slice = [1, 2, 3, 4]; dasp_ring_buffer::Fixed::from(&slice[..]); }
Implementations
impl<S> Fixed<S> where
S: Slice,
[src]
S: Slice,
pub fn len(&self) -> usize
[src]
The fixed length of the buffer.
fn main() { let rb = dasp_ring_buffer::Fixed::from([0; 4]); assert_eq!(rb.len(), 4); }
pub fn push(&mut self, item: <S as Slice>::Element) -> <S as Slice>::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.
fn main() { let mut rb = dasp_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]); }
pub fn get(&self, index: usize) -> &<S as Slice>::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.
fn main() { let mut rb = dasp_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); }
pub fn get_mut(&mut self, index: usize) -> &mut <S as Slice>::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.
pub 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.
fn main() { let mut rb = dasp_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); }
pub fn slices(&self) -> (&[<S as Slice>::Element], &[<S as Slice>::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.
fn main() { let mut ring_buffer = dasp_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][..], &[][..])); }
pub fn slices_mut(
&mut self
) -> (&mut [<S as Slice>::Element], &mut [<S as Slice>::Element]) where
S: SliceMut,
[src]
&mut self
) -> (&mut [<S as Slice>::Element], &mut [<S as Slice>::Element]) where
S: SliceMut,
The same as the slices
method, but returns mutable slices instead.
pub fn iter_loop(&self) -> Skip<Cycle<Iter<<S as Slice>::Element>>>
[src]
Produce an iterator that repeatedly yields a reference to each element in the buffer.
pub fn iter(&self) -> Take<Skip<Cycle<Iter<<S as Slice>::Element>>>>
[src]
Produce an iterator that yields a reference to each element in the buffer.
pub fn iter_mut(
&mut self
) -> Chain<IterMut<<S as Slice>::Element>, IterMut<<S as Slice>::Element>> where
S: SliceMut,
[src]
&mut self
) -> Chain<IterMut<<S as Slice>::Element>, IterMut<<S as Slice>::Element>> where
S: SliceMut,
Produce an iterator that yields a mutable reference to each element in the buffer.
pub fn from_raw_parts(first: usize, data: S) -> Fixed<S>
[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.
pub unsafe fn from_raw_parts_unchecked(first: usize, data: S) -> Fixed<S>
[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()
.
pub 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> Clone for Fixed<S> where
S: Clone,
[src]
S: Clone,
impl<S> Copy for Fixed<S> where
S: Copy,
[src]
S: Copy,
impl<S> Debug for Fixed<S> where
S: Debug,
[src]
S: Debug,
impl<S> Eq for Fixed<S> where
S: Eq,
[src]
S: Eq,
impl<S> From<S> for Fixed<S> where
S: Slice,
[src]
S: Slice,
fn from(data: S) -> Fixed<S>
[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) -> Fixed<S> where
I: IntoIterator<Item = T>,
[src]
I: IntoIterator<Item = T>,
impl<S> Hash for Fixed<S> where
S: Hash,
[src]
S: Hash,
fn hash<__H>(&self, state: &mut __H) where
__H: Hasher,
[src]
__H: Hasher,
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<S> Index<usize> for Fixed<S> where
S: Slice,
[src]
S: Slice,
type Output = <S as Slice>::Element
The returned type after indexing.
fn index(&self, index: usize) -> &<Fixed<S> as Index<usize>>::Output
[src]
impl<S> IndexMut<usize> for Fixed<S> where
S: SliceMut,
[src]
S: SliceMut,
impl<S> PartialEq<Fixed<S>> for Fixed<S> where
S: PartialEq<S>,
[src]
S: PartialEq<S>,
impl<S> StructuralEq for Fixed<S>
[src]
impl<S> StructuralPartialEq for Fixed<S>
[src]
Auto Trait Implementations
impl<S> RefUnwindSafe for Fixed<S> where
S: RefUnwindSafe,
S: RefUnwindSafe,
impl<S> Send for Fixed<S> where
S: Send,
S: Send,
impl<S> Sync for Fixed<S> where
S: Sync,
S: Sync,
impl<S> Unpin for Fixed<S> where
S: Unpin,
S: Unpin,
impl<S> UnwindSafe for Fixed<S> where
S: UnwindSafe,
S: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<S, T> Duplex<S> for T where
T: FromSample<S> + ToSample<S>,
[src]
T: FromSample<S> + ToSample<S>,
impl<T> From<T> for T
[src]
impl<S> FromSample<S> for S
[src]
fn from_sample_(s: S) -> S
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
fn clone_into(&self, target: &mut T)
[src]
impl<T, U> ToSample<U> for T where
U: FromSample<T>,
[src]
U: FromSample<T>,
fn to_sample_(self) -> U
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,