Struct smoltcp::storage::RingBuffer [−][src]
pub struct RingBuffer<'a, T: 'a> { /* fields omitted */ }
Expand description
A ring buffer.
This ring buffer implementation provides many ways to interact with it:
- Enqueueing or dequeueing one element from corresponding side of the buffer;
- Enqueueing or dequeueing a slice of elements from corresponding side of the buffer;
- Accessing allocated and unallocated areas directly.
It is also zero-copy; all methods provide references into the buffer’s storage. Note that all references are mutable; it is considered more important to allow in-place processing than to protect from accidental mutation.
This implementation is suitable for both simple uses such as a FIFO queue of UDP packets, and advanced ones such as a TCP reassembly buffer.
Implementations
Create a ring buffer with the given storage.
During creation, every element in storage
is reset.
Clear the ring buffer, and reset every element.
Return the number of elements that can be added to the ring buffer.
Return the largest number of elements that can be added to the buffer
without wrapping around (i.e. in a single enqueue_many
call).
This is the “discrete” ring buffer interface: it operates with single elements, and boundary conditions (empty/full) are errors.
Call f
with a single buffer element, and enqueue the element if f
returns successfully, or return Err(Error::Exhausted)
if the buffer is full.
Enqueue a single element into the buffer, and return a reference to it,
or return Err(Error::Exhausted)
if the buffer is full.
This function is a shortcut for ring_buf.enqueue_one_with(Ok)
.
Call f
with a single buffer element, and dequeue the element if f
returns successfully, or return Err(Error::Exhausted)
if the buffer is empty.
Dequeue an element from the buffer, and return a reference to it,
or return Err(Error::Exhausted)
if the buffer is empty.
This function is a shortcut for ring_buf.dequeue_one_with(Ok)
.
This is the “continuous” ring buffer interface: it operates with element slices, and boundary conditions (empty/full) simply result in empty slices.
pub fn enqueue_many_with<'b, R, F>(&'b mut self, f: F) -> (usize, R) where
F: FnOnce(&'b mut [T]) -> (usize, R),
pub fn enqueue_many_with<'b, R, F>(&'b mut self, f: F) -> (usize, R) where
F: FnOnce(&'b mut [T]) -> (usize, R),
Call f
with the largest contiguous slice of unallocated buffer elements,
and enqueue the amount of elements returned by f
.
Panics
This function panics if the amount of elements returned by f
is larger
than the size of the slice passed into it.
Enqueue a slice of elements up to the given size into the buffer, and return a reference to them.
This function may return a slice smaller than the given size if the free space in the buffer is not contiguous.
Enqueue as many elements from the given slice into the buffer as possible, and return the amount of elements that could fit.
pub fn dequeue_many_with<'b, R, F>(&'b mut self, f: F) -> (usize, R) where
F: FnOnce(&'b mut [T]) -> (usize, R),
pub fn dequeue_many_with<'b, R, F>(&'b mut self, f: F) -> (usize, R) where
F: FnOnce(&'b mut [T]) -> (usize, R),
Call f
with the largest contiguous slice of allocated buffer elements,
and dequeue the amount of elements returned by f
.
Panics
This function panics if the amount of elements returned by f
is larger
than the size of the slice passed into it.
Dequeue a slice of elements up to the given size from the buffer, and return a reference to them.
This function may return a slice smaller than the given size if the allocated space in the buffer is not contiguous.
Dequeue as many elements from the buffer into the given slice as possible, and return the amount of elements that could fit.
This is the “random access” ring buffer interface: it operates with element slices, and allows to access elements of the buffer that are not adjacent to its head or tail.
Return the largest contiguous slice of unallocated buffer elements starting at the given offset past the last allocated element, and up to the given size.
Write as many elements from the given slice into unallocated buffer elements starting at the given offset past the last allocated element, and return the amount written.
Enqueue the given number of unallocated buffer elements.
Panics
Panics if the number of elements given exceeds the number of unallocated elements.
Return the largest contiguous slice of allocated buffer elements starting at the given offset past the first allocated element, and up to the given size.
Read as many elements from allocated buffer elements into the given slice starting at the given offset past the first allocated element, and return the amount read.
Dequeue the given number of allocated buffer elements.
Panics
Panics if the number of elements given exceeds the number of allocated elements.
Trait Implementations
Performs the conversion.