macro_rules! impl_read_buf {
() => {
#[inline]
pub fn advance(&mut self, cnt: usize) {
let new = self.filled.checked_add(cnt).expect("filled overflow");
assert!(
new <= self.buf.len(),
"filled must not become larger than buf.len()"
);
self.filled = new;
}
#[inline]
pub fn buf(&self) -> &[u8] {
&self.buf
}
#[inline]
pub fn buf_mut(&mut self) -> &mut [u8] {
&mut self.buf
}
#[inline]
pub fn filled(&self) -> usize {
self.filled
}
#[inline]
pub fn left(&self) -> usize {
self.buf.len() - self.filled
}
#[inline]
pub fn clear(&mut self) {
self.filled = 0;
}
#[inline]
pub fn set_filled(&mut self, filled: usize) {
assert!(
self.buf.len() >= filled,
"filled must not become larger than buf.len()"
);
self.filled = filled;
}
#[inline]
pub fn set(&mut self, val: u8) {
assert!(
self.left() >= 1,
"left() must large than 1"
);
self.buf[self.filled] = val;
}
#[inline]
pub fn put(&mut self, val: u8) {
self.set(val);
self.filled += 1;
}
#[inline]
pub fn set_slice(&mut self, slice: &[u8]) {
assert!(
self.left() >= slice.len(),
"buf.len() must fit in remaining()"
);
self.buf[self.filled..self.filled + slice.len()].copy_from_slice(slice);
}
#[inline]
pub fn put_slice(&mut self, slice: &[u8]) {
self.set_slice(slice);
self.filled += slice.len();
}
};
}
#[cfg(feature = "bytes")]
macro_rules! impl_buf_mut {
() => {
#[inline]
fn remaining_mut(&self) -> usize {
self.left()
}
#[inline]
unsafe fn advance_mut(&mut self, cnt: usize) {
self.advance(cnt)
}
#[inline]
fn chunk_mut(&mut self) -> &mut bytes::buf::UninitSlice {
bytes::buf::UninitSlice::new(self.buf_mut())
}
};
}
#[derive(Debug)]
pub struct ReadBuf<'a> {
buf: &'a mut [u8],
filled: usize,
}
impl<'a> ReadBuf<'a> {
pub fn new(buf: &'a mut [u8]) -> Self {
Self {
buf,
filled: 0,
}
}
impl_read_buf!();
}
#[cfg(feature = "bytes")]
#[cfg_attr(docsrs, doc(cfg(feature = "bytes")))]
unsafe impl<'a> bytes::BufMut for ReadBuf<'a> {
impl_buf_mut!();
}
#[cfg(feature = "async")]
#[cfg_attr(docsrs, doc(cfg(feature = "async")))]
impl<'a, 'b> From<&'b mut ReadBuf<'a>> for tokio::io::ReadBuf<'b> {
#[inline]
fn from(value: &'b mut ReadBuf<'a>) -> Self {
let mut buf = Self::new(value.buf);
buf.set_filled(value.filled);
buf
}
}
macro_rules! impl_write_buf {
() => {
#[inline]
pub fn skip(&mut self, cnt: usize) {
let new = self.read.checked_add(cnt).expect("read overflow");
assert!(
new <= self.buf.len(),
"read must not become larger than buf.len()"
);
self.read = new;
}
#[inline]
pub fn buf(&self) -> &[u8] {
&self.buf
}
#[inline]
pub fn read(&self) -> usize {
self.read
}
#[inline]
pub fn left(&self) -> usize {
self.buf.len() - self.read
}
#[inline]
pub fn reset(&mut self) {
self.read = 0;
}
#[inline]
pub fn set_read(&mut self, read: usize) {
assert!(
self.buf.len() >= read,
"read must not become larger than buf.len()"
);
self.read = read;
}
#[inline]
pub fn get(&self) -> u8 {
assert!(
self.left() >= 1,
"left() must large than 1"
);
self.buf[self.read]
}
#[inline]
pub fn take(&mut self) -> u8 {
let val = self.get();
self.read += 1;
val
}
#[inline]
pub fn get_slice(&self, len: usize) -> &[u8] {
assert!(
self.left() >= len,
"left() must large than len"
);
&self.buf[self.read..self.read + len]
}
#[inline]
pub fn take_slice(&mut self, len: usize) -> &[u8] {
assert!(
self.left() >= len,
"left() must large than len"
);
let slice = &self.buf[self.read..self.read + len];
self.read += len;
slice
}
};
}
#[cfg(feature = "bytes")]
macro_rules! impl_buf {
() => {
#[inline]
fn remaining(&self) -> usize {
self.left()
}
#[inline]
fn chunk(&self) -> &[u8] {
self.buf()
}
#[inline]
fn advance(&mut self, cnt: usize) {
self.skip(cnt)
}
};
}
#[derive(Debug)]
pub struct WriteBuf<'a> {
buf: &'a [u8],
read: usize,
}
impl<'a> WriteBuf<'a> {
pub fn new(buf: &'a [u8]) -> Self {
Self {
buf,
read: 0,
}
}
impl_write_buf!();
}
#[cfg(feature = "bytes")]
#[cfg_attr(docsrs, doc(cfg(feature = "bytes")))]
impl<'a> bytes::Buf for WriteBuf<'a> {
impl_buf!();
}
#[macro_export]
macro_rules! define_read_buf {
($name: ident, $n: expr) => {
#[derive(Debug)]
pub struct $name {
buf: [u8; $n],
filled: usize,
}
impl $name {
#[inline]
pub fn new() -> Self {
Self {
buf: [0; $n],
filled: 0,
}
}
#[inline]
pub fn into_inner(&self) -> [u8; $n] {
self.buf
}
impl_read_buf!();
}
#[cfg(feature = "bytes")]
#[cfg_attr(docsrs, doc(cfg(feature = "bytes")))]
unsafe impl bytes::BufMut for $name {
impl_buf_mut!();
}
impl<'a> From<&'a mut $name> for ReadBuf<'a> {
#[inline]
fn from(value: &'a mut $name) -> Self {
Self {
buf: &mut value.buf,
filled: value.filled,
}
}
}
};
}
define_read_buf!(OwnedReadBuf8, std::mem::size_of::<u8>());
define_read_buf!(OwnedReadBuf16, std::mem::size_of::<u16>());
define_read_buf!(OwnedReadBuf32, std::mem::size_of::<u32>());
define_read_buf!(OwnedReadBuf64, std::mem::size_of::<u64>());
define_read_buf!(OwnedReadBuf128, std::mem::size_of::<u128>());
#[macro_export]
macro_rules! define_write_buf {
($name: ident, $n: expr) => {
#[derive(Debug)]
pub struct $name {
buf: [u8; $n],
read: usize,
}
impl $name {
#[inline]
pub fn new(buf: [u8; $n]) -> Self {
Self {
buf,
read: 0,
}
}
#[inline]
pub fn into_inner(&self) -> [u8; $n] {
self.buf
}
#[inline]
pub fn buf_mut(&mut self) -> &mut [u8] {
&mut self.buf
}
#[inline]
pub fn set_buf(&mut self, buf: [u8; $n]) {
self.buf = buf;
}
impl_write_buf!();
}
#[cfg(feature = "bytes")]
#[cfg_attr(docsrs, doc(cfg(feature = "bytes")))]
impl bytes::Buf for $name {
impl_buf!();
}
impl<'a> From<&'a $name> for WriteBuf<'a> {
#[inline]
fn from(value: &'a $name) -> Self {
Self {
buf: &value.buf,
read: value.read,
}
}
}
};
}
define_write_buf!(OwnedWriteBuf8, std::mem::size_of::<u8>());
define_write_buf!(OwnedWriteBuf16, std::mem::size_of::<u16>());
define_write_buf!(OwnedWriteBuf32, std::mem::size_of::<u32>());
define_write_buf!(OwnedWriteBuf64, std::mem::size_of::<u64>());
define_write_buf!(OwnedWriteBuf128, std::mem::size_of::<u128>());