use std::io::Result;
use qubit_codec::BigEndian;
use qubit_codec::ByteOrder;
use qubit_codec::LittleEndian;
use qubit_codec_binary::BinaryCodec;
use qubit_io::ByteInput;
use qubit_io::Input;
use crate::util::decode_infallible_unchecked;
macro_rules! read_binary_value {
($reader:expr, $ty:ty, $order:ty) => {
read_binary::<{ BinaryCodec::<$ty, $order>::MIN_UNITS_PER_VALUE }, _, _, _>($reader, |bytes| {
type Codec = BinaryCodec<$ty, $order>;
// SAFETY: The local buffer is exactly the codec's minimum buffer
// length.
unsafe { decode_infallible_unchecked::<Codec>(bytes, 0) }
})
};
}
#[must_use]
#[inline]
const fn use_big_endian(byte_order: ByteOrder) -> bool {
match byte_order {
ByteOrder::BigEndian => true,
ByteOrder::LittleEndian => false,
ByteOrder::NativeEndian => cfg!(target_endian = "big"),
}
}
pub trait BinaryReadExt: ByteInput {
#[inline(always)]
fn read_u8(&mut self) -> Result<u8> {
read_binary_value!(self, u8, BigEndian)
}
#[inline(always)]
fn read_i8(&mut self) -> Result<i8> {
read_binary_value!(self, i8, BigEndian)
}
#[inline]
fn read_u16(&mut self, byte_order: ByteOrder) -> Result<u16> {
if use_big_endian(byte_order) {
self.read_u16_be()
} else {
self.read_u16_le()
}
}
#[inline(always)]
fn read_u16_be(&mut self) -> Result<u16> {
read_binary_value!(self, u16, BigEndian)
}
#[inline(always)]
fn read_u16_le(&mut self) -> Result<u16> {
read_binary_value!(self, u16, LittleEndian)
}
#[inline]
fn read_u32(&mut self, byte_order: ByteOrder) -> Result<u32> {
if use_big_endian(byte_order) {
self.read_u32_be()
} else {
self.read_u32_le()
}
}
#[inline(always)]
fn read_u32_be(&mut self) -> Result<u32> {
read_binary_value!(self, u32, BigEndian)
}
#[inline(always)]
fn read_u32_le(&mut self) -> Result<u32> {
read_binary_value!(self, u32, LittleEndian)
}
#[inline]
fn read_u64(&mut self, byte_order: ByteOrder) -> Result<u64> {
if use_big_endian(byte_order) {
self.read_u64_be()
} else {
self.read_u64_le()
}
}
#[inline(always)]
fn read_u64_be(&mut self) -> Result<u64> {
read_binary_value!(self, u64, BigEndian)
}
#[inline(always)]
fn read_u64_le(&mut self) -> Result<u64> {
read_binary_value!(self, u64, LittleEndian)
}
#[inline]
fn read_u128(&mut self, byte_order: ByteOrder) -> Result<u128> {
if use_big_endian(byte_order) {
self.read_u128_be()
} else {
self.read_u128_le()
}
}
#[inline(always)]
fn read_u128_be(&mut self) -> Result<u128> {
read_binary_value!(self, u128, BigEndian)
}
#[inline(always)]
fn read_u128_le(&mut self) -> Result<u128> {
read_binary_value!(self, u128, LittleEndian)
}
#[inline]
fn read_i16(&mut self, byte_order: ByteOrder) -> Result<i16> {
if use_big_endian(byte_order) {
self.read_i16_be()
} else {
self.read_i16_le()
}
}
#[inline(always)]
fn read_i16_be(&mut self) -> Result<i16> {
read_binary_value!(self, i16, BigEndian)
}
#[inline(always)]
fn read_i16_le(&mut self) -> Result<i16> {
read_binary_value!(self, i16, LittleEndian)
}
#[inline]
fn read_i32(&mut self, byte_order: ByteOrder) -> Result<i32> {
if use_big_endian(byte_order) {
self.read_i32_be()
} else {
self.read_i32_le()
}
}
#[inline(always)]
fn read_i32_be(&mut self) -> Result<i32> {
read_binary_value!(self, i32, BigEndian)
}
#[inline(always)]
fn read_i32_le(&mut self) -> Result<i32> {
read_binary_value!(self, i32, LittleEndian)
}
#[inline]
fn read_i64(&mut self, byte_order: ByteOrder) -> Result<i64> {
if use_big_endian(byte_order) {
self.read_i64_be()
} else {
self.read_i64_le()
}
}
#[inline(always)]
fn read_i64_be(&mut self) -> Result<i64> {
read_binary_value!(self, i64, BigEndian)
}
#[inline(always)]
fn read_i64_le(&mut self) -> Result<i64> {
read_binary_value!(self, i64, LittleEndian)
}
#[inline]
fn read_i128(&mut self, byte_order: ByteOrder) -> Result<i128> {
if use_big_endian(byte_order) {
self.read_i128_be()
} else {
self.read_i128_le()
}
}
#[inline(always)]
fn read_i128_be(&mut self) -> Result<i128> {
read_binary_value!(self, i128, BigEndian)
}
#[inline(always)]
fn read_i128_le(&mut self) -> Result<i128> {
read_binary_value!(self, i128, LittleEndian)
}
#[inline]
fn read_f32(&mut self, byte_order: ByteOrder) -> Result<f32> {
if use_big_endian(byte_order) {
self.read_f32_be()
} else {
self.read_f32_le()
}
}
#[inline(always)]
fn read_f32_be(&mut self) -> Result<f32> {
read_binary_value!(self, f32, BigEndian)
}
#[inline(always)]
fn read_f32_le(&mut self) -> Result<f32> {
read_binary_value!(self, f32, LittleEndian)
}
#[inline]
fn read_f64(&mut self, byte_order: ByteOrder) -> Result<f64> {
if use_big_endian(byte_order) {
self.read_f64_be()
} else {
self.read_f64_le()
}
}
#[inline(always)]
fn read_f64_be(&mut self) -> Result<f64> {
read_binary_value!(self, f64, BigEndian)
}
#[inline(always)]
fn read_f64_le(&mut self) -> Result<f64> {
read_binary_value!(self, f64, LittleEndian)
}
}
impl<R> BinaryReadExt for R where R: ByteInput + ?Sized {}
#[inline]
fn read_binary<const N: usize, T, R, F>(reader: &mut R, decode: F) -> Result<T>
where
R: ByteInput + ?Sized,
F: FnOnce(&[u8]) -> T,
{
let mut bytes = [0u8; N];
Input::read_exactly(reader, &mut bytes)?;
Ok(decode(&bytes))
}