bitcode_lightyear_patch/encoding/
mod.rs

1use crate::{Decode, Encode};
2use prelude::*;
3use std::num::NonZeroUsize;
4
5#[cfg(all(feature = "simdutf8", not(miri)))]
6use simdutf8::basic::from_utf8;
7#[cfg(not(all(feature = "simdutf8", not(miri))))]
8use std::str::from_utf8;
9
10mod bit_string;
11mod expect_normalized_float;
12mod expected_range_u64;
13mod gamma;
14mod prelude;
15
16pub use bit_string::*;
17pub use expect_normalized_float::ExpectNormalizedFloat;
18pub use expected_range_u64::ExpectedRangeU64;
19pub use gamma::Gamma;
20
21pub trait Encoding: Copy {
22    fn is_fixed(self) -> bool {
23        false
24    }
25
26    fn zigzag(self) -> bool {
27        false
28    }
29
30    #[inline(always)]
31    fn write_u64<const BITS: usize>(self, writer: &mut impl Write, v: u64) {
32        writer.write_bits(v, BITS);
33    }
34
35    #[inline(always)]
36    fn read_u64<const BITS: usize>(self, reader: &mut impl Read) -> Result<u64> {
37        reader.read_bits(BITS)
38    }
39
40    // TODO add implementations to Gamma and ExpectedRange.
41    #[inline(always)]
42    fn write_u128<const BITS: usize>(self, writer: &mut impl Write, v: u128) {
43        debug_assert!((65..=128).contains(&BITS));
44
45        let lo = v as u64;
46        let hi = (v >> 64) as u64;
47        writer.write_bits(lo, 64);
48        writer.write_bits(hi, BITS - 64);
49    }
50
51    #[inline(always)]
52    fn read_u128<const BITS: usize>(self, reader: &mut impl Read) -> Result<u128> {
53        debug_assert!((65..=128).contains(&BITS));
54
55        let lo = reader.read_bits(64)?;
56        let hi = reader.read_bits(BITS - 64)?;
57        Ok(lo as u128 | ((hi as u128) << 64))
58    }
59
60    #[inline(always)]
61    fn write_f32(self, writer: &mut impl Write, v: f32) {
62        v.to_bits().encode(Fixed, writer).unwrap()
63    }
64
65    #[inline(always)]
66    fn read_f32(self, reader: &mut impl Read) -> Result<f32> {
67        Ok(f32::from_bits(Decode::decode(Fixed, reader)?))
68    }
69
70    #[inline(always)]
71    fn write_f64(self, writer: &mut impl Write, v: f64) {
72        v.to_bits().encode(Fixed, writer).unwrap()
73    }
74
75    #[inline(always)]
76    fn read_f64(self, reader: &mut impl Read) -> Result<f64> {
77        Ok(f64::from_bits(Decode::decode(Fixed, reader)?))
78    }
79
80    #[inline(always)]
81    fn write_str(self, writer: &mut impl Write, v: &str) {
82        self.write_byte_str(writer, v.as_bytes());
83    }
84
85    #[inline(always)]
86    fn read_str(self, reader: &mut impl Read) -> Result<&str> {
87        let len = usize::decode(Gamma, reader)?;
88        if let Some(len) = NonZeroUsize::new(len) {
89            from_utf8(self.read_bytes(reader, len)?).map_err(|_| E::Invalid("utf8").e())
90        } else {
91            Ok("")
92        }
93    }
94
95    #[inline(always)]
96    fn write_byte_str(self, writer: &mut impl Write, v: &[u8]) {
97        v.len().encode(Gamma, writer).unwrap();
98        writer.write_bytes(v);
99    }
100
101    #[inline(always)]
102    fn read_byte_str(self, reader: &mut impl Read) -> Result<&[u8]> {
103        let len = usize::decode(Gamma, reader)?;
104        if let Some(len) = NonZeroUsize::new(len) {
105            self.read_bytes(reader, len)
106        } else {
107            Ok(&[])
108        }
109    }
110
111    #[inline(always)]
112    fn read_bytes(self, reader: &mut impl Read, len: NonZeroUsize) -> Result<&[u8]> {
113        reader.read_bytes(len)
114    }
115}
116
117#[derive(Copy, Clone)]
118pub struct Fixed;
119
120impl Encoding for Fixed {
121    fn is_fixed(self) -> bool {
122        true
123    }
124}
bitcode_lightyear_patch/encoding/mod.rs

bitcode_lightyear_patch/encoding/
mod.rs
