Struct pi_bon::ReadBuffer

pub struct ReadBuffer<'a> {
    pub bytes: &'a [u8],
    pub head: usize,
}

ReadBuffer，用于将二进制反序列化为对应数据

Fields

bytes: &'a [u8]

head: usize

Implementations

impl<'a> ReadBuffer<'a>

pub fn new(buf: &[u8], head: usize) -> ReadBuffer<'_>

创建ReadBuffer, buf必须符合bon协议， 否则当调用其partial_cmp会直接panic head指定反序列化开始的位置

pub fn head(&self) -> usize

获取ReadBuffer当前的读指针（读是从头部开始，即下一次调用read方法，将从self.head位置向后反序列化）

pub fn len(&self) -> usize

二进制的长度

pub fn get_type(&mut self) -> Result<u8, ReadBonErr>

获取接下来要反序列化的数据的类型

pub fn get_type_chunk(&mut self) -> Result<u8, ReadBonErr>

获取接下来要反序列化的数据的类型(不改变bytes偏移)

pub fn read_bool(&mut self) -> Result<bool, ReadBonErr>

读一个布尔类型，如果二进制当前的值不是布尔类型，返回Err

pub fn read_u8(&mut self) -> Result<u8, ReadBonErr>

读一个u8类型，如果二进制当前的值不是u8类型，返回Err

pub fn read_u16(&mut self) -> Result<u16, ReadBonErr>

读一个u16类型，如果二进制当前的值不是u16类型，返回Err

pub fn read_u32(&mut self) -> Result<u32, ReadBonErr>

读一个u32类型，如果二进制当前的值不是u32类型，返回Err

pub fn read_u64(&mut self) -> Result<u64, ReadBonErr>

读一个u64类型，如果二进制当前的值不是u64类型，返回Err

pub fn read_usize(&mut self) -> Result<usize, ReadBonErr>

读一个usize类型，如果二进制当前的值不是usize类型，返回Err

pub fn read_u128(&mut self) -> Result<u128, ReadBonErr>

读一个u128类型，如果二进制当前的值不是u128类型，返回Err

pub fn read_i8(&mut self) -> Result<i8, ReadBonErr>

读一个i8类型，如果二进制当前的值不是i8类型，返回Err

pub fn read_i16(&mut self) -> Result<i16, ReadBonErr>

读一个i16类型，如果二进制当前的值不是i16类型，返回Err

pub fn read_i32(&mut self) -> Result<i32, ReadBonErr>

读一个ui32类型，如果二进制当前的值不是i32类型，返回Err

pub fn read_i64(&mut self) -> Result<i64, ReadBonErr>

读一个i61类型，如果二进制当前的值不是i64类型，返回Err

pub fn read_isize(&mut self) -> Result<isize, ReadBonErr>

读一个isize类型，如果二进制当前的值不是isize类型，返回Err

pub fn read_i128(&mut self) -> Result<i128, ReadBonErr>

读一个i128类型，如果二进制当前的值不是i128类型，返回Err

pub fn read_f32(&mut self) -> Result<f32, ReadBonErr>

读一个f32类型，如果二进制当前的值不是f32类型，返回Err

pub fn read_f64(&mut self) -> Result<f64, ReadBonErr>

读一个f64类型，如果二进制当前的值不是f64类型，返回Err

pub fn read_lengthen(&mut self) -> Result<u32, ReadBonErr>

读出一个动态长度，正整数，不允许大于0x20000000

pub fn read_bin(&mut self) -> Result<Vec<u8>, ReadBonErr>

pub fn read_utf8(&mut self) -> Result<String, ReadBonErr>

读一个utf8编码的字符串类型，如果二进制当前的值不是utf8编码的字符串类型类型，返回Err

pub fn read_container<T, F>(&mut self, read_next: F) -> Result<T, ReadBonErr>

where F: FnOnce(&mut ReadBuffer<'_>, u32, u64) -> Result<T, ReadBonErr>,

读一个容器类型，如果二进制当前的值不是容器类型，返回Err

pub fn is_nil(&mut self) -> Result<bool, ReadBonErr>

下一个值是否为None

pub fn read(&mut self) -> Result<EnumValue, ReadBonErr>

读下一个数据，已经读到最后，返回Err。否则，返回下一个数据

Trait Implementations

impl<'a> Clone for ReadBuffer<'a>

fn clone(&self) -> ReadBuffer<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for ReadBuffer<'a>

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

Formats the value using the given formatter.

impl<'a> Default for ReadBuffer<'a>

fn default() -> ReadBuffer<'a>

Returns the “default value” for a type.

impl<'a> Ord for ReadBuffer<'a>

fn cmp(&self, other: &ReadBuffer<'a>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl<'a> PartialEq for ReadBuffer<'a>

fn eq(&self, other: &ReadBuffer<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> PartialOrd for ReadBuffer<'a>

fn partial_cmp(&self, other: &ReadBuffer<'a>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a> Eq for ReadBuffer<'a>