use core::convert::Infallible;
use core::marker::PhantomData;
use qubit_codec::Codec;
use qubit_codec::DecodeFailure;
use crate::Leb128Codec;
use crate::Leb128DecodeError;
use crate::Leb128DecodePolicy;
use crate::NonStrict;
use crate::codec::leb128_codec::map_leb128_decode_failure;
use crate::codec::leb128_codec::uleb_encoded_len;
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct ZigZagCodec<T, P> {
marker: PhantomData<fn() -> (T, P)>,
}
macro_rules! impl_zig_zag_codec {
($signed:ty, $unsigned:ty, $shift:expr) => {
impl<P> ZigZagCodec<$signed, P>
where
P: Leb128DecodePolicy,
{
pub const MIN_UNITS_PER_VALUE: usize = <Self as Codec>::MIN_UNITS_PER_VALUE;
pub const MAX_ENCODE_UNITS_PER_VALUE: usize = <Self as Codec>::MAX_ENCODE_UNITS_PER_VALUE;
pub const MAX_DECODE_UNITS_PER_VALUE: usize = <Self as Codec>::MAX_DECODE_UNITS_PER_VALUE;
#[inline(always)]
pub unsafe fn decode(
input: &[u8],
input_index: usize,
) -> Result<($signed, core::num::NonZeroUsize), Leb128DecodeError> {
debug_assert!(input.len().saturating_sub(input_index) >= Self::MIN_UNITS_PER_VALUE);
let (encoded, consumed) = unsafe { Leb128Codec::<$unsigned, P>::decode(input, input_index)? };
let value = ((encoded >> 1) as $signed) ^ (-((encoded & 1) as $signed));
Ok((value, consumed))
}
#[must_use = "the returned byte count determines the encoded payload range"]
#[inline(always)]
pub unsafe fn encode(value: $signed, output: &mut [u8], output_index: usize) -> usize {
let encoded = ((value as $unsigned) << 1) ^ ((value >> $shift) as $unsigned);
unsafe { Leb128Codec::<$unsigned, NonStrict>::encode(encoded, output, output_index) }
}
}
impl<P> Codec for ZigZagCodec<$signed, P>
where
P: Leb128DecodePolicy,
{
type Value = $signed;
type Unit = u8;
type DecodeError = Leb128DecodeError;
type EncodeError = Infallible;
const MIN_UNITS_PER_VALUE: usize = 1;
const MAX_ENCODE_UNITS_PER_VALUE: usize = Leb128Codec::<$unsigned, NonStrict>::MAX_ENCODE_UNITS_PER_VALUE;
const MAX_DECODE_UNITS_PER_VALUE: usize = Leb128Codec::<$unsigned, NonStrict>::MAX_DECODE_UNITS_PER_VALUE;
#[inline(always)]
fn encode_len(&self, value: &$signed) -> usize {
let encoded = ((*value as $unsigned) << 1) ^ ((*value >> $shift) as $unsigned);
uleb_encoded_len(encoded as u128)
}
#[inline(always)]
unsafe fn decode(
&mut self,
input: &[u8],
input_index: usize,
) -> Result<($signed, core::num::NonZeroUsize), DecodeFailure<Self::DecodeError>> {
debug_assert!(input.len().saturating_sub(input_index) >= Self::MIN_UNITS_PER_VALUE);
unsafe { Self::decode(input, input_index) }.map_err(map_leb128_decode_failure)
}
#[inline(always)]
unsafe fn encode(
&mut self,
value: &$signed,
output: &mut [u8],
output_index: usize,
) -> Result<usize, Self::EncodeError> {
let required = self.encode_len(value);
debug_assert!(output.len().saturating_sub(output_index) >= required);
let written = unsafe { Self::encode(*value, output, output_index) };
Ok(written)
}
}
};
}
impl_zig_zag_codec!(i8, u8, 7);
impl_zig_zag_codec!(i16, u16, 15);
impl_zig_zag_codec!(i32, u32, 31);
impl_zig_zag_codec!(i64, u64, 63);
impl_zig_zag_codec!(i128, u128, 127);
impl_zig_zag_codec!(isize, usize, isize::BITS - 1);