Struct bytebuff::ByteBuff

pub struct ByteBuff { /* fields omitted */ }

ByteBuff is a convenient helper for game networking. Using this is similar to using ThreadRng from rand package. Example speaks for it self.

Example

use bytebuff::{ByteBuff, ReadError, Interface};
let mut buff = ByteBuff::new();

buff.write(10f32); // supports float types
buff.write(30); // all integer types
buff.write(vec![10u8, 5u8, 8u8]); // as well as strings and byte vectors

assert_eq!(Ok(10f32), buff.read());
assert_eq!(Ok(30), buff.read());
assert_eq!(Ok(vec![10u8, 5u8, 8u8]), buff.read());
let bool: Result<bool, ReadError> = buff.read(); // unable to infer type in this case
assert!(bool.is_err());

Implementations

impl ByteBuff

pub fn new() -> Self

pub fn with_capacity(cap: usize) -> Self

works like Vec::with_capacity

pub fn from_bytes(data: &[u8]) -> Self

read creates buffer for reading

pub fn len(&self) -> usize

len returns length of buffer

pub fn clear(&mut self)

clear restarts the buffer, its useful when reusing buffers

pub fn is_finished(&self) -> bool

is_finished returns whether buffer is completely red

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

data returns slice of buffers data

pub fn extend(&mut self, other: &Self)

extend works almost as Vec::extend with slight difference. it also appends size of appended data and if the self length is missing as well it will add it too.

pub fn split(
    self,
    reminder: Option<Self>,
    reminding_size: usize,
    reminding_data: Vec<u8>,
    collector: &mut Vec<Self>
) -> (Option<Self>, usize, Vec<u8>)

split works on previously merged buffers. It splits them to original smaller parts and also some garbage that you are supposed to feed into next split call. NOW you may be asking why is there so match garbage arguments and return values, well as we know your byte buffer witch you are passing to packet sender can be only so big and packages can arrive incomplete. Function simply takes and returns these reminders so all packages get completed.

Trait Implementations

impl Debug for ByteBuff

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

Formats the value using the given formatter.

impl Interface<String> for ByteBuff

fn write(&mut self, data: String)

fn read(&mut self) -> Result<String, ReadError>

impl Interface<Vec<u8>> for ByteBuff

fn write(&mut self, data: Vec<u8>)

fn read(&mut self) -> Result<Vec<u8>, ReadError>

impl Interface<bool> for ByteBuff

fn write(&mut self, data: bool)

fn read(&mut self) -> Result<bool, ReadError>

impl Interface<f32> for ByteBuff

fn write(&mut self, data: f32)

fn read(&mut self) -> Result<f32, ReadError>

impl Interface<f64> for ByteBuff

fn write(&mut self, data: f64)

fn read(&mut self) -> Result<f64, ReadError>

impl Interface<i128> for ByteBuff

fn write(&mut self, data: i128)

fn read(&mut self) -> Result<i128, ReadError>

impl Interface<i16> for ByteBuff

fn write(&mut self, data: i16)

fn read(&mut self) -> Result<i16, ReadError>

impl Interface<i32> for ByteBuff

fn write(&mut self, data: i32)

fn read(&mut self) -> Result<i32, ReadError>

impl Interface<i64> for ByteBuff

fn write(&mut self, data: i64)

fn read(&mut self) -> Result<i64, ReadError>

impl Interface<i8> for ByteBuff

fn write(&mut self, data: i8)

fn read(&mut self) -> Result<i8, ReadError>

impl Interface<u128> for ByteBuff

fn write(&mut self, data: u128)

fn read(&mut self) -> Result<u128, ReadError>

impl Interface<u16> for ByteBuff

fn write(&mut self, data: u16)

fn read(&mut self) -> Result<u16, ReadError>

impl Interface<u32> for ByteBuff

fn write(&mut self, data: u32)

fn read(&mut self) -> Result<u32, ReadError>

impl Interface<u64> for ByteBuff

fn write(&mut self, data: u64)

fn read(&mut self) -> Result<u64, ReadError>

impl Interface<u8> for ByteBuff

fn write(&mut self, data: u8)

fn read(&mut self) -> Result<u8, ReadError>

impl Interface<usize> for ByteBuff

fn write(&mut self, data: usize)

fn read(&mut self) -> Result<usize, ReadError>