use std::io::Result;
use qubit_codec::BigEndian;
use qubit_codec::ByteOrder;
use qubit_codec::LittleEndian;
use qubit_codec_binary::BinaryCodec;
use qubit_io::ByteOutput;
use crate::util::encode_infallible_unchecked;
use crate::util::write_all;
macro_rules! write_binary_value {
($writer:expr, $value:expr, $ty:ty, $order:ty) => {
write_binary::<{ BinaryCodec::<$ty, $order>::MAX_ENCODE_UNITS_PER_VALUE }, _, _, _>(
$writer,
$value,
|bytes, value| {
type Codec = BinaryCodec<$ty, $order>;
// SAFETY: The local buffer is exactly the codec's maximum buffer
// length.
unsafe {
let _ = encode_infallible_unchecked::<Codec>(value, 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 BinaryWriteExt: ByteOutput {
#[inline(always)]
fn write_u8(&mut self, value: u8) -> Result<()> {
write_binary_value!(self, value, u8, BigEndian)
}
#[inline(always)]
fn write_i8(&mut self, value: i8) -> Result<()> {
write_binary_value!(self, value, i8, BigEndian)
}
#[inline]
fn write_u16(&mut self, value: u16, byte_order: ByteOrder) -> Result<()> {
if use_big_endian(byte_order) {
self.write_u16_be(value)
} else {
self.write_u16_le(value)
}
}
#[inline(always)]
fn write_u16_be(&mut self, value: u16) -> Result<()> {
write_binary_value!(self, value, u16, BigEndian)
}
#[inline(always)]
fn write_u16_le(&mut self, value: u16) -> Result<()> {
write_binary_value!(self, value, u16, LittleEndian)
}
#[inline]
fn write_u32(&mut self, value: u32, byte_order: ByteOrder) -> Result<()> {
if use_big_endian(byte_order) {
self.write_u32_be(value)
} else {
self.write_u32_le(value)
}
}
#[inline(always)]
fn write_u32_be(&mut self, value: u32) -> Result<()> {
write_binary_value!(self, value, u32, BigEndian)
}
#[inline(always)]
fn write_u32_le(&mut self, value: u32) -> Result<()> {
write_binary_value!(self, value, u32, LittleEndian)
}
#[inline]
fn write_u64(&mut self, value: u64, byte_order: ByteOrder) -> Result<()> {
if use_big_endian(byte_order) {
self.write_u64_be(value)
} else {
self.write_u64_le(value)
}
}
#[inline(always)]
fn write_u64_be(&mut self, value: u64) -> Result<()> {
write_binary_value!(self, value, u64, BigEndian)
}
#[inline(always)]
fn write_u64_le(&mut self, value: u64) -> Result<()> {
write_binary_value!(self, value, u64, LittleEndian)
}
#[inline]
fn write_u128(&mut self, value: u128, byte_order: ByteOrder) -> Result<()> {
if use_big_endian(byte_order) {
self.write_u128_be(value)
} else {
self.write_u128_le(value)
}
}
#[inline(always)]
fn write_u128_be(&mut self, value: u128) -> Result<()> {
write_binary_value!(self, value, u128, BigEndian)
}
#[inline(always)]
fn write_u128_le(&mut self, value: u128) -> Result<()> {
write_binary_value!(self, value, u128, LittleEndian)
}
#[inline]
fn write_i16(&mut self, value: i16, byte_order: ByteOrder) -> Result<()> {
if use_big_endian(byte_order) {
self.write_i16_be(value)
} else {
self.write_i16_le(value)
}
}
#[inline(always)]
fn write_i16_be(&mut self, value: i16) -> Result<()> {
write_binary_value!(self, value, i16, BigEndian)
}
#[inline(always)]
fn write_i16_le(&mut self, value: i16) -> Result<()> {
write_binary_value!(self, value, i16, LittleEndian)
}
#[inline]
fn write_i32(&mut self, value: i32, byte_order: ByteOrder) -> Result<()> {
if use_big_endian(byte_order) {
self.write_i32_be(value)
} else {
self.write_i32_le(value)
}
}
#[inline(always)]
fn write_i32_be(&mut self, value: i32) -> Result<()> {
write_binary_value!(self, value, i32, BigEndian)
}
#[inline(always)]
fn write_i32_le(&mut self, value: i32) -> Result<()> {
write_binary_value!(self, value, i32, LittleEndian)
}
#[inline]
fn write_i64(&mut self, value: i64, byte_order: ByteOrder) -> Result<()> {
if use_big_endian(byte_order) {
self.write_i64_be(value)
} else {
self.write_i64_le(value)
}
}
#[inline(always)]
fn write_i64_be(&mut self, value: i64) -> Result<()> {
write_binary_value!(self, value, i64, BigEndian)
}
#[inline(always)]
fn write_i64_le(&mut self, value: i64) -> Result<()> {
write_binary_value!(self, value, i64, LittleEndian)
}
#[inline]
fn write_i128(&mut self, value: i128, byte_order: ByteOrder) -> Result<()> {
if use_big_endian(byte_order) {
self.write_i128_be(value)
} else {
self.write_i128_le(value)
}
}
#[inline(always)]
fn write_i128_be(&mut self, value: i128) -> Result<()> {
write_binary_value!(self, value, i128, BigEndian)
}
#[inline(always)]
fn write_i128_le(&mut self, value: i128) -> Result<()> {
write_binary_value!(self, value, i128, LittleEndian)
}
#[inline]
fn write_f32(&mut self, value: f32, byte_order: ByteOrder) -> Result<()> {
if use_big_endian(byte_order) {
self.write_f32_be(value)
} else {
self.write_f32_le(value)
}
}
#[inline(always)]
fn write_f32_be(&mut self, value: f32) -> Result<()> {
write_binary_value!(self, value, f32, BigEndian)
}
#[inline(always)]
fn write_f32_le(&mut self, value: f32) -> Result<()> {
write_binary_value!(self, value, f32, LittleEndian)
}
#[inline]
fn write_f64(&mut self, value: f64, byte_order: ByteOrder) -> Result<()> {
if use_big_endian(byte_order) {
self.write_f64_be(value)
} else {
self.write_f64_le(value)
}
}
#[inline(always)]
fn write_f64_be(&mut self, value: f64) -> Result<()> {
write_binary_value!(self, value, f64, BigEndian)
}
#[inline(always)]
fn write_f64_le(&mut self, value: f64) -> Result<()> {
write_binary_value!(self, value, f64, LittleEndian)
}
}
impl<W> BinaryWriteExt for W where W: ByteOutput + ?Sized {}
#[inline]
fn write_binary<const N: usize, T, W, F>(writer: &mut W, value: T, encode: F) -> Result<()>
where
W: ByteOutput + ?Sized,
F: FnOnce(&mut [u8], T),
{
let mut bytes = [0u8; N];
encode(&mut bytes, value);
write_all(writer, &bytes)
}