mirror of
https://github.com/ntex-rs/ntex.git
synced 2025-04-06 06:17:40 +03:00
939 lines
25 KiB
Rust
939 lines
25 KiB
Rust
use std::{cmp, io::IoSlice, mem, ptr};
|
|
|
|
macro_rules! buf_get_impl {
|
|
($this:ident, $typ:tt::$conv:tt) => {{
|
|
const SIZE: usize = mem::size_of::<$typ>();
|
|
// try to convert directly from the bytes
|
|
// this Option<ret> trick is to avoid keeping a borrow on self
|
|
// when advance() is called (mut borrow) and to call bytes() only once
|
|
let ret = $this
|
|
.chunk()
|
|
.get(..SIZE)
|
|
.map(|src| unsafe { $typ::$conv(*(src as *const _ as *const [_; SIZE])) });
|
|
|
|
if let Some(ret) = ret {
|
|
// if the direct conversion was possible, advance and return
|
|
$this.advance(SIZE);
|
|
return ret;
|
|
} else {
|
|
// if not we copy the bytes in a temp buffer then convert
|
|
let mut buf = [0; SIZE];
|
|
$this.copy_to_slice(&mut buf); // (do the advance)
|
|
return $typ::$conv(buf);
|
|
}
|
|
}};
|
|
(le => $this:ident, $typ:tt, $len_to_read:expr) => {{
|
|
debug_assert!(mem::size_of::<$typ>() >= $len_to_read);
|
|
|
|
// The same trick as above does not improve the best case speed.
|
|
// It seems to be linked to the way the method is optimised by the compiler
|
|
let mut buf = [0; (mem::size_of::<$typ>())];
|
|
$this.copy_to_slice(&mut buf[..($len_to_read)]);
|
|
return $typ::from_le_bytes(buf);
|
|
}};
|
|
(be => $this:ident, $typ:tt, $len_to_read:expr) => {{
|
|
debug_assert!(mem::size_of::<$typ>() >= $len_to_read);
|
|
|
|
let mut buf = [0; (mem::size_of::<$typ>())];
|
|
$this.copy_to_slice(&mut buf[mem::size_of::<$typ>() - ($len_to_read)..]);
|
|
return $typ::from_be_bytes(buf);
|
|
}};
|
|
}
|
|
|
|
/// Read bytes from a buffer.
|
|
///
|
|
/// A buffer stores bytes in memory such that read operations are infallible.
|
|
/// The underlying storage may or may not be in contiguous memory. A `Buf` value
|
|
/// is a cursor into the buffer. Reading from `Buf` advances the cursor
|
|
/// position. It can be thought of as an efficient `Iterator` for collections of
|
|
/// bytes.
|
|
///
|
|
/// The simplest `Buf` is a `&[u8]`.
|
|
///
|
|
/// ```
|
|
/// use ntex_bytes::Buf;
|
|
///
|
|
/// let mut buf = &b"hello world"[..];
|
|
///
|
|
/// assert_eq!(b'h', buf.get_u8());
|
|
/// assert_eq!(b'e', buf.get_u8());
|
|
/// assert_eq!(b'l', buf.get_u8());
|
|
///
|
|
/// let mut rest = [0; 8];
|
|
/// buf.copy_to_slice(&mut rest);
|
|
///
|
|
/// assert_eq!(&rest[..], &b"lo world"[..]);
|
|
/// ```
|
|
pub trait Buf {
|
|
/// Returns the number of bytes between the current position and the end of
|
|
/// the buffer.
|
|
///
|
|
/// This value is greater than or equal to the length of the slice returned
|
|
/// by `bytes`.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// use ntex_bytes::Buf;
|
|
///
|
|
/// let mut buf = &b"hello world"[..];
|
|
///
|
|
/// assert_eq!(buf.remaining(), 11);
|
|
///
|
|
/// buf.get_u8();
|
|
///
|
|
/// assert_eq!(buf.remaining(), 10);
|
|
/// ```
|
|
///
|
|
/// # Implementer notes
|
|
///
|
|
/// Implementations of `remaining` should ensure that the return value does
|
|
/// not change unless a call is made to `advance` or any other function that
|
|
/// is documented to change the `Buf`'s current position.
|
|
fn remaining(&self) -> usize;
|
|
|
|
/// Returns a slice starting at the current position and of length between 0
|
|
/// and `Buf::remaining()`. Note that this *can* return shorter slice (this allows
|
|
/// non-continuous internal representation).
|
|
///
|
|
/// This is a lower level function. Most operations are done with other
|
|
/// functions.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// use ntex_bytes::Buf;
|
|
///
|
|
/// let mut buf = &b"hello world"[..];
|
|
///
|
|
/// assert_eq!(buf.chunk(), &b"hello world"[..]);
|
|
///
|
|
/// buf.advance(6);
|
|
///
|
|
/// assert_eq!(buf.chunk(), &b"world"[..]);
|
|
/// ```
|
|
///
|
|
/// # Implementer notes
|
|
///
|
|
/// This function should never panic. Once the end of the buffer is reached,
|
|
/// i.e., `Buf::remaining` returns 0, calls to `chunk` should return an
|
|
/// empty slice.
|
|
fn chunk(&self) -> &[u8];
|
|
|
|
/// Fills `dst` with potentially multiple slices starting at `self`'s
|
|
/// current position.
|
|
///
|
|
/// If the `Buf` is backed by disjoint slices of bytes, `bytes_vectored` enables
|
|
/// fetching more than one slice at once. `dst` is a slice of `IoSlice`
|
|
/// references, enabling the slice to be directly used with [`writev`]
|
|
/// without any further conversion. The sum of the lengths of all the
|
|
/// buffers in `dst` will be less than or equal to `Buf::remaining()`.
|
|
///
|
|
/// The entries in `dst` will be overwritten, but the data **contained** by
|
|
/// the slices **will not** be modified. If `bytes_vectored` does not fill every
|
|
/// entry in `dst`, then `dst` is guaranteed to contain all remaining slices
|
|
/// in `self.
|
|
///
|
|
/// This is a lower level function. Most operations are done with other
|
|
/// functions.
|
|
///
|
|
/// # Implementer notes
|
|
///
|
|
/// This function should never panic. Once the end of the buffer is reached,
|
|
/// i.e., `Buf::remaining` returns 0, calls to `bytes_vectored` must return 0
|
|
/// without mutating `dst`.
|
|
///
|
|
/// Implementations should also take care to properly handle being called
|
|
/// with `dst` being a zero length slice.
|
|
///
|
|
/// [`writev`]: http://man7.org/linux/man-pages/man2/readv.2.html
|
|
fn bytes_vectored<'a>(&'a self, dst: &mut [IoSlice<'a>]) -> usize {
|
|
if dst.is_empty() {
|
|
return 0;
|
|
}
|
|
|
|
if self.has_remaining() {
|
|
dst[0] = IoSlice::new(self.chunk());
|
|
1
|
|
} else {
|
|
0
|
|
}
|
|
}
|
|
|
|
/// Advance the internal cursor of the Buf
|
|
///
|
|
/// The next call to `bytes` will return a slice starting `cnt` bytes
|
|
/// further into the underlying buffer.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// use ntex_bytes::Buf;
|
|
///
|
|
/// let mut buf = &b"hello world"[..];
|
|
///
|
|
/// assert_eq!(buf.chunk(), &b"hello world"[..]);
|
|
///
|
|
/// buf.advance(6);
|
|
///
|
|
/// assert_eq!(buf.chunk(), &b"world"[..]);
|
|
/// ```
|
|
///
|
|
/// # Panics
|
|
///
|
|
/// This function **may** panic if `cnt > self.remaining()`.
|
|
///
|
|
/// # Implementer notes
|
|
///
|
|
/// It is recommended for implementations of `advance` to panic if `cnt >
|
|
/// self.remaining()`. If the implementation does not panic, the call must
|
|
/// behave as if `cnt == self.remaining()`.
|
|
///
|
|
/// A call with `cnt == 0` should never panic and be a no-op.
|
|
fn advance(&mut self, cnt: usize);
|
|
|
|
/// Returns true if there are any more bytes to consume
|
|
///
|
|
/// This is equivalent to `self.remaining() != 0`.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// use ntex_bytes::Buf;
|
|
///
|
|
/// let mut buf = &b"a"[..];
|
|
///
|
|
/// assert!(buf.has_remaining());
|
|
///
|
|
/// buf.get_u8();
|
|
///
|
|
/// assert!(!buf.has_remaining());
|
|
/// ```
|
|
fn has_remaining(&self) -> bool {
|
|
self.remaining() > 0
|
|
}
|
|
|
|
/// Copies bytes from `self` into `dst`.
|
|
///
|
|
/// The cursor is advanced by the number of bytes copied. `self` must have
|
|
/// enough remaining bytes to fill `dst`.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// use ntex_bytes::Buf;
|
|
///
|
|
/// let mut buf = &b"hello world"[..];
|
|
/// let mut dst = [0; 5];
|
|
///
|
|
/// buf.copy_to_slice(&mut dst);
|
|
/// assert_eq!(&b"hello"[..], &dst);
|
|
/// assert_eq!(6, buf.remaining());
|
|
/// ```
|
|
///
|
|
/// # Panics
|
|
///
|
|
/// This function panics if `self.remaining() < dst.len()`
|
|
fn copy_to_slice(&mut self, dst: &mut [u8]) {
|
|
let mut off = 0;
|
|
|
|
assert!(self.remaining() >= dst.len());
|
|
|
|
while off < dst.len() {
|
|
let cnt;
|
|
|
|
unsafe {
|
|
let src = self.chunk();
|
|
cnt = cmp::min(src.len(), dst.len() - off);
|
|
|
|
ptr::copy_nonoverlapping(src.as_ptr(), dst[off..].as_mut_ptr(), cnt);
|
|
|
|
off += cnt;
|
|
}
|
|
|
|
self.advance(cnt);
|
|
}
|
|
}
|
|
|
|
/// Gets an unsigned 8 bit integer from `self`.
|
|
///
|
|
/// The current position is advanced by 1.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// use ntex_bytes::Buf;
|
|
///
|
|
/// let mut buf = &b"\x08 hello"[..];
|
|
/// assert_eq!(8, buf.get_u8());
|
|
/// ```
|
|
///
|
|
/// # Panics
|
|
///
|
|
/// This function panics if there is no more remaining data in `self`.
|
|
fn get_u8(&mut self) -> u8 {
|
|
assert!(self.remaining() >= 1);
|
|
let ret = self.chunk()[0];
|
|
self.advance(1);
|
|
ret
|
|
}
|
|
|
|
/// Gets a signed 8 bit integer from `self`.
|
|
///
|
|
/// The current position is advanced by 1.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// use ntex_bytes::Buf;
|
|
///
|
|
/// let mut buf = &b"\x08 hello"[..];
|
|
/// assert_eq!(8, buf.get_i8());
|
|
/// ```
|
|
///
|
|
/// # Panics
|
|
///
|
|
/// This function panics if there is no more remaining data in `self`.
|
|
fn get_i8(&mut self) -> i8 {
|
|
assert!(self.remaining() >= 1);
|
|
let ret = self.chunk()[0] as i8;
|
|
self.advance(1);
|
|
ret
|
|
}
|
|
|
|
/// Gets an unsigned 16 bit integer from `self` in big-endian byte order.
|
|
///
|
|
/// The current position is advanced by 2.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// use ntex_bytes::Buf;
|
|
///
|
|
/// let mut buf = &b"\x08\x09 hello"[..];
|
|
/// assert_eq!(0x0809, buf.get_u16());
|
|
/// ```
|
|
///
|
|
/// # Panics
|
|
///
|
|
/// This function panics if there is not enough remaining data in `self`.
|
|
fn get_u16(&mut self) -> u16 {
|
|
buf_get_impl!(self, u16::from_be_bytes);
|
|
}
|
|
|
|
/// Gets an unsigned 16 bit integer from `self` in little-endian byte order.
|
|
///
|
|
/// The current position is advanced by 2.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// use ntex_bytes::Buf;
|
|
///
|
|
/// let mut buf = &b"\x09\x08 hello"[..];
|
|
/// assert_eq!(0x0809, buf.get_u16_le());
|
|
/// ```
|
|
///
|
|
/// # Panics
|
|
///
|
|
/// This function panics if there is not enough remaining data in `self`.
|
|
fn get_u16_le(&mut self) -> u16 {
|
|
buf_get_impl!(self, u16::from_le_bytes);
|
|
}
|
|
|
|
/// Gets a signed 16 bit integer from `self` in big-endian byte order.
|
|
///
|
|
/// The current position is advanced by 2.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// use ntex_bytes::Buf;
|
|
///
|
|
/// let mut buf = &b"\x08\x09 hello"[..];
|
|
/// assert_eq!(0x0809, buf.get_i16());
|
|
/// ```
|
|
///
|
|
/// # Panics
|
|
///
|
|
/// This function panics if there is not enough remaining data in `self`.
|
|
fn get_i16(&mut self) -> i16 {
|
|
buf_get_impl!(self, i16::from_be_bytes);
|
|
}
|
|
|
|
/// Gets a signed 16 bit integer from `self` in little-endian byte order.
|
|
///
|
|
/// The current position is advanced by 2.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// use ntex_bytes::Buf;
|
|
///
|
|
/// let mut buf = &b"\x09\x08 hello"[..];
|
|
/// assert_eq!(0x0809, buf.get_i16_le());
|
|
/// ```
|
|
///
|
|
/// # Panics
|
|
///
|
|
/// This function panics if there is not enough remaining data in `self`.
|
|
fn get_i16_le(&mut self) -> i16 {
|
|
buf_get_impl!(self, i16::from_le_bytes);
|
|
}
|
|
|
|
/// Gets an unsigned 32 bit integer from `self` in the big-endian byte order.
|
|
///
|
|
/// The current position is advanced by 4.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// use ntex_bytes::Buf;
|
|
///
|
|
/// let mut buf = &b"\x08\x09\xA0\xA1 hello"[..];
|
|
/// assert_eq!(0x0809A0A1, buf.get_u32());
|
|
/// ```
|
|
///
|
|
/// # Panics
|
|
///
|
|
/// This function panics if there is not enough remaining data in `self`.
|
|
fn get_u32(&mut self) -> u32 {
|
|
buf_get_impl!(self, u32::from_be_bytes);
|
|
}
|
|
|
|
/// Gets an unsigned 32 bit integer from `self` in the little-endian byte order.
|
|
///
|
|
/// The current position is advanced by 4.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// use ntex_bytes::Buf;
|
|
///
|
|
/// let mut buf = &b"\xA1\xA0\x09\x08 hello"[..];
|
|
/// assert_eq!(0x0809A0A1, buf.get_u32_le());
|
|
/// ```
|
|
///
|
|
/// # Panics
|
|
///
|
|
/// This function panics if there is not enough remaining data in `self`.
|
|
fn get_u32_le(&mut self) -> u32 {
|
|
buf_get_impl!(self, u32::from_le_bytes);
|
|
}
|
|
|
|
/// Gets a signed 32 bit integer from `self` in big-endian byte order.
|
|
///
|
|
/// The current position is advanced by 4.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// use ntex_bytes::Buf;
|
|
///
|
|
/// let mut buf = &b"\x08\x09\xA0\xA1 hello"[..];
|
|
/// assert_eq!(0x0809A0A1, buf.get_i32());
|
|
/// ```
|
|
///
|
|
/// # Panics
|
|
///
|
|
/// This function panics if there is not enough remaining data in `self`.
|
|
fn get_i32(&mut self) -> i32 {
|
|
buf_get_impl!(self, i32::from_be_bytes);
|
|
}
|
|
|
|
/// Gets a signed 32 bit integer from `self` in little-endian byte order.
|
|
///
|
|
/// The current position is advanced by 4.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// use ntex_bytes::Buf;
|
|
///
|
|
/// let mut buf = &b"\xA1\xA0\x09\x08 hello"[..];
|
|
/// assert_eq!(0x0809A0A1, buf.get_i32_le());
|
|
/// ```
|
|
///
|
|
/// # Panics
|
|
///
|
|
/// This function panics if there is not enough remaining data in `self`.
|
|
fn get_i32_le(&mut self) -> i32 {
|
|
buf_get_impl!(self, i32::from_le_bytes);
|
|
}
|
|
|
|
/// Gets an unsigned 64 bit integer from `self` in big-endian byte order.
|
|
///
|
|
/// The current position is advanced by 8.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// use ntex_bytes::Buf;
|
|
///
|
|
/// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08 hello"[..];
|
|
/// assert_eq!(0x0102030405060708, buf.get_u64());
|
|
/// ```
|
|
///
|
|
/// # Panics
|
|
///
|
|
/// This function panics if there is not enough remaining data in `self`.
|
|
fn get_u64(&mut self) -> u64 {
|
|
buf_get_impl!(self, u64::from_be_bytes);
|
|
}
|
|
|
|
/// Gets an unsigned 64 bit integer from `self` in little-endian byte order.
|
|
///
|
|
/// The current position is advanced by 8.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// use ntex_bytes::Buf;
|
|
///
|
|
/// let mut buf = &b"\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..];
|
|
/// assert_eq!(0x0102030405060708, buf.get_u64_le());
|
|
/// ```
|
|
///
|
|
/// # Panics
|
|
///
|
|
/// This function panics if there is not enough remaining data in `self`.
|
|
fn get_u64_le(&mut self) -> u64 {
|
|
buf_get_impl!(self, u64::from_le_bytes);
|
|
}
|
|
|
|
/// Gets a signed 64 bit integer from `self` in big-endian byte order.
|
|
///
|
|
/// The current position is advanced by 8.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// use ntex_bytes::Buf;
|
|
///
|
|
/// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08 hello"[..];
|
|
/// assert_eq!(0x0102030405060708, buf.get_i64());
|
|
/// ```
|
|
///
|
|
/// # Panics
|
|
///
|
|
/// This function panics if there is not enough remaining data in `self`.
|
|
fn get_i64(&mut self) -> i64 {
|
|
buf_get_impl!(self, i64::from_be_bytes);
|
|
}
|
|
|
|
/// Gets a signed 64 bit integer from `self` in little-endian byte order.
|
|
///
|
|
/// The current position is advanced by 8.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// use ntex_bytes::Buf;
|
|
///
|
|
/// let mut buf = &b"\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..];
|
|
/// assert_eq!(0x0102030405060708, buf.get_i64_le());
|
|
/// ```
|
|
///
|
|
/// # Panics
|
|
///
|
|
/// This function panics if there is not enough remaining data in `self`.
|
|
fn get_i64_le(&mut self) -> i64 {
|
|
buf_get_impl!(self, i64::from_le_bytes);
|
|
}
|
|
|
|
/// Gets an unsigned 128 bit integer from `self` in big-endian byte order.
|
|
///
|
|
/// The current position is advanced by 16.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// use ntex_bytes::Buf;
|
|
///
|
|
/// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16 hello"[..];
|
|
/// assert_eq!(0x01020304050607080910111213141516, buf.get_u128());
|
|
/// ```
|
|
///
|
|
/// # Panics
|
|
///
|
|
/// This function panics if there is not enough remaining data in `self`.
|
|
fn get_u128(&mut self) -> u128 {
|
|
buf_get_impl!(self, u128::from_be_bytes);
|
|
}
|
|
|
|
/// Gets an unsigned 128 bit integer from `self` in little-endian byte order.
|
|
///
|
|
/// The current position is advanced by 16.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// use ntex_bytes::Buf;
|
|
///
|
|
/// let mut buf = &b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..];
|
|
/// assert_eq!(0x01020304050607080910111213141516, buf.get_u128_le());
|
|
/// ```
|
|
///
|
|
/// # Panics
|
|
///
|
|
/// This function panics if there is not enough remaining data in `self`.
|
|
fn get_u128_le(&mut self) -> u128 {
|
|
buf_get_impl!(self, u128::from_le_bytes);
|
|
}
|
|
|
|
/// Gets a signed 128 bit integer from `self` in big-endian byte order.
|
|
///
|
|
/// The current position is advanced by 16.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// use ntex_bytes::Buf;
|
|
///
|
|
/// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16 hello"[..];
|
|
/// assert_eq!(0x01020304050607080910111213141516, buf.get_i128());
|
|
/// ```
|
|
///
|
|
/// # Panics
|
|
///
|
|
/// This function panics if there is not enough remaining data in `self`.
|
|
fn get_i128(&mut self) -> i128 {
|
|
buf_get_impl!(self, i128::from_be_bytes);
|
|
}
|
|
|
|
/// Gets a signed 128 bit integer from `self` in little-endian byte order.
|
|
///
|
|
/// The current position is advanced by 16.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// use ntex_bytes::Buf;
|
|
///
|
|
/// let mut buf = &b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..];
|
|
/// assert_eq!(0x01020304050607080910111213141516, buf.get_i128_le());
|
|
/// ```
|
|
///
|
|
/// # Panics
|
|
///
|
|
/// This function panics if there is not enough remaining data in `self`.
|
|
fn get_i128_le(&mut self) -> i128 {
|
|
buf_get_impl!(self, i128::from_le_bytes);
|
|
}
|
|
|
|
/// Gets an unsigned n-byte integer from `self` in big-endian byte order.
|
|
///
|
|
/// The current position is advanced by `nbytes`.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// use ntex_bytes::Buf;
|
|
///
|
|
/// let mut buf = &b"\x01\x02\x03 hello"[..];
|
|
/// assert_eq!(0x010203, buf.get_uint(3));
|
|
/// ```
|
|
///
|
|
/// # Panics
|
|
///
|
|
/// This function panics if there is not enough remaining data in `self`.
|
|
fn get_uint(&mut self, nbytes: usize) -> u64 {
|
|
buf_get_impl!(be => self, u64, nbytes);
|
|
}
|
|
|
|
/// Gets an unsigned n-byte integer from `self` in little-endian byte order.
|
|
///
|
|
/// The current position is advanced by `nbytes`.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// use ntex_bytes::Buf;
|
|
///
|
|
/// let mut buf = &b"\x03\x02\x01 hello"[..];
|
|
/// assert_eq!(0x010203, buf.get_uint_le(3));
|
|
/// ```
|
|
///
|
|
/// # Panics
|
|
///
|
|
/// This function panics if there is not enough remaining data in `self`.
|
|
fn get_uint_le(&mut self, nbytes: usize) -> u64 {
|
|
buf_get_impl!(le => self, u64, nbytes);
|
|
}
|
|
|
|
/// Gets a signed n-byte integer from `self` in big-endian byte order.
|
|
///
|
|
/// The current position is advanced by `nbytes`.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// use ntex_bytes::Buf;
|
|
///
|
|
/// let mut buf = &b"\x01\x02\x03 hello"[..];
|
|
/// assert_eq!(0x010203, buf.get_int(3));
|
|
/// ```
|
|
///
|
|
/// # Panics
|
|
///
|
|
/// This function panics if there is not enough remaining data in `self`.
|
|
fn get_int(&mut self, nbytes: usize) -> i64 {
|
|
buf_get_impl!(be => self, i64, nbytes);
|
|
}
|
|
|
|
/// Gets a signed n-byte integer from `self` in little-endian byte order.
|
|
///
|
|
/// The current position is advanced by `nbytes`.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// use ntex_bytes::Buf;
|
|
///
|
|
/// let mut buf = &b"\x03\x02\x01 hello"[..];
|
|
/// assert_eq!(0x010203, buf.get_int_le(3));
|
|
/// ```
|
|
///
|
|
/// # Panics
|
|
///
|
|
/// This function panics if there is not enough remaining data in `self`.
|
|
fn get_int_le(&mut self, nbytes: usize) -> i64 {
|
|
buf_get_impl!(le => self, i64, nbytes);
|
|
}
|
|
|
|
/// Gets an IEEE754 single-precision (4 bytes) floating point number from
|
|
/// `self` in big-endian byte order.
|
|
///
|
|
/// The current position is advanced by 4.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// use ntex_bytes::Buf;
|
|
///
|
|
/// let mut buf = &b"\x3F\x99\x99\x9A hello"[..];
|
|
/// assert_eq!(1.2f32, buf.get_f32());
|
|
/// ```
|
|
///
|
|
/// # Panics
|
|
///
|
|
/// This function panics if there is not enough remaining data in `self`.
|
|
fn get_f32(&mut self) -> f32 {
|
|
f32::from_bits(Self::get_u32(self))
|
|
}
|
|
|
|
/// Gets an IEEE754 single-precision (4 bytes) floating point number from
|
|
/// `self` in little-endian byte order.
|
|
///
|
|
/// The current position is advanced by 4.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// use ntex_bytes::Buf;
|
|
///
|
|
/// let mut buf = &b"\x9A\x99\x99\x3F hello"[..];
|
|
/// assert_eq!(1.2f32, buf.get_f32_le());
|
|
/// ```
|
|
///
|
|
/// # Panics
|
|
///
|
|
/// This function panics if there is not enough remaining data in `self`.
|
|
fn get_f32_le(&mut self) -> f32 {
|
|
f32::from_bits(Self::get_u32_le(self))
|
|
}
|
|
|
|
/// Gets an IEEE754 double-precision (8 bytes) floating point number from
|
|
/// `self` in big-endian byte order.
|
|
///
|
|
/// The current position is advanced by 8.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// use ntex_bytes::Buf;
|
|
///
|
|
/// let mut buf = &b"\x3F\xF3\x33\x33\x33\x33\x33\x33 hello"[..];
|
|
/// assert_eq!(1.2f64, buf.get_f64());
|
|
/// ```
|
|
///
|
|
/// # Panics
|
|
///
|
|
/// This function panics if there is not enough remaining data in `self`.
|
|
fn get_f64(&mut self) -> f64 {
|
|
f64::from_bits(Self::get_u64(self))
|
|
}
|
|
|
|
/// Gets an IEEE754 double-precision (8 bytes) floating point number from
|
|
/// `self` in little-endian byte order.
|
|
///
|
|
/// The current position is advanced by 8.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// use ntex_bytes::Buf;
|
|
///
|
|
/// let mut buf = &b"\x33\x33\x33\x33\x33\x33\xF3\x3F hello"[..];
|
|
/// assert_eq!(1.2f64, buf.get_f64_le());
|
|
/// ```
|
|
///
|
|
/// # Panics
|
|
///
|
|
/// This function panics if there is not enough remaining data in `self`.
|
|
fn get_f64_le(&mut self) -> f64 {
|
|
f64::from_bits(Self::get_u64_le(self))
|
|
}
|
|
|
|
/// Consumes remaining bytes inside self and returns new instance of `Bytes`
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// use ntex_bytes::{Buf};
|
|
///
|
|
/// let bytes = "hello world".to_bytes();
|
|
/// assert_eq!(&bytes[..], &b"hello world"[..]);
|
|
/// ```
|
|
fn to_bytes(&mut self) -> crate::Bytes {
|
|
use super::BufMut;
|
|
let mut ret = crate::BytesMut::with_capacity(self.remaining());
|
|
ret.put(self);
|
|
ret.freeze()
|
|
}
|
|
}
|
|
|
|
impl<T: Buf + ?Sized> Buf for &mut T {
|
|
fn remaining(&self) -> usize {
|
|
(**self).remaining()
|
|
}
|
|
|
|
fn chunk(&self) -> &[u8] {
|
|
(**self).chunk()
|
|
}
|
|
|
|
fn bytes_vectored<'b>(&'b self, dst: &mut [IoSlice<'b>]) -> usize {
|
|
(**self).bytes_vectored(dst)
|
|
}
|
|
|
|
fn advance(&mut self, cnt: usize) {
|
|
(**self).advance(cnt)
|
|
}
|
|
}
|
|
|
|
impl<T: Buf + ?Sized> Buf for Box<T> {
|
|
fn remaining(&self) -> usize {
|
|
(**self).remaining()
|
|
}
|
|
|
|
fn chunk(&self) -> &[u8] {
|
|
(**self).chunk()
|
|
}
|
|
|
|
fn bytes_vectored<'b>(&'b self, dst: &mut [IoSlice<'b>]) -> usize {
|
|
(**self).bytes_vectored(dst)
|
|
}
|
|
|
|
fn advance(&mut self, cnt: usize) {
|
|
(**self).advance(cnt)
|
|
}
|
|
}
|
|
|
|
impl Buf for &[u8] {
|
|
#[inline]
|
|
fn remaining(&self) -> usize {
|
|
self.len()
|
|
}
|
|
|
|
#[inline]
|
|
fn chunk(&self) -> &[u8] {
|
|
self
|
|
}
|
|
|
|
#[inline]
|
|
fn advance(&mut self, cnt: usize) {
|
|
*self = &self[cnt..];
|
|
}
|
|
}
|
|
|
|
impl Buf for &str {
|
|
#[inline]
|
|
fn remaining(&self) -> usize {
|
|
self.len()
|
|
}
|
|
|
|
#[inline]
|
|
fn chunk(&self) -> &[u8] {
|
|
self.as_bytes()
|
|
}
|
|
|
|
#[inline]
|
|
fn advance(&mut self, cnt: usize) {
|
|
*self = &self[cnt..];
|
|
}
|
|
}
|
|
|
|
impl Buf for Option<[u8; 1]> {
|
|
fn remaining(&self) -> usize {
|
|
if self.is_some() {
|
|
1
|
|
} else {
|
|
0
|
|
}
|
|
}
|
|
|
|
fn chunk(&self) -> &[u8] {
|
|
self.as_ref()
|
|
.map(AsRef::as_ref)
|
|
.unwrap_or(Default::default())
|
|
}
|
|
|
|
fn advance(&mut self, cnt: usize) {
|
|
if cnt == 0 {
|
|
return;
|
|
}
|
|
|
|
if self.is_none() {
|
|
panic!("overflow");
|
|
} else {
|
|
assert_eq!(1, cnt);
|
|
*self = None;
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<T: AsRef<[u8]>> Buf for std::io::Cursor<T> {
|
|
fn remaining(&self) -> usize {
|
|
let len = self.get_ref().as_ref().len();
|
|
let pos = self.position();
|
|
|
|
if pos >= len as u64 {
|
|
return 0;
|
|
}
|
|
|
|
len - pos as usize
|
|
}
|
|
|
|
fn chunk(&self) -> &[u8] {
|
|
let len = self.get_ref().as_ref().len();
|
|
let pos = self.position();
|
|
|
|
if pos >= len as u64 {
|
|
return &[];
|
|
}
|
|
|
|
&self.get_ref().as_ref()[pos as usize..]
|
|
}
|
|
|
|
fn advance(&mut self, cnt: usize) {
|
|
let pos = (self.position() as usize)
|
|
.checked_add(cnt)
|
|
.expect("overflow");
|
|
|
|
assert!(pos <= self.get_ref().as_ref().len());
|
|
self.set_position(pos as u64);
|
|
}
|
|
}
|
|
// The existence of this function makes the compiler catch if the Buf
|
|
// trait is "object-safe" or not.
|
|
fn _assert_trait_object(_b: &dyn Buf) {}
|