varing 0.14.0

Protobuf's varint encoding/decoding for LEB128 friendly types with full const context operations supports.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

use core::num::NonZeroUsize;

use float8_0_4::{F8E4M3, F8E5M2};

use crate::Varint;

macro_rules! generate {
  ($($ty:ident),+$(,)?) => {
    paste::paste! {
      $(
        impl Varint for $ty {
          const MIN_ENCODED_LEN: NonZeroUsize = u8::MIN_ENCODED_LEN;

          const MAX_ENCODED_LEN: NonZeroUsize = u8::MAX_ENCODED_LEN;

          #[inline]
          fn encoded_len(&self) -> NonZeroUsize {
            [< encoded_ $ty:lower _varint_len >](*self)
          }

          #[inline]
          fn encode(&self, buf: &mut [u8]) -> Result<NonZeroUsize, crate::EncodeError> {
            [< encode_ $ty:lower _varint_to >](*self, buf).map_err(Into::into)
          }

          #[inline]
          fn decode(buf: &[u8]) -> Result<(NonZeroUsize, Self), crate::DecodeError>
          where
            Self: Sized,
          {
            [< decode_ $ty:lower _varint >](buf).map_err(Into::into)
          }
        }

        #[doc = "Returns the encoded length of the value in LEB128 variable length format. The returned value will be in range of [`" $ty "::ENCODED_LEN_RANGE`]"]
        #[inline]
        pub const fn [< encoded_ $ty:lower _varint_len >](value: $ty) -> NonZeroUsize {
          crate::encoded_u8_varint_len(value.to_bits())
        }

        #[doc = "Encodes a `" $ty "` value into LEB128 variable length format, and writes it to the buffer."]
        #[inline]
        pub const fn [< encode_ $ty:lower _varint >](
          value: $ty,
        ) -> crate::utils::Buffer<{ <$ty>::MAX_ENCODED_LEN.get() + 1 }> {
          crate::encode_u8_varint(value.to_bits())
        }

        #[doc = "Encodes a `" $ty "` value into LEB128 variable length format, and writes it to the buffer."]
        #[inline]
        pub const fn [< encode_ $ty:lower _varint_to >](
          value: $ty,
          buf: &mut [u8],
        ) -> Result<NonZeroUsize, crate::ConstEncodeError> {
          crate::encode_u8_varint_to(value.to_bits(), buf)
        }

        #[doc = "Decodes an `" $ty "` in LEB128 encoded format from the buffer."]
        ///
        /// Returns the bytes readed and the decoded value if successful.
        #[inline]
        pub const fn [< decode_ $ty:lower _varint >](buf: &[u8]) -> Result<(NonZeroUsize, $ty), crate::ConstDecodeError> {
          match crate::decode_u8_varint(buf) {
            Ok((len, bits)) => Ok((len, <$ty>::from_bits(bits))),
            Err(e) => Err(e),
          }
        }

        #[doc = "Returns the encoded length of a sequence of `" $ty "` values."]
        #[inline]
        pub const fn [< encoded_ $ty:lower _sequence_len >](sequence: &[$ty]) -> usize {
          encode!(@sequence_encoded_len_impl sequence, [< encoded_ $ty:lower _varint_len >])
        }

        #[doc = "Encodes a sequence of `" $ty "` to the buffer."]
        #[inline]
        pub const fn [< encode_ $ty:lower _sequence_to >](
          sequence: &[$ty],
          buf: &mut [u8],
        ) -> Result<usize, crate::ConstEncodeError> {
          encode!(@sequence_encode_to_impl buf, sequence, [< encode_ $ty:lower _varint_to >], [< encoded_ $ty:lower _sequence_len >])
        }
      )*
    }
  };
}

generate!(F8E4M3, F8E5M2);

#[cfg(test)]
mod tests;