Struct Buffer

Source

pub struct Buffer<T: AsMut<[u8]> + AsRef<[u8]>> { /* private fields */ }

Expand description

A buffer that allows reading and writuing bytes u8 from / to an underlying generic source

Implementations§

Source §

impl<T: AsMut<[u8]> + AsRef<[u8]>> Buffer<T>

Source

pub fn new(source: T) -> Self

Create a new buffer from any source

§Example

    use embytes_buffer::Buffer;
 
    let mut bytes = [0; 1024];
    let mut buffer = Buffer::new(&mut bytes);

Examples found in repository ?

examples/reader.rs (line 10)

8fn main () {
9    let mut bytes = [0; 1024];
10    let mut buffer = Buffer::new(&mut bytes);
11
12    // Write some bytes
13    buffer.write_all("abc".as_bytes()).unwrap();
14
15    // try to read to a komma but there is none
16    let reader = buffer.create_reader();
17    let result = read_til_komma(&reader);
18    assert_eq!(result, None);
19    drop(reader);
20
21    // Write a string that now contains a comma
22    buffer.write_all("def,1234".as_bytes()).unwrap();
23
24    // try to read to a komma. now there is one
25    let reader = buffer.create_reader();
26    let result = read_til_komma(&reader);
27    assert_eq!(result, Some("abcdef"));
28    drop(reader);
29
30    assert_eq!(buffer.data(), "1234".as_bytes());
31}

More examples

Hide additional examples

examples/writer.rs (line 8)

6fn main () {
7    let mut bytes = [0; 1024];
8    let mut buffer = Buffer::new(&mut bytes);
9
10    // Write some bytes
11    buffer.write_all("abc".as_bytes()).unwrap();
12
13    // Create a writer, write some bytes but do not commit
14    // writer implements DerefMut<Target = [u8]> and can be used as a mutable bytes slice
15    let mut writer = buffer.create_writer();
16    writer[0] = 36; // ascii '$'
17    drop(writer);
18
19    // Create a new writer
20    let mut writer = buffer.create_writer();
21    writer[0] = 100; // ascii d
22    writer[1] = 101; // ascii e
23    writer[2] = 102; // ascii f
24
25    // Commit that 3 bytes are written
26    // writing bytes has only an effect if the written bytes are committed
27    writer.commit(3).unwrap();
28    drop(writer); // drop the writer to follow the borrowing rules. at drop the written bytes are committed
29
30    let mut result = [0; 1024];
31    let bytes_read = buffer.read(&mut result).unwrap();
32    assert_eq!("abcdef".as_bytes(), &result[..bytes_read]);
33}

Source

pub fn reset(&mut self)

Reset the buffer to its initial state

Source

pub fn capacity(&self) -> usize

Returns the length of the undelying buffer

Source

pub fn remaining_capacity(&self) -> usize

Returns the remaining space that can be written to. This method does not perform a Buffer::shift

Source

pub fn has_remaining_capacity(&self) -> bool

returns true if there is remaining capacity to write to. is equal to Buffer::remaining_capacity > 0

Source

pub fn remaining_len(&self) -> usize

Returns the remaining bytes to read

Source

pub fn has_remaining_len(&self) -> bool

returns true if there are remainng bytes to read.

Source

pub fn has_dead_capacity(&self) -> bool

Returns true if there is dead capacity. Dead capacity occures when bytes are read from a buffer. Dead capacity can be regained by using Buffer::shift

Source

pub fn shift(&mut self)

Shifts the content of the source left to reuse space of read bytes. See also Buffer::has_dead_capacity

Source

pub fn ensure_remaining_capacity(&mut self) -> bool

Performa s Buffer::shift if there is no remianing capacity and returns true if there is remainig capacity afterwards

Source

pub fn create_reader_with_max(&mut self, max_bytes: usize) -> Reader<'_, T>

Creates a reader that ready at most max_bytes

Source

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

Returns a slice containing the readable data

Examples found in repository ?

examples/reader.rs (line 30)

8fn main () {
9    let mut bytes = [0; 1024];
10    let mut buffer = Buffer::new(&mut bytes);
11
12    // Write some bytes
13    buffer.write_all("abc".as_bytes()).unwrap();
14
15    // try to read to a komma but there is none
16    let reader = buffer.create_reader();
17    let result = read_til_komma(&reader);
18    assert_eq!(result, None);
19    drop(reader);
20
21    // Write a string that now contains a comma
22    buffer.write_all("def,1234".as_bytes()).unwrap();
23
24    // try to read to a komma. now there is one
25    let reader = buffer.create_reader();
26    let result = read_til_komma(&reader);
27    assert_eq!(result, Some("abcdef"));
28    drop(reader);
29
30    assert_eq!(buffer.data(), "1234".as_bytes());
31}