]>
Commit | Line | Data |
---|---|---|
5869c6ff | 1 | use crate::leb128::{self, max_leb128_len}; |
923072b8 | 2 | use crate::serialize::{Decodable, Decoder, Encodable, Encoder}; |
cdc7bbd5 | 3 | use std::convert::TryInto; |
5869c6ff XL |
4 | use std::fs::File; |
5 | use std::io::{self, Write}; | |
6 | use std::mem::MaybeUninit; | |
7 | use std::path::Path; | |
8 | use std::ptr; | |
9cc50fc6 SL |
9 | |
10 | // ----------------------------------------------------------------------------- | |
11 | // Encoder | |
12 | // ----------------------------------------------------------------------------- | |
13 | ||
923072b8 | 14 | pub struct MemEncoder { |
8faf50e0 | 15 | pub data: Vec<u8>, |
9cc50fc6 SL |
16 | } |
17 | ||
923072b8 FG |
18 | impl MemEncoder { |
19 | pub fn new() -> MemEncoder { | |
20 | MemEncoder { data: vec![] } | |
2c00a5a8 | 21 | } |
9cc50fc6 | 22 | |
5869c6ff XL |
23 | #[inline] |
24 | pub fn position(&self) -> usize { | |
25 | self.data.len() | |
26 | } | |
923072b8 FG |
27 | |
28 | pub fn finish(self) -> Vec<u8> { | |
29 | self.data | |
30 | } | |
8faf50e0 | 31 | } |
9cc50fc6 | 32 | |
5869c6ff XL |
33 | macro_rules! write_leb128 { |
34 | ($enc:expr, $value:expr, $int_ty:ty, $fun:ident) => {{ | |
35 | const MAX_ENCODED_LEN: usize = max_leb128_len!($int_ty); | |
36 | let old_len = $enc.data.len(); | |
37 | ||
38 | if MAX_ENCODED_LEN > $enc.data.capacity() - old_len { | |
39 | $enc.data.reserve(MAX_ENCODED_LEN); | |
40 | } | |
41 | ||
42 | // SAFETY: The above check and `reserve` ensures that there is enough | |
43 | // room to write the encoded value to the vector's internal buffer. | |
44 | unsafe { | |
45 | let buf = &mut *($enc.data.as_mut_ptr().add(old_len) | |
46 | as *mut [MaybeUninit<u8>; MAX_ENCODED_LEN]); | |
47 | let encoded = leb128::$fun(buf, $value); | |
48 | $enc.data.set_len(old_len + encoded.len()); | |
49 | } | |
dfeec247 | 50 | }}; |
9cc50fc6 SL |
51 | } |
52 | ||
a2a8927a XL |
53 | /// A byte that [cannot occur in UTF8 sequences][utf8]. Used to mark the end of a string. |
54 | /// This way we can skip validation and still be relatively sure that deserialization | |
55 | /// did not desynchronize. | |
56 | /// | |
57 | /// [utf8]: https://en.wikipedia.org/w/index.php?title=UTF-8&oldid=1058865525#Codepage_layout | |
58 | const STR_SENTINEL: u8 = 0xC1; | |
59 | ||
923072b8 | 60 | impl Encoder for MemEncoder { |
2c00a5a8 | 61 | #[inline] |
923072b8 | 62 | fn emit_usize(&mut self, v: usize) { |
5869c6ff | 63 | write_leb128!(self, v, usize, write_usize_leb128) |
9cc50fc6 SL |
64 | } |
65 | ||
2c00a5a8 | 66 | #[inline] |
923072b8 FG |
67 | fn emit_u128(&mut self, v: u128) { |
68 | write_leb128!(self, v, u128, write_u128_leb128); | |
32a655c1 SL |
69 | } |
70 | ||
2c00a5a8 | 71 | #[inline] |
923072b8 FG |
72 | fn emit_u64(&mut self, v: u64) { |
73 | write_leb128!(self, v, u64, write_u64_leb128); | |
9cc50fc6 SL |
74 | } |
75 | ||
2c00a5a8 | 76 | #[inline] |
923072b8 FG |
77 | fn emit_u32(&mut self, v: u32) { |
78 | write_leb128!(self, v, u32, write_u32_leb128); | |
9cc50fc6 SL |
79 | } |
80 | ||
2c00a5a8 | 81 | #[inline] |
923072b8 | 82 | fn emit_u16(&mut self, v: u16) { |
a2a8927a | 83 | self.data.extend_from_slice(&v.to_le_bytes()); |
9cc50fc6 SL |
84 | } |
85 | ||
2c00a5a8 | 86 | #[inline] |
923072b8 | 87 | fn emit_u8(&mut self, v: u8) { |
8faf50e0 | 88 | self.data.push(v); |
9cc50fc6 SL |
89 | } |
90 | ||
2c00a5a8 | 91 | #[inline] |
923072b8 | 92 | fn emit_isize(&mut self, v: isize) { |
5869c6ff | 93 | write_leb128!(self, v, isize, write_isize_leb128) |
9cc50fc6 SL |
94 | } |
95 | ||
2c00a5a8 | 96 | #[inline] |
923072b8 | 97 | fn emit_i128(&mut self, v: i128) { |
5869c6ff | 98 | write_leb128!(self, v, i128, write_i128_leb128) |
32a655c1 SL |
99 | } |
100 | ||
2c00a5a8 | 101 | #[inline] |
923072b8 | 102 | fn emit_i64(&mut self, v: i64) { |
5869c6ff | 103 | write_leb128!(self, v, i64, write_i64_leb128) |
9cc50fc6 SL |
104 | } |
105 | ||
2c00a5a8 | 106 | #[inline] |
923072b8 | 107 | fn emit_i32(&mut self, v: i32) { |
5869c6ff | 108 | write_leb128!(self, v, i32, write_i32_leb128) |
9cc50fc6 SL |
109 | } |
110 | ||
2c00a5a8 | 111 | #[inline] |
923072b8 | 112 | fn emit_i16(&mut self, v: i16) { |
a2a8927a | 113 | self.data.extend_from_slice(&v.to_le_bytes()); |
9cc50fc6 SL |
114 | } |
115 | ||
2c00a5a8 | 116 | #[inline] |
923072b8 FG |
117 | fn emit_i8(&mut self, v: i8) { |
118 | self.emit_u8(v as u8); | |
9cc50fc6 SL |
119 | } |
120 | ||
2c00a5a8 | 121 | #[inline] |
923072b8 FG |
122 | fn emit_bool(&mut self, v: bool) { |
123 | self.emit_u8(if v { 1 } else { 0 }); | |
9cc50fc6 SL |
124 | } |
125 | ||
2c00a5a8 | 126 | #[inline] |
923072b8 | 127 | fn emit_f64(&mut self, v: f64) { |
3dfed10e | 128 | let as_u64: u64 = v.to_bits(); |
923072b8 | 129 | self.emit_u64(as_u64); |
9cc50fc6 SL |
130 | } |
131 | ||
2c00a5a8 | 132 | #[inline] |
923072b8 | 133 | fn emit_f32(&mut self, v: f32) { |
3dfed10e | 134 | let as_u32: u32 = v.to_bits(); |
923072b8 | 135 | self.emit_u32(as_u32); |
9cc50fc6 SL |
136 | } |
137 | ||
2c00a5a8 | 138 | #[inline] |
923072b8 FG |
139 | fn emit_char(&mut self, v: char) { |
140 | self.emit_u32(v as u32); | |
9cc50fc6 SL |
141 | } |
142 | ||
2c00a5a8 | 143 | #[inline] |
923072b8 FG |
144 | fn emit_str(&mut self, v: &str) { |
145 | self.emit_usize(v.len()); | |
146 | self.emit_raw_bytes(v.as_bytes()); | |
147 | self.emit_u8(STR_SENTINEL); | |
cdc7bbd5 XL |
148 | } |
149 | ||
150 | #[inline] | |
923072b8 | 151 | fn emit_raw_bytes(&mut self, s: &[u8]) { |
cdc7bbd5 | 152 | self.data.extend_from_slice(s); |
9cc50fc6 | 153 | } |
9cc50fc6 SL |
154 | } |
155 | ||
923072b8 | 156 | pub type FileEncodeResult = Result<usize, io::Error>; |
5869c6ff XL |
157 | |
158 | // `FileEncoder` encodes data to file via fixed-size buffer. | |
159 | // | |
160 | // When encoding large amounts of data to a file, using `FileEncoder` may be | |
923072b8 | 161 | // preferred over using `MemEncoder` to encode to a `Vec`, and then writing the |
5869c6ff XL |
162 | // `Vec` to file, as the latter uses as much memory as there is encoded data, |
163 | // while the former uses the fixed amount of memory allocated to the buffer. | |
164 | // `FileEncoder` also has the advantage of not needing to reallocate as data | |
165 | // is appended to it, but the disadvantage of requiring more error handling, | |
166 | // which has some runtime overhead. | |
167 | pub struct FileEncoder { | |
168 | // The input buffer. For adequate performance, we need more control over | |
169 | // buffering than `BufWriter` offers. If `BufWriter` ever offers a raw | |
170 | // buffer access API, we can use it, and remove `buf` and `buffered`. | |
171 | buf: Box<[MaybeUninit<u8>]>, | |
172 | buffered: usize, | |
173 | flushed: usize, | |
174 | file: File, | |
923072b8 FG |
175 | // This is used to implement delayed error handling, as described in the |
176 | // comment on `trait Encoder`. | |
177 | res: Result<(), io::Error>, | |
5869c6ff XL |
178 | } |
179 | ||
180 | impl FileEncoder { | |
181 | pub fn new<P: AsRef<Path>>(path: P) -> io::Result<Self> { | |
182 | const DEFAULT_BUF_SIZE: usize = 8192; | |
183 | FileEncoder::with_capacity(path, DEFAULT_BUF_SIZE) | |
184 | } | |
185 | ||
186 | pub fn with_capacity<P: AsRef<Path>>(path: P, capacity: usize) -> io::Result<Self> { | |
187 | // Require capacity at least as large as the largest LEB128 encoding | |
188 | // here, so that we don't have to check or handle this on every write. | |
189 | assert!(capacity >= max_leb128_len()); | |
190 | ||
191 | // Require capacity small enough such that some capacity checks can be | |
192 | // done using guaranteed non-overflowing add rather than sub, which | |
193 | // shaves an instruction off those code paths (on x86 at least). | |
194 | assert!(capacity <= usize::MAX - max_leb128_len()); | |
195 | ||
196 | let file = File::create(path)?; | |
197 | ||
923072b8 FG |
198 | Ok(FileEncoder { |
199 | buf: Box::new_uninit_slice(capacity), | |
200 | buffered: 0, | |
201 | flushed: 0, | |
202 | file, | |
203 | res: Ok(()), | |
204 | }) | |
5869c6ff XL |
205 | } |
206 | ||
2c00a5a8 | 207 | #[inline] |
9cc50fc6 | 208 | pub fn position(&self) -> usize { |
5869c6ff XL |
209 | // Tracking position this way instead of having a `self.position` field |
210 | // means that we don't have to update the position on every write call. | |
211 | self.flushed + self.buffered | |
212 | } | |
213 | ||
923072b8 | 214 | pub fn flush(&mut self) { |
5869c6ff XL |
215 | // This is basically a copy of `BufWriter::flush`. If `BufWriter` ever |
216 | // offers a raw buffer access API, we can use it, and remove this. | |
217 | ||
218 | /// Helper struct to ensure the buffer is updated after all the writes | |
219 | /// are complete. It tracks the number of written bytes and drains them | |
220 | /// all from the front of the buffer when dropped. | |
221 | struct BufGuard<'a> { | |
222 | buffer: &'a mut [u8], | |
223 | encoder_buffered: &'a mut usize, | |
224 | encoder_flushed: &'a mut usize, | |
225 | flushed: usize, | |
226 | } | |
227 | ||
228 | impl<'a> BufGuard<'a> { | |
229 | fn new( | |
230 | buffer: &'a mut [u8], | |
231 | encoder_buffered: &'a mut usize, | |
232 | encoder_flushed: &'a mut usize, | |
233 | ) -> Self { | |
234 | assert_eq!(buffer.len(), *encoder_buffered); | |
235 | Self { buffer, encoder_buffered, encoder_flushed, flushed: 0 } | |
236 | } | |
237 | ||
238 | /// The unwritten part of the buffer | |
239 | fn remaining(&self) -> &[u8] { | |
240 | &self.buffer[self.flushed..] | |
241 | } | |
242 | ||
243 | /// Flag some bytes as removed from the front of the buffer | |
244 | fn consume(&mut self, amt: usize) { | |
245 | self.flushed += amt; | |
246 | } | |
247 | ||
248 | /// true if all of the bytes have been written | |
249 | fn done(&self) -> bool { | |
250 | self.flushed >= *self.encoder_buffered | |
251 | } | |
252 | } | |
253 | ||
254 | impl Drop for BufGuard<'_> { | |
255 | fn drop(&mut self) { | |
256 | if self.flushed > 0 { | |
257 | if self.done() { | |
258 | *self.encoder_flushed += *self.encoder_buffered; | |
259 | *self.encoder_buffered = 0; | |
260 | } else { | |
261 | self.buffer.copy_within(self.flushed.., 0); | |
262 | *self.encoder_flushed += self.flushed; | |
263 | *self.encoder_buffered -= self.flushed; | |
264 | } | |
265 | } | |
266 | } | |
267 | } | |
268 | ||
923072b8 FG |
269 | // If we've already had an error, do nothing. It'll get reported after |
270 | // `finish` is called. | |
271 | if self.res.is_err() { | |
272 | return; | |
273 | } | |
274 | ||
5869c6ff XL |
275 | let mut guard = BufGuard::new( |
276 | unsafe { MaybeUninit::slice_assume_init_mut(&mut self.buf[..self.buffered]) }, | |
277 | &mut self.buffered, | |
278 | &mut self.flushed, | |
279 | ); | |
280 | ||
281 | while !guard.done() { | |
282 | match self.file.write(guard.remaining()) { | |
283 | Ok(0) => { | |
923072b8 | 284 | self.res = Err(io::Error::new( |
5869c6ff XL |
285 | io::ErrorKind::WriteZero, |
286 | "failed to write the buffered data", | |
287 | )); | |
923072b8 | 288 | return; |
5869c6ff XL |
289 | } |
290 | Ok(n) => guard.consume(n), | |
291 | Err(ref e) if e.kind() == io::ErrorKind::Interrupted => {} | |
923072b8 FG |
292 | Err(e) => { |
293 | self.res = Err(e); | |
294 | return; | |
295 | } | |
5869c6ff XL |
296 | } |
297 | } | |
5869c6ff XL |
298 | } |
299 | ||
300 | #[inline] | |
301 | fn capacity(&self) -> usize { | |
302 | self.buf.len() | |
303 | } | |
304 | ||
305 | #[inline] | |
923072b8 | 306 | fn write_one(&mut self, value: u8) { |
5869c6ff XL |
307 | // We ensure this during `FileEncoder` construction. |
308 | debug_assert!(self.capacity() >= 1); | |
309 | ||
310 | let mut buffered = self.buffered; | |
311 | ||
312 | if std::intrinsics::unlikely(buffered >= self.capacity()) { | |
923072b8 | 313 | self.flush(); |
5869c6ff XL |
314 | buffered = 0; |
315 | } | |
316 | ||
317 | // SAFETY: The above check and `flush` ensures that there is enough | |
318 | // room to write the input to the buffer. | |
319 | unsafe { | |
320 | *MaybeUninit::slice_as_mut_ptr(&mut self.buf).add(buffered) = value; | |
321 | } | |
322 | ||
323 | self.buffered = buffered + 1; | |
5869c6ff XL |
324 | } |
325 | ||
326 | #[inline] | |
923072b8 | 327 | fn write_all(&mut self, buf: &[u8]) { |
5869c6ff XL |
328 | let capacity = self.capacity(); |
329 | let buf_len = buf.len(); | |
330 | ||
331 | if std::intrinsics::likely(buf_len <= capacity) { | |
332 | let mut buffered = self.buffered; | |
333 | ||
334 | if std::intrinsics::unlikely(buf_len > capacity - buffered) { | |
923072b8 | 335 | self.flush(); |
5869c6ff XL |
336 | buffered = 0; |
337 | } | |
338 | ||
339 | // SAFETY: The above check and `flush` ensures that there is enough | |
340 | // room to write the input to the buffer. | |
341 | unsafe { | |
342 | let src = buf.as_ptr(); | |
343 | let dst = MaybeUninit::slice_as_mut_ptr(&mut self.buf).add(buffered); | |
344 | ptr::copy_nonoverlapping(src, dst, buf_len); | |
345 | } | |
346 | ||
347 | self.buffered = buffered + buf_len; | |
5869c6ff | 348 | } else { |
923072b8 | 349 | self.write_all_unbuffered(buf); |
5869c6ff XL |
350 | } |
351 | } | |
352 | ||
923072b8 FG |
353 | fn write_all_unbuffered(&mut self, mut buf: &[u8]) { |
354 | // If we've already had an error, do nothing. It'll get reported after | |
355 | // `finish` is called. | |
356 | if self.res.is_err() { | |
357 | return; | |
358 | } | |
359 | ||
5869c6ff | 360 | if self.buffered > 0 { |
923072b8 | 361 | self.flush(); |
5869c6ff XL |
362 | } |
363 | ||
364 | // This is basically a copy of `Write::write_all` but also updates our | |
365 | // `self.flushed`. It's necessary because `Write::write_all` does not | |
366 | // return the number of bytes written when an error is encountered, and | |
367 | // without that, we cannot accurately update `self.flushed` on error. | |
368 | while !buf.is_empty() { | |
369 | match self.file.write(buf) { | |
370 | Ok(0) => { | |
923072b8 | 371 | self.res = Err(io::Error::new( |
5869c6ff XL |
372 | io::ErrorKind::WriteZero, |
373 | "failed to write whole buffer", | |
374 | )); | |
923072b8 | 375 | return; |
5869c6ff XL |
376 | } |
377 | Ok(n) => { | |
378 | buf = &buf[n..]; | |
379 | self.flushed += n; | |
380 | } | |
381 | Err(ref e) if e.kind() == io::ErrorKind::Interrupted => {} | |
923072b8 FG |
382 | Err(e) => { |
383 | self.res = Err(e); | |
384 | return; | |
385 | } | |
5869c6ff XL |
386 | } |
387 | } | |
923072b8 FG |
388 | } |
389 | ||
390 | pub fn finish(mut self) -> Result<usize, io::Error> { | |
391 | self.flush(); | |
5869c6ff | 392 | |
923072b8 FG |
393 | let res = std::mem::replace(&mut self.res, Ok(())); |
394 | res.map(|()| self.position()) | |
5869c6ff XL |
395 | } |
396 | } | |
397 | ||
398 | impl Drop for FileEncoder { | |
399 | fn drop(&mut self) { | |
923072b8 FG |
400 | // Likely to be a no-op, because `finish` should have been called and |
401 | // it also flushes. But do it just in case. | |
5869c6ff XL |
402 | let _result = self.flush(); |
403 | } | |
404 | } | |
405 | ||
406 | macro_rules! file_encoder_write_leb128 { | |
407 | ($enc:expr, $value:expr, $int_ty:ty, $fun:ident) => {{ | |
408 | const MAX_ENCODED_LEN: usize = max_leb128_len!($int_ty); | |
409 | ||
410 | // We ensure this during `FileEncoder` construction. | |
411 | debug_assert!($enc.capacity() >= MAX_ENCODED_LEN); | |
412 | ||
413 | let mut buffered = $enc.buffered; | |
414 | ||
415 | // This can't overflow. See assertion in `FileEncoder::with_capacity`. | |
416 | if std::intrinsics::unlikely(buffered + MAX_ENCODED_LEN > $enc.capacity()) { | |
923072b8 | 417 | $enc.flush(); |
5869c6ff XL |
418 | buffered = 0; |
419 | } | |
420 | ||
421 | // SAFETY: The above check and flush ensures that there is enough | |
422 | // room to write the encoded value to the buffer. | |
423 | let buf = unsafe { | |
424 | &mut *($enc.buf.as_mut_ptr().add(buffered) as *mut [MaybeUninit<u8>; MAX_ENCODED_LEN]) | |
425 | }; | |
426 | ||
427 | let encoded = leb128::$fun(buf, $value); | |
428 | $enc.buffered = buffered + encoded.len(); | |
5869c6ff XL |
429 | }}; |
430 | } | |
431 | ||
923072b8 | 432 | impl Encoder for FileEncoder { |
5869c6ff | 433 | #[inline] |
923072b8 | 434 | fn emit_usize(&mut self, v: usize) { |
5869c6ff XL |
435 | file_encoder_write_leb128!(self, v, usize, write_usize_leb128) |
436 | } | |
437 | ||
438 | #[inline] | |
923072b8 | 439 | fn emit_u128(&mut self, v: u128) { |
5869c6ff XL |
440 | file_encoder_write_leb128!(self, v, u128, write_u128_leb128) |
441 | } | |
442 | ||
443 | #[inline] | |
923072b8 | 444 | fn emit_u64(&mut self, v: u64) { |
5869c6ff XL |
445 | file_encoder_write_leb128!(self, v, u64, write_u64_leb128) |
446 | } | |
447 | ||
448 | #[inline] | |
923072b8 | 449 | fn emit_u32(&mut self, v: u32) { |
5869c6ff XL |
450 | file_encoder_write_leb128!(self, v, u32, write_u32_leb128) |
451 | } | |
452 | ||
453 | #[inline] | |
923072b8 FG |
454 | fn emit_u16(&mut self, v: u16) { |
455 | self.write_all(&v.to_le_bytes()); | |
5869c6ff XL |
456 | } |
457 | ||
458 | #[inline] | |
923072b8 FG |
459 | fn emit_u8(&mut self, v: u8) { |
460 | self.write_one(v); | |
5869c6ff XL |
461 | } |
462 | ||
463 | #[inline] | |
923072b8 | 464 | fn emit_isize(&mut self, v: isize) { |
5869c6ff XL |
465 | file_encoder_write_leb128!(self, v, isize, write_isize_leb128) |
466 | } | |
467 | ||
468 | #[inline] | |
923072b8 | 469 | fn emit_i128(&mut self, v: i128) { |
5869c6ff XL |
470 | file_encoder_write_leb128!(self, v, i128, write_i128_leb128) |
471 | } | |
472 | ||
473 | #[inline] | |
923072b8 | 474 | fn emit_i64(&mut self, v: i64) { |
5869c6ff XL |
475 | file_encoder_write_leb128!(self, v, i64, write_i64_leb128) |
476 | } | |
477 | ||
478 | #[inline] | |
923072b8 | 479 | fn emit_i32(&mut self, v: i32) { |
5869c6ff XL |
480 | file_encoder_write_leb128!(self, v, i32, write_i32_leb128) |
481 | } | |
482 | ||
483 | #[inline] | |
923072b8 FG |
484 | fn emit_i16(&mut self, v: i16) { |
485 | self.write_all(&v.to_le_bytes()); | |
5869c6ff XL |
486 | } |
487 | ||
488 | #[inline] | |
923072b8 FG |
489 | fn emit_i8(&mut self, v: i8) { |
490 | self.emit_u8(v as u8); | |
5869c6ff XL |
491 | } |
492 | ||
493 | #[inline] | |
923072b8 FG |
494 | fn emit_bool(&mut self, v: bool) { |
495 | self.emit_u8(if v { 1 } else { 0 }); | |
5869c6ff XL |
496 | } |
497 | ||
498 | #[inline] | |
923072b8 | 499 | fn emit_f64(&mut self, v: f64) { |
5869c6ff | 500 | let as_u64: u64 = v.to_bits(); |
923072b8 | 501 | self.emit_u64(as_u64); |
5869c6ff XL |
502 | } |
503 | ||
504 | #[inline] | |
923072b8 | 505 | fn emit_f32(&mut self, v: f32) { |
5869c6ff | 506 | let as_u32: u32 = v.to_bits(); |
923072b8 | 507 | self.emit_u32(as_u32); |
5869c6ff XL |
508 | } |
509 | ||
510 | #[inline] | |
923072b8 FG |
511 | fn emit_char(&mut self, v: char) { |
512 | self.emit_u32(v as u32); | |
5869c6ff XL |
513 | } |
514 | ||
515 | #[inline] | |
923072b8 FG |
516 | fn emit_str(&mut self, v: &str) { |
517 | self.emit_usize(v.len()); | |
518 | self.emit_raw_bytes(v.as_bytes()); | |
519 | self.emit_u8(STR_SENTINEL); | |
9cc50fc6 | 520 | } |
cdc7bbd5 XL |
521 | |
522 | #[inline] | |
923072b8 FG |
523 | fn emit_raw_bytes(&mut self, s: &[u8]) { |
524 | self.write_all(s); | |
cdc7bbd5 | 525 | } |
9cc50fc6 SL |
526 | } |
527 | ||
528 | // ----------------------------------------------------------------------------- | |
529 | // Decoder | |
530 | // ----------------------------------------------------------------------------- | |
531 | ||
923072b8 | 532 | pub struct MemDecoder<'a> { |
9cc50fc6 SL |
533 | pub data: &'a [u8], |
534 | position: usize, | |
535 | } | |
536 | ||
923072b8 | 537 | impl<'a> MemDecoder<'a> { |
0731742a | 538 | #[inline] |
923072b8 FG |
539 | pub fn new(data: &'a [u8], position: usize) -> MemDecoder<'a> { |
540 | MemDecoder { data, position } | |
9cc50fc6 SL |
541 | } |
542 | ||
2c00a5a8 | 543 | #[inline] |
9cc50fc6 SL |
544 | pub fn position(&self) -> usize { |
545 | self.position | |
546 | } | |
547 | ||
2c00a5a8 | 548 | #[inline] |
ff7c6d11 XL |
549 | pub fn set_position(&mut self, pos: usize) { |
550 | self.position = pos | |
551 | } | |
552 | ||
2c00a5a8 | 553 | #[inline] |
9cc50fc6 SL |
554 | pub fn advance(&mut self, bytes: usize) { |
555 | self.position += bytes; | |
556 | } | |
557 | } | |
558 | ||
5869c6ff | 559 | macro_rules! read_leb128 { |
5099ac24 | 560 | ($dec:expr, $fun:ident) => {{ leb128::$fun($dec.data, &mut $dec.position) }}; |
9cc50fc6 SL |
561 | } |
562 | ||
923072b8 | 563 | impl<'a> Decoder for MemDecoder<'a> { |
32a655c1 | 564 | #[inline] |
5099ac24 | 565 | fn read_u128(&mut self) -> u128 { |
5869c6ff | 566 | read_leb128!(self, read_u128_leb128) |
32a655c1 SL |
567 | } |
568 | ||
c30ab7b3 | 569 | #[inline] |
5099ac24 | 570 | fn read_u64(&mut self) -> u64 { |
5869c6ff | 571 | read_leb128!(self, read_u64_leb128) |
9cc50fc6 SL |
572 | } |
573 | ||
c30ab7b3 | 574 | #[inline] |
5099ac24 | 575 | fn read_u32(&mut self) -> u32 { |
5869c6ff | 576 | read_leb128!(self, read_u32_leb128) |
9cc50fc6 SL |
577 | } |
578 | ||
c30ab7b3 | 579 | #[inline] |
5099ac24 | 580 | fn read_u16(&mut self) -> u16 { |
a2a8927a XL |
581 | let bytes = [self.data[self.position], self.data[self.position + 1]]; |
582 | let value = u16::from_le_bytes(bytes); | |
583 | self.position += 2; | |
5099ac24 | 584 | value |
9cc50fc6 SL |
585 | } |
586 | ||
c30ab7b3 | 587 | #[inline] |
5099ac24 | 588 | fn read_u8(&mut self) -> u8 { |
9cc50fc6 SL |
589 | let value = self.data[self.position]; |
590 | self.position += 1; | |
5099ac24 | 591 | value |
9cc50fc6 SL |
592 | } |
593 | ||
c30ab7b3 | 594 | #[inline] |
5099ac24 | 595 | fn read_usize(&mut self) -> usize { |
5869c6ff | 596 | read_leb128!(self, read_usize_leb128) |
9cc50fc6 SL |
597 | } |
598 | ||
32a655c1 | 599 | #[inline] |
5099ac24 | 600 | fn read_i128(&mut self) -> i128 { |
5869c6ff | 601 | read_leb128!(self, read_i128_leb128) |
32a655c1 SL |
602 | } |
603 | ||
c30ab7b3 | 604 | #[inline] |
5099ac24 | 605 | fn read_i64(&mut self) -> i64 { |
5869c6ff | 606 | read_leb128!(self, read_i64_leb128) |
9cc50fc6 SL |
607 | } |
608 | ||
c30ab7b3 | 609 | #[inline] |
5099ac24 | 610 | fn read_i32(&mut self) -> i32 { |
5869c6ff | 611 | read_leb128!(self, read_i32_leb128) |
9cc50fc6 SL |
612 | } |
613 | ||
c30ab7b3 | 614 | #[inline] |
5099ac24 | 615 | fn read_i16(&mut self) -> i16 { |
a2a8927a XL |
616 | let bytes = [self.data[self.position], self.data[self.position + 1]]; |
617 | let value = i16::from_le_bytes(bytes); | |
618 | self.position += 2; | |
5099ac24 | 619 | value |
9cc50fc6 SL |
620 | } |
621 | ||
c30ab7b3 | 622 | #[inline] |
5099ac24 FG |
623 | fn read_i8(&mut self) -> i8 { |
624 | let value = self.data[self.position]; | |
9cc50fc6 | 625 | self.position += 1; |
5099ac24 | 626 | value as i8 |
9cc50fc6 SL |
627 | } |
628 | ||
c30ab7b3 | 629 | #[inline] |
5099ac24 | 630 | fn read_isize(&mut self) -> isize { |
5869c6ff | 631 | read_leb128!(self, read_isize_leb128) |
9cc50fc6 SL |
632 | } |
633 | ||
c30ab7b3 | 634 | #[inline] |
5099ac24 FG |
635 | fn read_bool(&mut self) -> bool { |
636 | let value = self.read_u8(); | |
637 | value != 0 | |
9cc50fc6 SL |
638 | } |
639 | ||
c30ab7b3 | 640 | #[inline] |
5099ac24 FG |
641 | fn read_f64(&mut self) -> f64 { |
642 | let bits = self.read_u64(); | |
643 | f64::from_bits(bits) | |
9cc50fc6 SL |
644 | } |
645 | ||
c30ab7b3 | 646 | #[inline] |
5099ac24 FG |
647 | fn read_f32(&mut self) -> f32 { |
648 | let bits = self.read_u32(); | |
649 | f32::from_bits(bits) | |
9cc50fc6 SL |
650 | } |
651 | ||
c30ab7b3 | 652 | #[inline] |
5099ac24 FG |
653 | fn read_char(&mut self) -> char { |
654 | let bits = self.read_u32(); | |
655 | std::char::from_u32(bits).unwrap() | |
9cc50fc6 SL |
656 | } |
657 | ||
c30ab7b3 | 658 | #[inline] |
5e7ed085 | 659 | fn read_str(&mut self) -> &'a str { |
5099ac24 | 660 | let len = self.read_usize(); |
a2a8927a XL |
661 | let sentinel = self.data[self.position + len]; |
662 | assert!(sentinel == STR_SENTINEL); | |
663 | let s = unsafe { | |
664 | std::str::from_utf8_unchecked(&self.data[self.position..self.position + len]) | |
665 | }; | |
666 | self.position += len + 1; | |
5e7ed085 | 667 | s |
9cc50fc6 SL |
668 | } |
669 | ||
b7449926 | 670 | #[inline] |
5e7ed085 | 671 | fn read_raw_bytes(&mut self, bytes: usize) -> &'a [u8] { |
cdc7bbd5 | 672 | let start = self.position; |
5e7ed085 FG |
673 | self.position += bytes; |
674 | &self.data[start..self.position] | |
cdc7bbd5 | 675 | } |
9cc50fc6 | 676 | } |
5869c6ff XL |
677 | |
678 | // Specializations for contiguous byte sequences follow. The default implementations for slices | |
679 | // encode and decode each element individually. This isn't necessary for `u8` slices when using | |
680 | // opaque encoders and decoders, because each `u8` is unchanged by encoding and decoding. | |
681 | // Therefore, we can use more efficient implementations that process the entire sequence at once. | |
682 | ||
683 | // Specialize encoding byte slices. This specialization also applies to encoding `Vec<u8>`s, etc., | |
684 | // since the default implementations call `encode` on their slices internally. | |
923072b8 FG |
685 | impl Encodable<MemEncoder> for [u8] { |
686 | fn encode(&self, e: &mut MemEncoder) { | |
687 | Encoder::emit_usize(e, self.len()); | |
688 | e.emit_raw_bytes(self); | |
5869c6ff XL |
689 | } |
690 | } | |
691 | ||
923072b8 FG |
692 | impl Encodable<FileEncoder> for [u8] { |
693 | fn encode(&self, e: &mut FileEncoder) { | |
694 | Encoder::emit_usize(e, self.len()); | |
695 | e.emit_raw_bytes(self); | |
5869c6ff XL |
696 | } |
697 | } | |
698 | ||
699 | // Specialize decoding `Vec<u8>`. This specialization also applies to decoding `Box<[u8]>`s, etc., | |
700 | // since the default implementations call `decode` to produce a `Vec<u8>` internally. | |
923072b8 FG |
701 | impl<'a> Decodable<MemDecoder<'a>> for Vec<u8> { |
702 | fn decode(d: &mut MemDecoder<'a>) -> Self { | |
703 | let len = Decoder::read_usize(d); | |
5099ac24 | 704 | d.read_raw_bytes(len).to_owned() |
cdc7bbd5 XL |
705 | } |
706 | } | |
5869c6ff | 707 | |
cdc7bbd5 XL |
708 | // An integer that will always encode to 8 bytes. |
709 | pub struct IntEncodedWithFixedSize(pub u64); | |
5869c6ff | 710 | |
cdc7bbd5 XL |
711 | impl IntEncodedWithFixedSize { |
712 | pub const ENCODED_SIZE: usize = 8; | |
713 | } | |
714 | ||
923072b8 | 715 | impl Encodable<MemEncoder> for IntEncodedWithFixedSize { |
cdc7bbd5 | 716 | #[inline] |
923072b8 | 717 | fn encode(&self, e: &mut MemEncoder) { |
cdc7bbd5 | 718 | let _start_pos = e.position(); |
923072b8 | 719 | e.emit_raw_bytes(&self.0.to_le_bytes()); |
cdc7bbd5 XL |
720 | let _end_pos = e.position(); |
721 | debug_assert_eq!((_end_pos - _start_pos), IntEncodedWithFixedSize::ENCODED_SIZE); | |
cdc7bbd5 XL |
722 | } |
723 | } | |
724 | ||
923072b8 | 725 | impl Encodable<FileEncoder> for IntEncodedWithFixedSize { |
cdc7bbd5 | 726 | #[inline] |
923072b8 | 727 | fn encode(&self, e: &mut FileEncoder) { |
cdc7bbd5 | 728 | let _start_pos = e.position(); |
923072b8 | 729 | e.emit_raw_bytes(&self.0.to_le_bytes()); |
cdc7bbd5 XL |
730 | let _end_pos = e.position(); |
731 | debug_assert_eq!((_end_pos - _start_pos), IntEncodedWithFixedSize::ENCODED_SIZE); | |
cdc7bbd5 XL |
732 | } |
733 | } | |
734 | ||
923072b8 | 735 | impl<'a> Decodable<MemDecoder<'a>> for IntEncodedWithFixedSize { |
cdc7bbd5 | 736 | #[inline] |
923072b8 | 737 | fn decode(decoder: &mut MemDecoder<'a>) -> IntEncodedWithFixedSize { |
cdc7bbd5 XL |
738 | let _start_pos = decoder.position(); |
739 | let bytes = decoder.read_raw_bytes(IntEncodedWithFixedSize::ENCODED_SIZE); | |
5e7ed085 | 740 | let value = u64::from_le_bytes(bytes.try_into().unwrap()); |
cdc7bbd5 XL |
741 | let _end_pos = decoder.position(); |
742 | debug_assert_eq!((_end_pos - _start_pos), IntEncodedWithFixedSize::ENCODED_SIZE); | |
5869c6ff | 743 | |
5099ac24 | 744 | IntEncodedWithFixedSize(value) |
5869c6ff XL |
745 | } |
746 | } |