use crate::DecodeError;
pub const MAX_LEN: usize = 4;
pub fn encode_to(value: u32, dst: &mut [u8]) -> usize {
let mut remaining = value;
let mut written = 0;
loop {
let mut byte = (remaining % 128) as u8;
remaining /= 128;
if remaining > 0 {
byte |= 0x80;
}
dst[written] = byte;
written += 1;
if remaining == 0 {
return written;
}
}
}
pub fn peek(buf: &[u8]) -> Result<Option<(u32, usize)>, DecodeError> {
let mut multiplier: u32 = 1;
let mut value: u32 = 0;
for i in 0..MAX_LEN {
let Some(&byte) = buf.get(i) else {
return Ok(None);
};
value += (byte as u32 & 0x7F) * multiplier;
if byte & 0x80 == 0 {
return Ok(Some((value, i + 1)));
}
multiplier *= 128;
}
Err(DecodeError::MalformedRemainingLength)
}
pub fn decode(buf: &mut bytes::Bytes) -> Result<u32, DecodeError> {
use bytes::Buf;
let mut multiplier: u32 = 1;
let mut value: u32 = 0;
for _ in 0..MAX_LEN {
if !buf.has_remaining() {
return Err(DecodeError::InsufficientBytes { needed: 1 });
}
let byte = buf.get_u8();
value += (byte as u32 & 0x7F) * multiplier;
if byte & 0x80 == 0 {
return Ok(value);
}
multiplier *= 128;
}
Err(DecodeError::MalformedRemainingLength)
}
pub fn len(value: u32) -> usize {
match value {
0..=127 => 1,
128..=16_383 => 2,
16_384..=2_097_151 => 3,
_ => 4,
}
}
#[cfg(test)]
mod tests {
use bytes::Bytes;
use super::*;
use crate::DecodeError;
const BOUNDARY_VALUES: &[(u32, &[u8])] = &[
(0, &[0x00]),
(127, &[0x7F]),
(128, &[0x80, 0x01]),
(16_383, &[0xFF, 0x7F]),
(16_384, &[0x80, 0x80, 0x01]),
(2_097_151, &[0xFF, 0xFF, 0x7F]),
(2_097_152, &[0x80, 0x80, 0x80, 0x01]),
(268_435_455, &[0xFF, 0xFF, 0xFF, 0x7F]),
];
#[test]
fn encode_boundary_values() {
for &(value, expected) in BOUNDARY_VALUES {
let mut dst = [0u8; 4];
let written = encode_to(value, &mut dst);
assert_eq!(&dst[..written], expected, "encode_to({value}) failed");
}
}
#[test]
fn decode_boundary_values() {
for &(expected, encoded) in BOUNDARY_VALUES {
let mut buf = Bytes::copy_from_slice(encoded);
let got = decode(&mut buf).unwrap();
assert_eq!(got, expected, "decode({encoded:?}) failed");
assert_eq!(buf.len(), 0);
}
}
#[test]
fn encode_decode_roundtrip() {
for &(value, _) in BOUNDARY_VALUES {
let mut dst = [0u8; 4];
let written = encode_to(value, &mut dst);
let mut buf = Bytes::copy_from_slice(&dst[..written]);
assert_eq!(decode(&mut buf).unwrap(), value);
}
}
#[test]
fn peek_empty_buffer() {
assert_eq!(peek(&[]), Ok(None));
}
#[test]
fn peek_incomplete_one_byte_with_continuation() {
assert_eq!(peek(&[0x80]), Ok(None));
}
#[test]
fn peek_incomplete_two_bytes_with_continuation() {
assert_eq!(peek(&[0x80, 0x80]), Ok(None));
}
#[test]
fn peek_incomplete_three_bytes_with_continuation() {
assert_eq!(peek(&[0x80, 0x80, 0x80]), Ok(None));
}
#[test]
fn peek_malformed_four_bytes_all_continuation() {
assert_eq!(
peek(&[0x80, 0x80, 0x80, 0x80]),
Err(DecodeError::MalformedRemainingLength)
);
}
#[test]
fn peek_value_with_trailing_bytes() {
assert_eq!(peek(&[0x01, 0x02, 0x03]), Ok(Some((1, 1))));
}
#[test]
fn peek_boundary_values() {
for &(value, encoded) in BOUNDARY_VALUES {
let result = peek(encoded).unwrap().unwrap();
assert_eq!(result, (value, encoded.len()), "peek({encoded:?}) failed");
}
}
#[test]
fn decode_empty_buffer() {
let mut buf = Bytes::new();
assert_eq!(decode(&mut buf), Err(DecodeError::InsufficientBytes { needed: 1 }));
}
#[test]
fn decode_incomplete_continuation() {
let mut buf = Bytes::from_static(&[0x80]);
assert_eq!(decode(&mut buf), Err(DecodeError::InsufficientBytes { needed: 1 }));
}
#[test]
fn decode_malformed() {
let mut buf = Bytes::from_static(&[0x80, 0x80, 0x80, 0x80]);
assert_eq!(decode(&mut buf), Err(DecodeError::MalformedRemainingLength));
}
#[test]
fn len_boundary_values() {
assert_eq!(len(0), 1);
assert_eq!(len(127), 1);
assert_eq!(len(128), 2);
assert_eq!(len(16_383), 2);
assert_eq!(len(16_384), 3);
assert_eq!(len(2_097_151), 3);
assert_eq!(len(2_097_152), 4);
assert_eq!(len(268_435_455), 4);
}
}