Struct vmcircbuf::Buffer

pub struct Buffer { /* fields omitted */ }

A raw circular buffer of bytes. The buffer holds exactly size many bytes but it is presented as a size + wrap length slice where the last wrap many bytes overlap with the first wrap many bytes of the slice. This magic trick is performed with virtual memory, the same physical pages are mapped both at the start and at the end of the buffer.

Examples

let mut buffer = vmcircbuf::Buffer::new(1024, 100).unwrap();
let size = buffer.size();
let wrap = buffer.wrap();
assert!(size >= 1024 && wrap >= 100);
let slice: &mut [u8] = buffer.as_mut_slice();
assert_eq!(slice.len(), size + wrap);

for a in slice.iter_mut() {
    *a = 0;
}
slice[0] = 123;
assert_eq!(slice[size], 123);

Methods

impl Buffer

pub fn granularity() -> Result<usize, Error>

Returns the virtual memory mapping granularity of the underlying operating system. On Unix this is the page size, which is typically 4096 bytes. On Windows this is the allocation granularity, which is typically 65536 bytes.

pub fn new(size: usize, wrap: usize) -> Result<Buffer, Error>

Creates a new circular buffer with the given size and wrap. The returned size and wrap will be rounded up to an integer multiple of the granularity. This size parameter must be greater than zero. The wrap parameter cannot be larger than size, but it can be zero.

pub fn size(&self) -> usize

Returns the size of the circular buffer.

pub fn wrap(&self) -> usize

Returns the wrap of the circular buffer.

pub fn as_slice(&self) -> &[u8]

Returns an immutable slice of the circular buffer. The last wrap many bytes are mapped to the first wrap many bytes, so you can read the same content at both places. The length of the slice is always size + wrap but it contains only size many elements.

pub fn as_mut_slice(&mut self) -> &mut [u8]

Returns a mutable slice of the circular buffer. The last wrap many bytes are mapped to the first wrap many bytes, so you can read and write the same content at both places. The length of the slice is always size + wrap, but contains only size many elements.

Trait Implementations

impl Drop for Buffer

fn drop(&mut self)

Executes the destructor for this type.

impl<I: SliceIndex<[u8]>> Index<I> for Buffer

type Output = I::Output

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<I: SliceIndex<[u8]>> IndexMut<I> for Buffer

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

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

impl Send for Buffer

impl Sync for Buffer