Struct dyn_buf::VecBuf

pub struct VecBuf { /* fields omitted */ }

VecBuf is an effective dynamic buffer v1 implement, which tries to reduce reallocation and mem-moving.

If commit and consume speed matches(len() is always less than min_write), this buffer would allocate only once.

Example

use dyn_buf::VecBuf;
let mut buf = VecBuf::new(10);

let t = buf.prepare(4);
assert_eq!(t.len(), 4);

// write data to prepared buffer
t[..3].copy_from_slice(&[1, 2, 3]);
assert_eq!(buf.data(), &[]);

buf.commit(3);
assert_eq!(buf.data(), &[1, 2, 3]);

buf.consume(2);
assert_eq!(buf.data(), &[3]);

let t = buf.prepare_at_least(2);
assert!(t.len() >= 2);
t[..2].copy_from_slice(&[4, 5]);
assert_eq!(buf.data(), &[3]);

buf.commit(2);
assert_eq!(buf.data(), &[3, 4, 5]);

buf.consume(2);
assert_eq!(buf.data(), &[5]);

assert_eq!(buf.into_vec(), vec![5]);

Implementations

impl VecBuf

pub fn len(&self) -> usize

Returns the number of readable bytes.

pub fn is_empty(&self) -> bool

Returns true if buffer contains no readable bytes.

pub fn capacity(&self) -> usize

Returns the maximum number of bytes, both readable and writable, that can be held by self without requiring reallocation.

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

Returns a constant buffer sequence u that represents the readable bytes.

pub fn prepare(&mut self, amt: usize) -> &mut [u8]

Returns a mutable buffer sequence u representing the writable bytes, and where buffer_size(u) == amt.

The dynamic buffer reallocates memory as required. All constant or mutable buffer sequences previously obtained using data() or prepare() are invalidated.

Panic: length_error if size() + amt exceeds max_size().

pub fn prepare_at_least(&mut self, amt: usize) -> &mut [u8]

Returns a mutable buffer sequence u representing the writable bytes, and where buffer_size(u) >= amt.

The dynamic buffer reallocates memory as required. All constant or mutable buffer sequences previously obtained using data() or prepare() are invalidated.

Panic: length_error if size() + amt exceeds max_size().

pub fn commit(&mut self, amt: usize)

Appends amt bytes from the start of the writable bytes to the end of the readable bytes.

The remainder of the writable bytes are discarded. If amt is greater than the number of writable bytes, all writable bytes are appended to the readable bytes. All constant or mutable buffer sequences previously obtained using data() or prepare() are invalidated.

pub fn consume(&mut self, amt: usize)

Removes amt bytes from beginning of the readable bytes.

If amt is greater than the number of readable bytes, all readable bytes are removed. All constant or mutable buffer sequences previously obtained using data() or prepare() are invalidated.

impl VecBuf

pub fn new(min_write: usize) -> Self

create a VecBuf with min_write

prepare_at_least will return a buffer at least min_write bytes.

Example

 use dyn_buf::VecBuf;
 let min_write = 5;
 let mut buf = VecBuf::new(min_write);
 let t = buf.prepare_at_least(0);
 assert!(t.len() >= min_write);
 t[..2].copy_from_slice(&[1,2]);
 buf.commit(2);
 let t = buf.prepare_at_least(0);
 assert!(t.len() >= min_write);

pub fn reserve(&mut self, amt: usize)

Reserves capacity for at least amt bytes to be wrote

pub fn grow(&mut self, amt: usize)

Grow capacity at least amt bytes

pub fn write_all(&mut self, buf: &[u8])

Write all bytes of buf into self

pub fn into_vec(self) -> Vec<u8>

Converts self into a vector without clones or allocation. The resulting vector contains all the readable bytes

Trait Implementations

impl Default for VecBuf

fn default() -> VecBuf

Returns the “default value” for a type.