moq_lite/coding/
size.rs

1use std::mem::MaybeUninit;
2
3use bytes::{Buf, BufMut, buf::UninitSlice};
4
5/// A [BufMut] implementation that only counts the size of the buffer.
6///
7/// Used to calculate the size of a message before encoding it.
8#[derive(Default)]
9pub struct Sizer {
10	pub size: usize,
11}
12
13unsafe impl BufMut for Sizer {
14	unsafe fn advance_mut(&mut self, cnt: usize) {
15		self.size += cnt;
16	}
17
18	fn chunk_mut(&mut self) -> &mut UninitSlice {
19		// We need to return a valid slice, but it won't actually be written to
20		// Use a thread-local static buffer to avoid safety issues
21		thread_local! {
22			static BUFFER: std::cell::UnsafeCell<[MaybeUninit<u8>; 8192]> =
23				const { std::cell::UnsafeCell::new([MaybeUninit::uninit(); 8192]) };
24		}
25
26		BUFFER.with(|buf| {
27			let ptr = buf.get();
28			unsafe {
29				let slice = (*ptr).as_mut_ptr();
30				bytes::buf::UninitSlice::from_raw_parts_mut(slice as *mut u8, 8192)
31			}
32		})
33	}
34
35	fn remaining_mut(&self) -> usize {
36		usize::MAX
37	}
38
39	fn has_remaining_mut(&self) -> bool {
40		true
41	}
42
43	fn put<T: Buf>(&mut self, mut src: T) {
44		self.size += src.remaining();
45		src.advance(src.remaining());
46	}
47
48	fn put_bytes(&mut self, _val: u8, cnt: usize) {
49		self.size += cnt;
50	}
51
52	fn put_f32(&mut self, _val: f32) {
53		self.size += 4;
54	}
55
56	fn put_f32_le(&mut self, _: f32) {
57		self.size += 4
58	}
59
60	fn put_f32_ne(&mut self, _: f32) {
61		self.size += 4
62	}
63
64	fn put_f64(&mut self, _: f64) {
65		self.size += 8
66	}
67
68	fn put_f64_le(&mut self, _: f64) {
69		self.size += 8
70	}
71
72	fn put_f64_ne(&mut self, _: f64) {
73		self.size += 8
74	}
75
76	fn put_i128(&mut self, _: i128) {
77		self.size += 16
78	}
79
80	fn put_i128_le(&mut self, _: i128) {
81		self.size += 16
82	}
83
84	fn put_i128_ne(&mut self, _: i128) {
85		self.size += 16
86	}
87
88	fn put_i16(&mut self, _: i16) {
89		self.size += 2
90	}
91
92	fn put_i16_le(&mut self, _: i16) {
93		self.size += 2
94	}
95
96	fn put_i16_ne(&mut self, _: i16) {
97		self.size += 2
98	}
99
100	fn put_i32(&mut self, _: i32) {
101		self.size += 4
102	}
103
104	fn put_i32_le(&mut self, _: i32) {
105		self.size += 4
106	}
107
108	fn put_i32_ne(&mut self, _: i32) {
109		self.size += 4
110	}
111
112	fn put_i64(&mut self, _: i64) {
113		self.size += 8
114	}
115
116	fn put_i64_le(&mut self, _: i64) {
117		self.size += 8
118	}
119
120	fn put_i64_ne(&mut self, _: i64) {
121		self.size += 8
122	}
123
124	fn put_i8(&mut self, _: i8) {
125		self.size += 1
126	}
127
128	fn put_int(&mut self, _: i64, nbytes: usize) {
129		self.size += nbytes
130	}
131
132	fn put_int_le(&mut self, _: i64, nbytes: usize) {
133		self.size += nbytes
134	}
135
136	fn put_int_ne(&mut self, _: i64, nbytes: usize) {
137		self.size += nbytes
138	}
139
140	fn put_slice(&mut self, src: &[u8]) {
141		self.size += src.len();
142	}
143
144	fn put_u128(&mut self, _: u128) {
145		self.size += 16
146	}
147
148	fn put_u128_le(&mut self, _: u128) {
149		self.size += 16
150	}
151
152	fn put_u128_ne(&mut self, _: u128) {
153		self.size += 16
154	}
155
156	fn put_u16(&mut self, _: u16) {
157		self.size += 2
158	}
159
160	fn put_u16_le(&mut self, _: u16) {
161		self.size += 2
162	}
163
164	fn put_u16_ne(&mut self, _: u16) {
165		self.size += 2
166	}
167
168	fn put_u32(&mut self, _: u32) {
169		self.size += 4
170	}
171
172	fn put_u32_le(&mut self, _: u32) {
173		self.size += 4
174	}
175
176	fn put_u32_ne(&mut self, _: u32) {
177		self.size += 4
178	}
179
180	fn put_u64(&mut self, _: u64) {
181		self.size += 8
182	}
183
184	fn put_u64_le(&mut self, _: u64) {
185		self.size += 8
186	}
187
188	fn put_u64_ne(&mut self, _: u64) {
189		self.size += 8
190	}
191
192	fn put_u8(&mut self, _: u8) {
193		self.size += 1
194	}
195
196	fn put_uint(&mut self, _: u64, nbytes: usize) {
197		self.size += nbytes
198	}
199
200	fn put_uint_le(&mut self, _: u64, nbytes: usize) {
201		self.size += nbytes
202	}
203
204	fn put_uint_ne(&mut self, _: u64, nbytes: usize) {
205		self.size += nbytes
206	}
207
208	// TODO
209	// fn writer(self) -> bytes::buf::Writer<Self> {
210	// fn chain_mut<U: BufMut>(self, next: U) -> bytes::buf::Chain<Self, U>
211	// fn limit(self, limit: usize) -> bytes::buf::Limit<Self>
212}
moq_lite/coding/size.rs

moq_lite/coding/
size.rs
