varing 0.5.2

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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

pub use super::packable::builtin::*;

/// A read-only buffer for storing LEB128 encoded values.
#[derive(Debug, Copy, Clone, Eq)]
pub struct Buffer<const N: usize>([u8; N]);

impl<const N: usize> PartialEq for Buffer<N> {
  #[inline]
  fn eq(&self, other: &Self) -> bool {
    self.as_slice().eq(other.as_slice())
  }
}

impl<const N: usize> core::hash::Hash for Buffer<N> {
  #[inline]
  fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
    self.as_slice().hash(state)
  }
}

impl<const N: usize> PartialOrd for Buffer<N> {
  #[inline]
  fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
    Some(self.cmp(other))
  }
}

impl<const N: usize> Ord for Buffer<N> {
  #[inline]
  fn cmp(&self, other: &Self) -> core::cmp::Ordering {
    self.as_slice().cmp(other.as_slice())
  }
}

impl<const N: usize> AsRef<[u8]> for Buffer<N> {
  #[inline]
  fn as_ref(&self) -> &[u8] {
    self
  }
}

impl<const N: usize> core::ops::Deref for Buffer<N> {
  type Target = [u8];

  #[inline]
  fn deref(&self) -> &Self::Target {
    let len = self.0[N - 1] as usize;
    &self.0[..len]
  }
}

impl<const N: usize> core::borrow::Borrow<[u8]> for Buffer<N> {
  #[inline]
  fn borrow(&self) -> &[u8] {
    self
  }
}

impl<const N: usize> Buffer<N> {
  pub(crate) const CAPACITY: usize = N - 1;

  pub(crate) const fn new(buffer: [u8; N]) -> Self {
    Self(buffer)
  }

  /// Returns the length of buffer.
  #[inline]
  pub const fn len(&self) -> usize {
    self.0[Self::CAPACITY] as usize
  }

  /// Returns `true` if the buffer is empty.
  #[inline]
  pub const fn is_empty(&self) -> bool {
    self.0[Self::CAPACITY] == 0
  }

  /// Returns the buffer as a slice.
  #[inline]
  pub const fn as_slice(&self) -> &[u8] {
    let len = self.len();
    let (data, _) = self.0.split_at(len);
    data
  }
}

/// Zigzag encode `i8` value.
#[inline]
pub const fn zigzag_encode_i8(value: i8) -> u8 {
  ((value << 1) ^ (value >> 7)) as u8
}

/// Zigzag encode `i16` value.
#[inline]
pub const fn zigzag_encode_i16(value: i16) -> u16 {
  ((value << 1) ^ (value >> 15)) as u16
}

/// Zigzag encode `i32` value.
#[inline]
pub const fn zigzag_encode_i32(value: i32) -> u32 {
  ((value << 1) ^ (value >> 31)) as u32
}

/// Zigzag encode `i64` value.
#[inline]
pub const fn zigzag_encode_i64(value: i64) -> u64 {
  ((value << 1) ^ (value >> 63)) as u64
}

/// Zigzag encode `i128` value.
#[inline]
pub const fn zigzag_encode_i128(value: i128) -> u128 {
  ((value << 1) ^ (value >> 127)) as u128
}

/// Zigzag decode `i8` value.
#[inline]
pub const fn zigzag_decode_i8(value: u8) -> i8 {
  ((value >> 1) as i8) ^ (-((value & 1) as i8))
}

/// Zigzag decode `i16` value.
#[inline]
pub const fn zigzag_decode_i16(value: u16) -> i16 {
  ((value >> 1) as i16) ^ (-((value & 1) as i16))
}

/// Zigzag decode `i32` value.
#[inline]
pub const fn zigzag_decode_i32(value: u32) -> i32 {
  ((value >> 1) as i32) ^ (-((value & 1) as i32))
}

/// Zigzag decode `i64` value.
#[inline]
pub const fn zigzag_decode_i64(value: u64) -> i64 {
  ((value >> 1) as i64) ^ (-((value & 1) as i64))
}

/// Zigzag decode `i128` value.
#[inline]
pub const fn zigzag_decode_i128(value: u128) -> i128 {
  ((value >> 1) as i128) ^ (-((value & 1) as i128))
}