Struct DataBuffer 

pub struct DataBuffer { /* private fields */ }

A data buffer object specifically turned to easily read and write binary values

Implementations

impl DataBuffer

pub fn new() -> DataBuffer

Construct a new, empty, DataBuffer

pub fn from_bytes(bytes: &[u8]) -> DataBuffer

Borrows the data from a Vec<u8> to produce a DataBuffer. This method is the equivalent of creating a new() DataBuffer and calling the .write_bytes() method to effectively copy all bytes from the borrowed vector into this buffer’s underlying vector.

pub fn with_vec(bytes: Vec<u8>) -> DataBuffer

Takes ownership of a Vec<u8> and uses it for this buffer’s underlying vector. This is not a borrow, you will not be able to use the original vector anymore after calling this method. This method is useful to avoid excessive copying of data.

pub fn create(opcode: u8, header: PacketHeader) -> DataBuffer

pub fn finish(&mut self)

pub fn len(&self) -> usize

Return the buffer size

pub fn clear(&mut self)

Clear the buffer and reinitialize the reading and writing cursor

pub fn resize(&mut self, size: usize)

Change the buffer size to size.

Note: You cannot shrink a buffer with this method

pub fn write_bytes(&mut self, bytes: &[u8])

Append a byte array to the buffer. The buffer is automatically extended if needed

#Example

let mut buffer = DataBuffer::new();
buffer.write_bytes(&vec![0x1, 0xFF, 0x45]); // buffer contains [0x1, 0xFF, 0x45]

pub fn write_u8(&mut self, val: u8)

Append a byte (8 bits value) to the buffer

#Example

let mut buffer = DataBuffer::new();
buffer.write_u8(1) // buffer contains [0x1]

pub fn write_i8(&mut self, val: i8)

Same as write_u8() but for signed values

pub fn write_u16(&mut self, val: u16)

Append a word (16 bits value) to the buffer

#Example

let mut buffer = DataBuffer::new();
buffer.write_u16(1) // buffer contains [0x00, 0x1] if little endian

pub fn write_i16(&mut self, val: i16)

Same as write_u16() but for signed values

pub fn write_u32(&mut self, val: u32)

Append a double word (32 bits value) to the buffer

#Example

let mut buffer = DataBuffer::new();
buffer.write_u32(1) // buffer contains [0x00, 0x00, 0x00, 0x1] if little endian

pub fn write_i32(&mut self, val: i32)

Same as write_u32() but for signed values

pub fn write_u64(&mut self, val: u64)

Append a quaddruple word (64 bits value) to the buffer

#Example

let mut buffer = DataBuffer::new();
buffer.write_u64(1) // buffer contains [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1] if little endian

pub fn write_i64(&mut self, val: i64)

Same as write_u64() but for signed values

pub fn write_f32(&mut self, val: f32)

Append a 32 bits floating point number to the buffer.

#Example

let mut buffer = DataBuffer::new();
buffer.write_f32(0.1)

pub fn write_f64(&mut self, val: f64)

Append a 64 bits floating point number to the buffer.

#Example

let mut buffer = DataBuffer::new();
buffer.write_f64(0.1)

pub fn write_str(&mut self, val: &str)

Append a string to the buffer.

Format The format is (u32)size + size * (u8)characters

#Example

let mut buffer = DataBuffer::new();
buffer.write_str("Hello")

pub fn write_ntstr(&mut self, val: &str)

Write a single null-terminated string to the buffer.

#Example

let mut buffer = DataBuffer::new();
buffer.write_ntstr("Hello");

pub fn write_dntstr(&mut self, val: &str)

Write a null-bookeneded string to the buffer.

#Example

let mut buffer = DataBuffer::new();
buffer.write_dntstr("Hello");

pub fn write_smart(&mut self, val: u16)

Writes a smart to the buffer, which is a dynamically-sized unit with a max value of 32768.

pub fn write_medium(&mut self, val: u32)

Writes a medium to the buffer, which is a tribyte word.

pub fn write_u8_neg(&mut self, val: u8)

Writes an inverted-signededness u8 to the buffer.

