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
|
use core::{mem::MaybeUninit, ops::Deref};
use super::varint;
const DEFAULT_FIELD_BUFFER_CAP: usize = 32;
pub enum Field<'a> {
U8(u8),
U16(u16),
VarInt(u32),
Buffer(&'a [u8]),
LenPrefixedBuffer(&'a [u8]),
LenPrefixedString(&'a str),
}
pub struct FieldBuffer<'a, const N: usize = DEFAULT_FIELD_BUFFER_CAP> {
data: [MaybeUninit<Field<'a>>; N],
len: usize,
}
impl<'a, const N: usize> Default for FieldBuffer<'a, N> {
fn default() -> Self {
Self {
data: [const { MaybeUninit::uninit() }; N],
len: 0,
}
}
}
impl<'a, const N: usize> FieldBuffer<'a, N> {
pub fn clear(&mut self) {
self.len = 0;
}
pub fn push(&mut self, field: Field<'a>) {
assert!(self.len < N, "field buffer lenght limit exceeded");
self.data[self.len].write(field);
self.len += 1;
}
pub fn set(&mut self, n: usize, field: Field<'a>) {
assert!(self.len > n);
self.data[n].write(field);
}
pub fn as_slice<'s>(&'s self) -> &'s [Field<'a>] {
unsafe {
core::mem::transmute::<&'s [MaybeUninit<Field<'a>>], &'s [Field<'a>]>(
&self.data[..self.len],
)
}
}
}
impl<'a, const N: usize> AsRef<[Field<'a>]> for FieldBuffer<'a, N> {
fn as_ref(&self) -> &[Field<'a>] {
self.as_slice()
}
}
impl<'a, const N: usize> Deref for FieldBuffer<'a, N> {
type Target = [Field<'a>];
fn deref(&self) -> &Self::Target {
self.as_slice()
}
}
pub fn field_size(field: &Field) -> usize {
match field {
Field::U8(_) => 1,
Field::U16(_) => 2,
Field::VarInt(v) => {
let (_, n) = varint::encode(*v);
n
}
Field::Buffer(v) => v.len(),
Field::LenPrefixedBuffer(v) => v.len().strict_add(2),
Field::LenPrefixedString(v) => v.len().strict_add(2),
}
}
pub fn fields_size(fields: &[Field]) -> usize {
let mut total_size = 0usize;
for field in fields {
total_size = total_size.strict_add(field_size(field));
}
total_size
}
|
