use crate::bits::reader::BitReader;
pub trait Byteable: Sized {
fn to_bytes(&self) -> Vec<u8>;
fn from_bytes<R: Reader>(reader: &mut R) -> Option<Self>;
}
pub trait Bittable: Sized {
fn to_bytes(&self) -> Vec<u8>;
fn from_bits(reader: &mut BitReader) -> Option<Self>;
}
pub trait Builder {
fn push_u8(&mut self, value: u8);
fn push_u16(&mut self, value: u16) {
self.push_bytes(&value.to_le_bytes());
}
fn push_u32(&mut self, value: u32) {
self.push_bytes(&value.to_le_bytes());
}
fn push_u64(&mut self, value: u64) {
self.push_bytes(&value.to_le_bytes());
}
fn push_u128(&mut self, value: u128) {
self.push_bytes(&value.to_le_bytes());
}
fn push_i8(&mut self, value: i8) {
self.push_bytes(&value.to_le_bytes());
}
fn push_i16(&mut self, value: i16) {
self.push_bytes(&value.to_le_bytes());
}
fn push_i32(&mut self, value: i32) {
self.push_bytes(&value.to_le_bytes());
}
fn push_i64(&mut self, value: i64) {
self.push_bytes(&value.to_le_bytes());
}
fn push_i128(&mut self, value: i128) {
self.push_bytes(&value.to_le_bytes());
}
fn push_f32(&mut self, value: f32) {
self.push_bytes(&value.to_le_bytes());
}
fn push_f64(&mut self, value: f64) {
self.push_bytes(&value.to_le_bytes());
}
fn push_bool(&mut self, value: bool) {
self.push_u8(value as u8);
}
fn push_bytes(&mut self, value: &[u8]) {
for &byte in value {
self.push_u8(byte);
}
}
fn push_str(&mut self, value: &str) {
let bytes = value.as_bytes();
self.push_bytes(bytes);
}
fn push_len_prefixed_bytes(&mut self, value: &[u8]) {
self.push_u32(value.len() as u32);
self.push_bytes(value);
}
fn push_len_prefixed_str(&mut self, value: &str) {
self.push_u32(value.len() as u32);
self.push_str(value);
}
fn push<T: Byteable>(&mut self, value: T) {
let bytes = value.to_bytes();
self.push_bytes(&bytes);
}
fn with_u8(&mut self, value: u8) -> &mut Self {
self.push_u8(value);
self
}
fn with_u16(&mut self, value: u16) -> &mut Self {
self.push_u16(value);
self
}
fn with_u32(&mut self, value: u32) -> &mut Self {
self.push_u32(value);
self
}
fn with_u64(&mut self, value: u64) -> &mut Self {
self.push_u64(value);
self
}
fn with_u128(&mut self, value: u128) -> &mut Self {
self.push_u128(value);
self
}
fn with_i8(&mut self, value: i8) -> &mut Self {
self.push_i8(value);
self
}
fn with_i16(&mut self, value: i16) -> &mut Self {
self.push_i16(value);
self
}
fn with_i32(&mut self, value: i32) -> &mut Self {
self.push_i32(value);
self
}
fn with_i64(&mut self, value: i64) -> &mut Self {
self.push_i64(value);
self
}
fn with_i128(&mut self, value: i128) -> &mut Self {
self.push_i128(value);
self
}
fn with_f32(&mut self, value: f32) -> &mut Self {
self.push_f32(value);
self
}
fn with_f64(&mut self, value: f64) -> &mut Self {
self.push_f64(value);
self
}
fn with_bool(&mut self, value: bool) -> &mut Self {
self.push_bool(value);
self
}
fn with_len_prefixed_str(&mut self, value: &str) -> &mut Self {
self.push_len_prefixed_str(value);
self
}
fn with_len_prefixed_bytes(&mut self, value: &[u8]) -> &mut Self {
self.push_len_prefixed_bytes(value);
self
}
fn with_bytes(&mut self, value: &[u8]) -> &mut Self {
self.push_bytes(value);
self
}
fn with_str(&mut self, value: &str) -> &mut Self {
self.push_str(value);
self
}
fn with<T: Byteable>(&mut self, value: T) -> &mut Self {
self.push(value);
self
}
fn as_slice(&self) -> &[u8];
fn build(self) -> Vec<u8>;
}
pub trait Reader {
fn read_u8(&mut self) -> Option<u8>;
fn read_u16(&mut self) -> Option<u16> {
if self.remaining() < 2 {
return None;
}
let value = u16::from_le_bytes([self.read_u8()?, self.read_u8()?]);
Some(value)
}
fn read_u32(&mut self) -> Option<u32> {
if self.remaining() < 4 {
return None;
}
let value = u32::from_le_bytes(self.read_bytes(4)?.try_into().ok()?);
Some(value)
}
fn read_u64(&mut self) -> Option<u64> {
if self.remaining() < 8 {
return None;
}
let value = u64::from_le_bytes(self.read_bytes(8)?.try_into().ok()?);
Some(value)
}
fn read_u128(&mut self) -> Option<u128> {
if self.remaining() < 16 {
return None;
}
let value = u128::from_le_bytes(self.read_bytes(16)?.try_into().ok()?);
Some(value)
}
fn read_i8(&mut self) -> Option<i8> {
if self.remaining() < 1 {
return None;
}
let value = i8::from_le_bytes([self.read_u8()?]);
Some(value)
}
fn read_i16(&mut self) -> Option<i16> {
if self.remaining() < 2 {
return None;
}
let value = i16::from_le_bytes([self.read_u8()?, self.read_u8()?]);
Some(value)
}
fn read_i32(&mut self) -> Option<i32> {
if self.remaining() < 4 {
return None;
}
let value = i32::from_le_bytes(self.read_bytes(4)?.try_into().ok()?);
Some(value)
}
fn read_i64(&mut self) -> Option<i64> {
if self.remaining() < 8 {
return None;
}
let value = i64::from_le_bytes(self.read_bytes(8)?.try_into().ok()?);
Some(value)
}
fn read_i128(&mut self) -> Option<i128> {
if self.remaining() < 16 {
return None;
}
let value = i128::from_le_bytes(self.read_bytes(16)?.try_into().ok()?);
Some(value)
}
fn read_f32(&mut self) -> Option<f32> {
if self.remaining() < 4 {
return None;
}
let value = f32::from_le_bytes(self.read_bytes(4)?.try_into().ok()?);
Some(value)
}
fn read_f64(&mut self) -> Option<f64> {
if self.remaining() < 8 {
return None;
}
let value = f64::from_le_bytes(self.read_bytes(8)?.try_into().ok()?);
Some(value)
}
fn read_bool(&mut self) -> Option<bool> {
if self.remaining() < 1 {
return None;
}
let value = self.read_u8()?;
Some(value != 0)
}
fn read_str(&mut self, len: usize) -> Option<String> {
let bytes = self.read_bytes(len)?;
String::from_utf8(bytes).ok()
}
fn read_bytes(&mut self, len: usize) -> Option<Vec<u8>> {
if self.remaining() < len {
return None;
}
let mut buf = vec![0; len];
for i in 0..len {
buf[i] = self.read_u8()?;
}
Some(buf)
}
fn read_len_prefixed_str(&mut self) -> Option<String> {
let len = self.read_u32()?;
self.read_str(len as usize)
}
fn read_len_prefixed_bytes(&mut self) -> Option<Vec<u8>> {
let len = self.read_u32()?;
self.read_bytes(len as usize)
}
fn read<T: Byteable>(&mut self) -> Option<T>;
fn remaining(&self) -> usize;
fn reset(&mut self);
fn skip(&mut self, len: usize) -> bool;
}