pub fn write_i8_neg(&mut self, val: i8)

Writes an inverted-signededness i8 to the buffer.

pub fn write_u8_add(&mut self, val: u8)

Writes a u8 + 128 to the buffer.

pub fn write_i8_add(&mut self, val: i8)

Writes a i8 + 128 to the buffer.

pub fn write_u8_sub(&mut self, val: u8)

Writes a u8 - 128 to the buffer.

pub fn write_i8_sub(&mut self, val: i8)

Writes a i8 - 128 to the buffer.

pub fn write_u16_le(&mut self, val: u16)

Writes a little-endian u16 to the buffer.

pub fn write_i16_le(&mut self, val: i16)

Writes a little-endian i16 to the buffer.

pub fn write_u16_le_add(&mut self, val: u16)

Writes a little-endian u16 + 128 to the buffer.

pub fn write_i16_le_add(&mut self, val: i16)

Writes a little-endian u16 + 128 to the buffer.

pub fn write_u32_le(&mut self, val: u32)

Writes a little-endian u32 to the buffer.

pub fn write_i32_le(&mut self, val: i32)

Writes a little-endian i32 to the buffer.

pub fn write_u32_me(&mut self, val: u32)

Writes a mixed-endian u32 to the buffer.

pub fn write_u32_me_reversed(&mut self, val: u32)

Writes a reverse mixed-endian u32 to the buffer.

pub fn read_bytes(&mut self, size: usize) -> Vec<u8>

Read a defined amount of raw bytes. The program crash if not enough bytes are available

pub fn read_u8(&mut self) -> u8

Read one byte. The program crash if not enough bytes are available

#Example

let mut buffer = DataBuffer::from_bytes(&vec![0x1]);
let value = buffer.read_u8(); //Value contains 1

pub fn read_i8(&mut self) -> i8

Same as read_u8() but for signed values

pub fn read_u16(&mut self) -> u16

Read a 2-bytes long value. The program crash if not enough bytes are available

#Example

let mut buffer = DataBuffer::from_bytes(&vec![0x0, 0x1]);
let value = buffer.read_u16(); //Value contains 1

pub fn read_i16(&mut self) -> i16

Same as read_u16() but for signed values

pub fn read_u32(&mut self) -> u32

Read a four-bytes long value. The program crash if not enough bytes are available

#Example

let mut buffer = DataBuffer::from_bytes(&vec![0x0, 0x0, 0x0, 0x1]);
let value = buffer.read_u32(); // Value contains 1

pub fn read_i32(&mut self) -> i32

Same as read_u32() but for signed values

pub fn read_u64(&mut self) -> u64

Read an eight bytes long value. The program crash if not enough bytes are available

#Example

let mut buffer = DataBuffer::from_bytes(&vec![0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1]);
let value = buffer.read_u64(); //Value contains 1

pub fn read_i64(&mut self) -> i64

Same as read_u64() but for signed values

pub fn read_f32(&mut self) -> f32

Read a 32 bits floating point value. The program crash if not enough bytes are available

pub fn read_f64(&mut self) -> f64

Read a 64 bits floating point value. The program crash if not enough bytes are available

pub fn read_string(&mut self) -> String

Read a string.

Note : First it reads a 32 bits value representing the size, the read ‘size’ raw bytes.

pub fn read_ntstr(&mut self) -> String

Read a null-terminated string.

pub fn read_dntstr(&mut self) -> String

Read a null-bookended string.

pub fn read_smart(&mut self) -> u16

Reads a smart from the buffer, which is a dynamically-sized unit with a max value of 32768.

pub fn read_medium(&mut self) -> u32

Reads a medium from the buffer, which is a tribyte word.

pub fn read_u8_neg(&mut self) -> u8

Reads an inverted-signededness u8 from the buffer.

pub fn read_i8_neg(&mut self) -> i8

Reads an inverted-signededness i8 from the buffer.

pub fn read_u8_add(&mut self) -> u8

Reads a u8 + 128 from the buffer, and subtracts the extra 128.

pub fn read_i8_add(&mut self) -> i8

Reads a i8 + 128 from the buffer, and subtracts the extra 128.

pub fn read_u8_sub(&mut self) -> u8

Reads a u8 - 128 from the buffer, and adds back the missing 128.

pub fn read_i8_sub(&mut self) -> i8

Reads a i8 - 128 from the buffer, and adds back the missing 128.

pub fn read_u16_le(&mut self) -> u16

Reads a little-endian u16 from the buffer.

pub fn read_i16_le(&mut self) -> i16

Reads a little-endian i16 from the buffer.

pub fn read_u16_le_add(&mut self) -> u16

Reads a little-endian u16 + 128 from the buffer, and subtracts the extra 128.

pub fn read_i16_le_add(&mut self) -> i16

Reads a little-endian i16 + 128 from the buffer, and subtracts the extra 128.

pub fn read_u32_le(&mut self) -> u32

Reads a little-endian u32 from the buffer.

pub fn read_i32_le(&mut self) -> i32

Reads a little-endian u32 from the buffer.

pub fn read_u32_me(&mut self) -> u32

Reads a mixed-endian u32 from the buffer.

pub fn read_u32_me_reversed(&mut self) -> u32

Reads a reverse mixed-endian u32 from the buffer.

pub fn to_string(&self) -> String

Dump the byte buffer to a string.

pub fn get_rpos(&self) -> usize

Return the position of the reading cursor

pub fn set_rpos(&mut self, rpos: usize)

Set the reading cursor position. Note : Set the reading cursor to min(newPosition, self.len()) to prevent overflow

pub fn get_wpos(&self) -> usize

Return the writing cursor position

pub fn set_wpos(&mut self, wpos: usize)

Set the writing cursor position. Note : Set the writing cursor to min(newPosition, self.len()) to prevent overflow

pub fn to_bytes(&self) -> Vec<u8>

Returns a copy of this buffer’s underlying Vec<u8>. If you no longer need to use this buffer after calling this, it is recommended to use .deconstruct() instead.

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

pub fn read_bit(&mut self) -> bool

Read 1 bit. Return true if the bit is set to 1, otherwhise, return false.

Note Bits are read from left to right

#Example

let mut buffer = DataBuffer::from_bytes(&vec![128]); // 10000000b
let value1 = buffer.read_bit(); //value1 contains true (eg: bit is 1)
let value2 = buffer.read_bit(); //value2 contains false (eg: bit is 0)

pub fn read_bits(&mut self, n: u8) -> u64

Read n bits. an return the corresponding value an u64.

Note 1 : We cannot read more than 64 bits

Note 2 Bits are read from left to right

#Example

let mut buffer = DataBuffer::from_bytes(&vec![128]); // 10000000b
let value = buffer.read_bits(3); // value contains 4 (eg: 100b)

pub fn flush_bit(&mut self)

Discard all the pending bits available for reading or writing and place the the corresponding cursor to the next byte.

Note 1 : If no bits are currently read or written, this function does nothing. Note 2 : This function is automatically called for each write or read operations. #Example

10010010 | 00000001
^
10010010 | 00000001 // read_bit called
 ^
10010010 | 00000001 // flush_bit() called
           ^

pub fn write_bit(&mut self, bit: bool)

Append 1 bit value to the buffer. The bit is happened like this :

...| XXXXXXXX | 10000000 |....

pub fn write_bits(&mut self, value: u64, n: u8)

Write the given value as a sequence of n bits

#Example

let mut buffer = DataBuffer::new();
buffer.write_bits(4, 3); // append 100b

Trait Implementations

impl Debug for DataBuffer

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Read for DataBuffer

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Reader has an efficient read_vectored implementation.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

Reads all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Reads all bytes until EOF in this source, appending them to buf.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Reads the exact number of bytes required to fill buf.

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Pull some bytes from this source into the specified buffer.

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Reads the exact number of bytes required to fill cursor.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R>

where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

where Self: Sized,

Creates an adapter which will read at most limit bytes from it.

impl Write for DataBuffer

fn write(&mut self, buf: &[u8]) -> Result<usize>

Writes a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> Result<()>

Flushes this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Write.