zerompk/
write.rs

1use alloc::vec::Vec;
2
3use crate::{Error, Result, consts::*};
4
5pub trait Write {
6    fn write_nil(&mut self) -> Result<()>;
7    fn write_boolean(&mut self, b: bool) -> Result<()>;
8    fn write_u8(&mut self, u: u8) -> Result<()>;
9    fn write_u16(&mut self, u: u16) -> Result<()>;
10    fn write_u32(&mut self, u: u32) -> Result<()>;
11    fn write_u64(&mut self, u: u64) -> Result<()>;
12    fn write_i8(&mut self, i: i8) -> Result<()>;
13    fn write_i16(&mut self, i: i16) -> Result<()>;
14    fn write_i32(&mut self, i: i32) -> Result<()>;
15    fn write_i64(&mut self, i: i64) -> Result<()>;
16    fn write_f32(&mut self, f: f32) -> Result<()>;
17    fn write_f64(&mut self, f: f64) -> Result<()>;
18    fn write_string(&mut self, s: &str) -> Result<()>;
19    fn write_binary(&mut self, data: &[u8]) -> Result<()>;
20    fn write_timestamp(&mut self, seconds: i64, nanoseconds: u32) -> Result<()>;
21    fn write_array_len(&mut self, len: usize) -> Result<()>;
22    fn write_map_len(&mut self, len: usize) -> Result<()>;
23    fn write_ext(&mut self, type_id: i8, data: &[u8]) -> Result<()>;
24}
25
26pub struct SliceWriter<'a> {
27    buffer: &'a mut [u8],
28    pos: usize,
29}
30
31impl<'a> SliceWriter<'a> {
32    pub fn new(buffer: &'a mut [u8]) -> Self {
33        SliceWriter { buffer, pos: 0 }
34    }
35
36    #[inline(always)]
37    fn take_array<const N: usize>(&mut self) -> Result<&mut [u8; N]> {
38        if self.pos + N > self.buffer.len() {
39            return Err(Error::BufferTooSmall);
40        }
41        let array: &mut [u8; N] =
42            unsafe { &mut *(self.buffer.as_mut_ptr().add(self.pos) as *mut [u8; N]) };
43        self.pos += N;
44        Ok(array)
45    }
46
47    #[inline(always)]
48    fn take_slice(&mut self, len: usize) -> Result<&mut [u8]> {
49        if self.pos + len > self.buffer.len() {
50            return Err(Error::BufferTooSmall);
51        }
52
53        let slice = unsafe { self.buffer.get_unchecked_mut(self.pos..self.pos + len) };
54        self.pos += len;
55        Ok(slice)
56    }
57
58    #[inline(always)]
59    pub fn position(&self) -> usize {
60        self.pos
61    }
62}
63
64impl<'a> Write for SliceWriter<'a> {
65    #[inline(always)]
66    fn write_nil(&mut self) -> Result<()> {
67        let buf = self.take_array::<1>()?;
68        buf[0] = NIL_MARKER;
69        Ok(())
70    }
71
72    #[inline(always)]
73    fn write_boolean(&mut self, b: bool) -> Result<()> {
74        let buf = self.take_array::<1>()?;
75        buf[0] = if b { TRUE_MARKER } else { FALSE_MARKER };
76        Ok(())
77    }
78
79    #[inline(always)]
80    fn write_u8(&mut self, u: u8) -> Result<()> {
81        if u <= POS_FIXINT_END {
82            let buf = self.take_array::<1>()?;
83            buf[0] = u;
84            Ok(())
85        } else {
86            let buf = self.take_array::<2>()?;
87            *buf = [UINT8_MARKER, u];
88            Ok(())
89        }
90    }
91
92    #[inline(always)]
93    fn write_u16(&mut self, u: u16) -> Result<()> {
94        match u {
95            0..=127 => {
96                let buf = self.take_array::<1>()?;
97                buf[0] = u as u8;
98                Ok(())
99            }
100            128..=255 => {
101                let buf = self.take_array::<2>()?;
102                *buf = [UINT8_MARKER, u as u8];
103                Ok(())
104            }
105            _ => {
106                let buf = self.take_array::<3>()?;
107                let [head, tail @ ..] = buf;
108                *head = UINT16_MARKER;
109                *tail = u.to_be_bytes();
110                Ok(())
111            }
112        }
113    }
114
115    #[inline(always)]
116    fn write_u32(&mut self, u: u32) -> Result<()> {
117        match u {
118            0..=127 => {
119                let buf = self.take_array::<1>()?;
120                buf[0] = u as u8;
121                Ok(())
122            }
123            128..=255 => {
124                let buf = self.take_array::<2>()?;
125                *buf = [UINT8_MARKER, u as u8];
126                Ok(())
127            }
128            256..=65535 => {
129                let buf = self.take_array::<3>()?;
130                let [head, tail @ ..] = buf;
131                *head = UINT16_MARKER;
132                *tail = (u as u16).to_be_bytes();
133                Ok(())
134            }
135            _ => {
136                let buf = self.take_array::<5>()?;
137                let [head, tail @ ..] = buf;
138                *head = UINT32_MARKER;
139                *tail = (u as u32).to_be_bytes();
140                Ok(())
141            }
142        }
143    }
144
145    #[inline(always)]
146    fn write_u64(&mut self, u: u64) -> Result<()> {
147        match u {
148            0..=127 => {
149                let buf = self.take_array::<1>()?;
150                buf[0] = u as u8;
151                Ok(())
152            }
153            128..=255 => {
154                let buf = self.take_array::<2>()?;
155                *buf = [UINT8_MARKER, u as u8];
156                Ok(())
157            }
158            256..=65535 => {
159                let buf = self.take_array::<3>()?;
160                let [head, tail @ ..] = buf;
161                *head = UINT16_MARKER;
162                *tail = (u as u16).to_be_bytes();
163                Ok(())
164            }
165            65536..=4294967295 => {
166                let buf = self.take_array::<5>()?;
167                let [head, tail @ ..] = buf;
168                *head = UINT32_MARKER;
169                *tail = (u as u32).to_be_bytes();
170                Ok(())
171            }
172            _ => {
173                let buf = self.take_array::<9>()?;
174                let [head, tail @ ..] = buf;
175                *head = UINT64_MARKER;
176                *tail = (u as u64).to_be_bytes();
177                Ok(())
178            }
179        }
180    }
181
182    #[inline(always)]
183    fn write_i8(&mut self, i: i8) -> Result<()> {
184        match i {
185            0..=127 => {
186                let buf = self.take_array::<1>()?;
187                buf[0] = i as u8;
188                Ok(())
189            }
190            -32..=-1 => {
191                let buf = self.take_array::<1>()?;
192                buf[0] = 0xe0 | ((i + 32) as u8);
193                Ok(())
194            }
195            _ => {
196                let buf = self.take_array::<2>()?;
197                *buf = [INT8_MARKER, i as u8];
198                Ok(())
199            }
200        }
201    }
202
203    #[inline(always)]
204    fn write_i16(&mut self, i: i16) -> Result<()> {
205        match i {
206            0..=127 => {
207                let buf = self.take_array::<1>()?;
208                buf[0] = i as u8;
209                Ok(())
210            }
211            -32..=-1 => {
212                let buf = self.take_array::<1>()?;
213                buf[0] = 0xe0 | ((i + 32) as u8);
214                Ok(())
215            }
216            -128..=127 => {
217                let buf = self.take_array::<2>()?;
218                *buf = [INT8_MARKER, i as u8];
219                Ok(())
220            }
221            _ => {
222                let buf = self.take_array::<3>()?;
223                let [head, tail @ ..] = buf;
224                *head = INT16_MARKER;
225                *tail = (i as i16).to_be_bytes();
226                Ok(())
227            }
228        }
229    }
230
231    #[inline(always)]
232    fn write_i32(&mut self, i: i32) -> Result<()> {
233        match i {
234            0..=127 => {
235                let buf = self.take_array::<1>()?;
236                buf[0] = i as u8;
237                Ok(())
238            }
239            -32..=-1 => {
240                let buf = self.take_array::<1>()?;
241                buf[0] = 0xe0 | ((i + 32) as u8);
242                Ok(())
243            }
244            -128..=127 => {
245                let buf = self.take_array::<2>()?;
246                *buf = [INT8_MARKER, i as u8];
247                Ok(())
248            }
249            -32768..=32767 => {
250                let buf = self.take_array::<3>()?;
251                let [head, tail @ ..] = buf;
252                *head = INT16_MARKER;
253                *tail = (i as i16).to_be_bytes();
254                Ok(())
255            }
256            _ => {
257                let buf = self.take_array::<5>()?;
258                let [head, tail @ ..] = buf;
259                *head = INT32_MARKER;
260                *tail = (i as i32).to_be_bytes();
261                Ok(())
262            }
263        }
264    }
265
266    #[inline(always)]
267    fn write_i64(&mut self, i: i64) -> Result<()> {
268        match i {
269            0..=127 => {
270                let buf = self.take_array::<1>()?;
271                buf[0] = i as u8;
272                Ok(())
273            }
274            -32..=-1 => {
275                let buf = self.take_array::<1>()?;
276                buf[0] = 0xe0 | ((i + 32) as u8);
277                Ok(())
278            }
279            -128..=127 => {
280                let buf = self.take_array::<2>()?;
281                *buf = [INT8_MARKER, i as u8];
282                Ok(())
283            }
284            -32768..=32767 => {
285                let buf = self.take_array::<3>()?;
286                let [head, tail @ ..] = buf;
287                *head = INT16_MARKER;
288                *tail = (i as i16).to_be_bytes();
289                Ok(())
290            }
291            -2147483648..=2147483647 => {
292                let buf = self.take_array::<5>()?;
293                let [head, tail @ ..] = buf;
294                *head = INT32_MARKER;
295                *tail = (i as i32).to_be_bytes();
296                Ok(())
297            }
298            _ => {
299                let buf = self.take_array::<9>()?;
300                let [head, tail @ ..] = buf;
301                *head = INT64_MARKER;
302                *tail = (i as i64).to_be_bytes();
303                Ok(())
304            }
305        }
306    }
307
308    #[inline(always)]
309    fn write_f32(&mut self, f: f32) -> Result<()> {
310        let buf = self.take_array::<5>()?;
311        let [head, tail @ ..] = buf;
312        *head = FLOAT32_MARKER;
313        *tail = f.to_be_bytes();
314        Ok(())
315    }
316
317    #[inline(always)]
318    fn write_f64(&mut self, f: f64) -> Result<()> {
319        let buf = self.take_array::<9>()?;
320        let [head, tail @ ..] = buf;
321        *head = FLOAT64_MARKER;
322        *tail = f.to_be_bytes();
323        Ok(())
324    }
325
326    #[inline(always)]
327    fn write_string(&mut self, s: &str) -> Result<()> {
328        let len = s.len();
329        match len {
330            // FixStr
331            0..=31 => {
332                let buf = self.take_slice(1 + len)?;
333                unsafe {
334                    let ptr = buf.as_mut_ptr();
335                    *ptr = 0xa0 | (len as u8);
336                    core::ptr::copy_nonoverlapping(s.as_bytes().as_ptr(), ptr.add(1), len);
337                }
338                Ok(())
339            }
340            // Str8
341            32..=255 => {
342                let buf = self.take_slice(2 + len)?;
343                unsafe {
344                    let ptr = buf.as_mut_ptr();
345                    *ptr = STR8_MARKER;
346                    *ptr.add(1) = len as u8;
347                    core::ptr::copy_nonoverlapping(s.as_bytes().as_ptr(), ptr.add(2), len);
348                }
349                Ok(())
350            }
351            // Str16
352            256..=65535 => {
353                let buf = self.take_slice(3 + len)?;
354                unsafe {
355                    let ptr = buf.as_mut_ptr();
356                    *ptr = STR16_MARKER;
357                    core::ptr::copy_nonoverlapping(
358                        (len as u16).to_be_bytes().as_ptr(),
359                        ptr.add(1),
360                        2,
361                    );
362                    core::ptr::copy_nonoverlapping(s.as_bytes().as_ptr(), ptr.add(3), len);
363                }
364                Ok(())
365            }
366            // Str32
367            _ => {
368                let buf = self.take_slice(5 + len)?;
369                unsafe {
370                    let ptr = buf.as_mut_ptr();
371                    *ptr = STR32_MARKER;
372                    core::ptr::copy_nonoverlapping(
373                        (len as u32).to_be_bytes().as_ptr(),
374                        ptr.add(1),
375                        4,
376                    );
377                    core::ptr::copy_nonoverlapping(s.as_bytes().as_ptr(), ptr.add(5), len);
378                }
379                Ok(())
380            }
381        }
382    }
383
384    #[inline(always)]
385    fn write_binary(&mut self, data: &[u8]) -> Result<()> {
386        let len = data.len();
387        match len {
388            // Bin8
389            0..=255 => {
390                let buf = self.take_slice(2 + len)?;
391                unsafe {
392                    let ptr = buf.as_mut_ptr();
393                    *ptr = BIN8_MARKER;
394                    *ptr.add(1) = len as u8;
395                    core::ptr::copy_nonoverlapping(data.as_ptr(), ptr.add(2), len);
396                }
397                Ok(())
398            }
399            // Bin16
400            256..=65535 => {
401                let buf = self.take_slice(3 + len)?;
402                unsafe {
403                    let ptr = buf.as_mut_ptr();
404                    *ptr = BIN16_MARKER;
405                    core::ptr::copy_nonoverlapping(
406                        (len as u16).to_be_bytes().as_ptr(),
407                        ptr.add(1),
408                        2,
409                    );
410                    core::ptr::copy_nonoverlapping(data.as_ptr(), ptr.add(3), len);
411                }
412                Ok(())
413            }
414            // Bin32
415            _ => {
416                let buf = self.take_slice(5 + len)?;
417                unsafe {
418                    let ptr = buf.as_mut_ptr();
419                    *ptr = BIN32_MARKER;
420                    core::ptr::copy_nonoverlapping(
421                        (len as u32).to_be_bytes().as_ptr(),
422                        ptr.add(1),
423                        4,
424                    );
425                    core::ptr::copy_nonoverlapping(data.as_ptr(), ptr.add(5), len);
426                }
427                Ok(())
428            }
429        }
430    }
431
432    #[inline(always)]
433    fn write_timestamp(&mut self, seconds: i64, nanoseconds: u32) -> Result<()> {
434        if nanoseconds >= 1_000_000_000 {
435            return Err(Error::InvalidTimestamp);
436        }
437
438        // timestamp 32: sec in [0, 2^32-1], nsec == 0
439        if nanoseconds == 0 && (0..=u32::MAX as i64).contains(&seconds) {
440            let buf = self.take_array::<6>()?;
441            let [head, type_marker, tail @ ..] = buf;
442            *head = TIMESTAMP32_MARKER;
443            *type_marker = 0xff;
444            *tail = (seconds as u32).to_be_bytes();
445            return Ok(());
446        }
447
448        // timestamp 64: sec in [0, 2^34-1]
449        if (0..=(1i64 << 34) - 1).contains(&seconds) {
450            let data = ((nanoseconds as u64) << 34) | (seconds as u64);
451            let buf = self.take_array::<10>()?;
452            let [head, type_marker, tail @ ..] = buf;
453            *head = TIMESTAMP64_MARKER;
454            *type_marker = 0xff;
455            *tail = data.to_be_bytes();
456            return Ok(());
457        }
458
459        // timestamp 96
460        let buf = self.take_array::<15>()?;
461        let [head, len_marker, type_marker, tail @ ..] = buf;
462        *head = TIMESTAMP96_MARKER;
463        *len_marker = 12;
464        *type_marker = 0xff;
465        unsafe {
466            let tail_ptr = tail.as_mut_ptr();
467            core::ptr::copy_nonoverlapping(nanoseconds.to_be_bytes().as_ptr(), tail_ptr, 4);
468            core::ptr::copy_nonoverlapping(
469                (seconds as i64).to_be_bytes().as_ptr(),
470                tail_ptr.add(4),
471                8,
472            );
473        }
474        Ok(())
475    }
476
477    #[inline(always)]
478    fn write_array_len(&mut self, len: usize) -> Result<()> {
479        match len {
480            0..=15 => {
481                let buf = self.take_array::<1>()?;
482                buf[0] = FIXARRAY_START | (len as u8);
483                Ok(())
484            }
485            16..=65535 => {
486                let buf = self.take_array::<3>()?;
487                let [head, tail @ ..] = buf;
488                *head = ARRAY16_MARKER;
489                *tail = (len as u16).to_be_bytes();
490                Ok(())
491            }
492            _ => {
493                let buf = self.take_array::<5>()?;
494                let [head, tail @ ..] = buf;
495                *head = ARRAY32_MARKER;
496                *tail = (len as u32).to_be_bytes();
497                Ok(())
498            }
499        }
500    }
501
502    #[inline(always)]
503    fn write_map_len(&mut self, len: usize) -> Result<()> {
504        match len {
505            0..=15 => {
506                let buf = self.take_array::<1>()?;
507                buf[0] = FIXMAP_START | (len as u8);
508                Ok(())
509            }
510            16..=65535 => {
511                let buf = self.take_array::<3>()?;
512                let [head, tail @ ..] = buf;
513                *head = MAP16_MARKER;
514                *tail = (len as u16).to_be_bytes();
515                Ok(())
516            }
517            _ => {
518                let buf = self.take_array::<5>()?;
519                let [head, tail @ ..] = buf;
520                *head = MAP32_MARKER;
521                *tail = (len as u32).to_be_bytes();
522                Ok(())
523            }
524        }
525    }
526
527    fn write_ext(&mut self, type_id: i8, data: &[u8]) -> Result<()> {
528        let len = data.len();
529        match len {
530            1 => {
531                let buf = self.take_array::<3>()?;
532                let [head, type_marker, tail] = buf;
533                *head = FIXEXT1_MARKER;
534                *type_marker = type_id as u8;
535                *tail = data[0];
536                Ok(())
537            }
538            2 => {
539                let buf = self.take_array::<4>()?;
540                let [head, type_marker, tail @ ..] = buf;
541                *head = FIXEXT2_MARKER;
542                *type_marker = type_id as u8;
543                *tail = data.try_into().unwrap();
544                Ok(())
545            }
546            4 => {
547                let buf = self.take_array::<6>()?;
548                let [head, type_marker, tail @ ..] = buf;
549                *head = FIXEXT4_MARKER;
550                *type_marker = type_id as u8;
551                *tail = data.try_into().unwrap();
552                Ok(())
553            }
554            8 => {
555                let buf = self.take_array::<10>()?;
556                let [head, type_marker, tail @ ..] = buf;
557                *head = FIXEXT8_MARKER;
558                *type_marker = type_id as u8;
559                *tail = data.try_into().unwrap();
560                Ok(())
561            }
562            16 => {
563                let buf = self.take_array::<18>()?;
564                let [head, type_marker, tail @ ..] = buf;
565                *head = FIXEXT16_MARKER;
566                *type_marker = type_id as u8;
567                *tail = data.try_into().unwrap();
568                Ok(())
569            }
570            0..=255 => {
571                let buf = self.take_slice(2 + len)?;
572                unsafe {
573                    let (header, body) = buf.split_at_mut(2);
574                    header.copy_from_slice(&[EXT8_MARKER, len as u8]);
575                    core::ptr::copy_nonoverlapping(data.as_ptr(), body.as_mut_ptr(), len);
576                }
577                Ok(())
578            }
579            256..=65535 => {
580                let buf = self.take_slice(3 + len)?;
581                unsafe {
582                    let (header, body) = buf.split_at_mut(3);
583                    let len_bytes = (len as u16).to_be_bytes();
584                    header.copy_from_slice(&[EXT16_MARKER, len_bytes[0], len_bytes[1]]);
585                    core::ptr::copy_nonoverlapping(data.as_ptr(), body.as_mut_ptr(), len);
586                }
587                Ok(())
588            }
589            _ => {
590                let buf = self.take_slice(5 + len)?;
591                unsafe {
592                    let (header, body) = buf.split_at_mut(5);
593                    let len_bytes = (len as u32).to_be_bytes();
594                    header.copy_from_slice(&[
595                        EXT32_MARKER,
596                        len_bytes[0],
597                        len_bytes[1],
598                        len_bytes[2],
599                        len_bytes[3],
600                    ]);
601                    core::ptr::copy_nonoverlapping(data.as_ptr(), body.as_mut_ptr(), len);
602                }
603                Ok(())
604            }
605        }
606    }
607}
608
609pub struct VecWriter {
610    buffer: Vec<u8>,
611}
612
613impl VecWriter {
614    pub fn new() -> Self {
615        VecWriter { buffer: Vec::new() }
616    }
617
618    pub fn into_vec(self) -> Vec<u8> {
619        self.buffer
620    }
621}
622
623impl Write for VecWriter {
624    #[inline(always)]
625    fn write_nil(&mut self) -> Result<()> {
626        self.buffer.push(NIL_MARKER);
627        Ok(())
628    }
629
630    #[inline(always)]
631    fn write_boolean(&mut self, b: bool) -> Result<()> {
632        self.buffer.push(if b { TRUE_MARKER } else { FALSE_MARKER });
633        Ok(())
634    }
635
636    #[inline(always)]
637    fn write_u8(&mut self, u: u8) -> Result<()> {
638        if u <= POS_FIXINT_END {
639            self.buffer.push(u);
640        } else {
641            self.buffer.reserve(2);
642            unsafe {
643                let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
644                *ptr = UINT8_MARKER;
645                *ptr.add(1) = u;
646                self.buffer.set_len(self.buffer.len() + 2);
647            }
648        }
649        Ok(())
650    }
651
652    #[inline(always)]
653    fn write_u16(&mut self, u: u16) -> Result<()> {
654        match u {
655            0..=127 => {
656                self.buffer.push(u as u8);
657                Ok(())
658            }
659            128..=255 => {
660                self.buffer.reserve(2);
661                unsafe {
662                    let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
663                    *ptr = UINT8_MARKER;
664                    *ptr.add(1) = u as u8;
665                    self.buffer.set_len(self.buffer.len() + 2);
666                }
667                Ok(())
668            }
669            _ => {
670                self.buffer.reserve(3);
671                unsafe {
672                    let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
673                    *ptr = UINT16_MARKER;
674                    ptr.add(1)
675                        .copy_from_nonoverlapping(u.to_be_bytes().as_ptr(), 2);
676                    self.buffer.set_len(self.buffer.len() + 3);
677                }
678                Ok(())
679            }
680        }
681    }
682
683    #[inline(always)]
684    fn write_u32(&mut self, u: u32) -> Result<()> {
685        match u {
686            0..=127 => {
687                self.buffer.push(u as u8);
688                Ok(())
689            }
690            128..=255 => {
691                self.buffer.reserve(2);
692                unsafe {
693                    let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
694                    *ptr = UINT8_MARKER;
695                    *ptr.add(1) = u as u8;
696                    self.buffer.set_len(self.buffer.len() + 2);
697                }
698                Ok(())
699            }
700            256..=65535 => {
701                self.buffer.reserve(3);
702                unsafe {
703                    let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
704                    *ptr = UINT16_MARKER;
705                    ptr.add(1)
706                        .copy_from_nonoverlapping((u as u16).to_be_bytes().as_ptr(), 2);
707                    self.buffer.set_len(self.buffer.len() + 3);
708                }
709                Ok(())
710            }
711            _ => {
712                self.buffer.reserve(5);
713                unsafe {
714                    let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
715                    *ptr = UINT32_MARKER;
716                    ptr.add(1)
717                        .copy_from_nonoverlapping(u.to_be_bytes().as_ptr(), 4);
718                    self.buffer.set_len(self.buffer.len() + 5);
719                }
720                Ok(())
721            }
722        }
723    }
724
725    #[inline(always)]
726    fn write_u64(&mut self, u: u64) -> Result<()> {
727        match u {
728            0..=127 => {
729                self.buffer.push(u as u8);
730                Ok(())
731            }
732            128..=255 => {
733                self.buffer.reserve(2);
734                unsafe {
735                    let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
736                    *ptr = UINT8_MARKER;
737                    *ptr.add(1) = u as u8;
738                    self.buffer.set_len(self.buffer.len() + 2);
739                }
740                Ok(())
741            }
742            256..=65535 => {
743                self.buffer.reserve(3);
744                unsafe {
745                    let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
746                    *ptr = UINT16_MARKER;
747                    ptr.add(1)
748                        .copy_from_nonoverlapping((u as u16).to_be_bytes().as_ptr(), 2);
749                    self.buffer.set_len(self.buffer.len() + 3);
750                }
751                Ok(())
752            }
753            65536..=4294967295 => {
754                self.buffer.reserve(5);
755                unsafe {
756                    let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
757                    *ptr = UINT32_MARKER;
758                    ptr.add(1)
759                        .copy_from_nonoverlapping((u as u32).to_be_bytes().as_ptr(), 4);
760                    self.buffer.set_len(self.buffer.len() + 5);
761                }
762                Ok(())
763            }
764            _ => {
765                self.buffer.reserve(9);
766                unsafe {
767                    let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
768                    *ptr = UINT64_MARKER;
769                    ptr.add(1)
770                        .copy_from_nonoverlapping(u.to_be_bytes().as_ptr(), 8);
771                    self.buffer.set_len(self.buffer.len() + 9);
772                }
773                Ok(())
774            }
775        }
776    }
777
778    #[inline(always)]
779    fn write_i8(&mut self, i: i8) -> Result<()> {
780        match i {
781            0..=127 => {
782                self.buffer.push(i as u8);
783                Ok(())
784            }
785            -32..=-1 => {
786                self.buffer.push(0xe0 | ((i + 32) as u8));
787                Ok(())
788            }
789            _ => {
790                self.buffer.reserve(2);
791                unsafe {
792                    let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
793                    *ptr = INT8_MARKER;
794                    *ptr.add(1) = i as u8;
795                    self.buffer.set_len(self.buffer.len() + 2);
796                }
797                Ok(())
798            }
799        }
800    }
801
802    #[inline(always)]
803    fn write_i16(&mut self, i: i16) -> Result<()> {
804        match i {
805            0..=127 => {
806                self.buffer.push(i as u8);
807                Ok(())
808            }
809            -32..=-1 => {
810                self.buffer.push(0xe0 | ((i + 32) as u8));
811                Ok(())
812            }
813            -128..=127 => {
814                self.buffer.reserve(2);
815                unsafe {
816                    let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
817                    *ptr = INT8_MARKER;
818                    *ptr.add(1) = i as u8;
819                    self.buffer.set_len(self.buffer.len() + 2);
820                }
821                Ok(())
822            }
823            _ => {
824                self.buffer.reserve(3);
825                unsafe {
826                    let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
827                    *ptr = INT16_MARKER;
828                    ptr.add(1)
829                        .copy_from_nonoverlapping((i as i16).to_be_bytes().as_ptr(), 2);
830                    self.buffer.set_len(self.buffer.len() + 3);
831                }
832                Ok(())
833            }
834        }
835    }
836
837    #[inline(always)]
838    fn write_i32(&mut self, i: i32) -> Result<()> {
839        match i {
840            0..=127 => {
841                self.buffer.push(i as u8);
842                Ok(())
843            }
844            -32..=-1 => {
845                self.buffer.push(0xe0 | ((i + 32) as u8));
846                Ok(())
847            }
848            -128..=127 => {
849                self.buffer.reserve(2);
850                unsafe {
851                    let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
852                    *ptr = INT8_MARKER;
853                    *ptr.add(1) = i as u8;
854                    self.buffer.set_len(self.buffer.len() + 2);
855                }
856                Ok(())
857            }
858            -32768..=32767 => {
859                self.buffer.reserve(3);
860                unsafe {
861                    let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
862                    *ptr = INT16_MARKER;
863                    ptr.add(1)
864                        .copy_from_nonoverlapping((i as i16).to_be_bytes().as_ptr(), 2);
865                    self.buffer.set_len(self.buffer.len() + 3);
866                }
867                Ok(())
868            }
869            _ => {
870                self.buffer.reserve(5);
871                unsafe {
872                    let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
873                    *ptr = INT32_MARKER;
874                    ptr.add(1)
875                        .copy_from_nonoverlapping((i as i32).to_be_bytes().as_ptr(), 4);
876                    self.buffer.set_len(self.buffer.len() + 5);
877                }
878                Ok(())
879            }
880        }
881    }
882
883    #[inline(always)]
884    fn write_i64(&mut self, i: i64) -> Result<()> {
885        match i {
886            0..=127 => {
887                self.buffer.push(i as u8);
888                Ok(())
889            }
890            -32..=-1 => {
891                self.buffer.push(0xe0 | ((i + 32) as u8));
892                Ok(())
893            }
894            -128..=127 => {
895                self.buffer.reserve(2);
896                unsafe {
897                    let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
898                    *ptr = INT8_MARKER;
899                    *ptr.add(1) = i as u8;
900                    self.buffer.set_len(self.buffer.len() + 2);
901                }
902                Ok(())
903            }
904            -32768..=32767 => {
905                self.buffer.reserve(3);
906                unsafe {
907                    let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
908                    *ptr = INT16_MARKER;
909                    ptr.add(1)
910                        .copy_from_nonoverlapping((i as i16).to_be_bytes().as_ptr(), 2);
911                    self.buffer.set_len(self.buffer.len() + 3);
912                }
913                Ok(())
914            }
915            -2147483648..=2147483647 => {
916                self.buffer.reserve(5);
917                unsafe {
918                    let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
919                    *ptr = INT32_MARKER;
920                    ptr.add(1)
921                        .copy_from_nonoverlapping((i as i32).to_be_bytes().as_ptr(), 4);
922                    self.buffer.set_len(self.buffer.len() + 5);
923                }
924                Ok(())
925            }
926            _ => {
927                self.buffer.reserve(9);
928                unsafe {
929                    let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
930                    *ptr = INT64_MARKER;
931                    ptr.add(1)
932                        .copy_from_nonoverlapping(i.to_be_bytes().as_ptr(), 8);
933                    self.buffer.set_len(self.buffer.len() + 9);
934                }
935                Ok(())
936            }
937        }
938    }
939
940    #[inline(always)]
941    fn write_f32(&mut self, f: f32) -> Result<()> {
942        self.buffer.reserve(5);
943        unsafe {
944            let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
945            *ptr = FLOAT32_MARKER;
946            ptr.add(1)
947                .copy_from_nonoverlapping(f.to_be_bytes().as_ptr(), 4);
948            self.buffer.set_len(self.buffer.len() + 5);
949        }
950        Ok(())
951    }
952
953    #[inline(always)]
954    fn write_f64(&mut self, f: f64) -> Result<()> {
955        self.buffer.reserve(9);
956        unsafe {
957            let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
958            *ptr = FLOAT64_MARKER;
959            ptr.add(1)
960                .copy_from_nonoverlapping(f.to_be_bytes().as_ptr(), 8);
961            self.buffer.set_len(self.buffer.len() + 9);
962        }
963        Ok(())
964    }
965
966    #[inline(always)]
967    fn write_string(&mut self, s: &str) -> Result<()> {
968        let len = s.len();
969        match len {
970            0..=31 => {
971                self.buffer.reserve(1 + len);
972                unsafe {
973                    let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
974                    *ptr = 0xa0 | (len as u8);
975                    ptr.add(1)
976                        .copy_from_nonoverlapping(s.as_bytes().as_ptr(), len);
977                    self.buffer.set_len(self.buffer.len() + 1 + len);
978                }
979                Ok(())
980            }
981            32..=255 => {
982                self.buffer.reserve(2 + len);
983                unsafe {
984                    let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
985                    *ptr = STR8_MARKER;
986                    *ptr.add(1) = len as u8;
987                    ptr.add(2)
988                        .copy_from_nonoverlapping(s.as_bytes().as_ptr(), len);
989                    self.buffer.set_len(self.buffer.len() + 2 + len);
990                }
991                Ok(())
992            }
993            256..=65535 => {
994                self.buffer.reserve(3 + len);
995                unsafe {
996                    let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
997                    *ptr = STR16_MARKER;
998                    let len_bytes = (len as u16).to_be_bytes();
999                    ptr.add(1).copy_from_nonoverlapping(len_bytes.as_ptr(), 2);
1000                    ptr.add(3)
1001                        .copy_from_nonoverlapping(s.as_bytes().as_ptr(), len);
1002                    self.buffer.set_len(self.buffer.len() + 3 + len);
1003                }
1004                Ok(())
1005            }
1006            _ => {
1007                self.buffer.reserve(5 + len);
1008                unsafe {
1009                    let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
1010                    *ptr = STR32_MARKER;
1011                    let len_bytes = (len as u32).to_be_bytes();
1012                    ptr.add(1).copy_from_nonoverlapping(len_bytes.as_ptr(), 4);
1013                    ptr.add(5)
1014                        .copy_from_nonoverlapping(s.as_bytes().as_ptr(), len);
1015                    self.buffer.set_len(self.buffer.len() + 5 + len);
1016                }
1017                Ok(())
1018            }
1019        }
1020    }
1021
1022    #[inline(always)]
1023    fn write_binary(&mut self, data: &[u8]) -> Result<()> {
1024        let len = data.len();
1025        match len {
1026            0..=255 => {
1027                self.buffer.reserve(2 + len);
1028                unsafe {
1029                    let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
1030                    *ptr = BIN8_MARKER;
1031                    *ptr.add(1) = len as u8;
1032                    ptr.add(2).copy_from_nonoverlapping(data.as_ptr(), len);
1033                    self.buffer.set_len(self.buffer.len() + 2 + len);
1034                }
1035                Ok(())
1036            }
1037            256..=65535 => {
1038                self.buffer.reserve(3 + len);
1039                unsafe {
1040                    let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
1041                    *ptr = BIN16_MARKER;
1042                    let len_bytes = (len as u16).to_be_bytes();
1043                    ptr.add(1).copy_from_nonoverlapping(len_bytes.as_ptr(), 2);
1044                    ptr.add(3).copy_from_nonoverlapping(data.as_ptr(), len);
1045                    self.buffer.set_len(self.buffer.len() + 3 + len);
1046                }
1047                Ok(())
1048            }
1049            _ => {
1050                self.buffer.reserve(5 + len);
1051                unsafe {
1052                    let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
1053                    *ptr = BIN32_MARKER;
1054                    let len_bytes = (len as u32).to_be_bytes();
1055                    ptr.add(1).copy_from_nonoverlapping(len_bytes.as_ptr(), 4);
1056                    ptr.add(5).copy_from_nonoverlapping(data.as_ptr(), len);
1057                    self.buffer.set_len(self.buffer.len() + 5 + len);
1058                }
1059                Ok(())
1060            }
1061        }
1062    }
1063
1064    #[inline(always)]
1065    fn write_timestamp(&mut self, seconds: i64, nanoseconds: u32) -> Result<()> {
1066        if nanoseconds >= 1_000_000_000 {
1067            return Err(Error::InvalidTimestamp);
1068        }
1069
1070        // timestamp 32: sec in [0, 2^32-1], nsec == 0
1071        if nanoseconds == 0 && (0..=u32::MAX as i64).contains(&seconds) {
1072            self.buffer.reserve(6);
1073            unsafe {
1074                let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
1075                *ptr = TIMESTAMP32_MARKER;
1076                *ptr.add(1) = 0xff;
1077                ptr.add(2)
1078                    .copy_from_nonoverlapping((seconds as u32).to_be_bytes().as_ptr(), 4);
1079                self.buffer.set_len(self.buffer.len() + 6);
1080            }
1081            return Ok(());
1082        }
1083
1084        // timestamp 64: sec in [0, 2^34-1]
1085        if (0..=(1i64 << 34) - 1).contains(&seconds) {
1086            let data = ((nanoseconds as u64) << 34) | (seconds as u64);
1087            self.buffer.reserve(10);
1088            unsafe {
1089                let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
1090                *ptr = TIMESTAMP64_MARKER;
1091                *ptr.add(1) = 0xff;
1092                ptr.add(2)
1093                    .copy_from_nonoverlapping(data.to_be_bytes().as_ptr(), 8);
1094                self.buffer.set_len(self.buffer.len() + 10);
1095            }
1096            return Ok(());
1097        }
1098
1099        // timestamp 96
1100        self.buffer.reserve(15);
1101        unsafe {
1102            let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
1103            *ptr = TIMESTAMP96_MARKER;
1104            *ptr.add(1) = 12;
1105            *ptr.add(2) = 0xff;
1106            ptr.add(3)
1107                .copy_from_nonoverlapping(nanoseconds.to_be_bytes().as_ptr(), 4);
1108            ptr.add(7)
1109                .copy_from_nonoverlapping((seconds as i64).to_be_bytes().as_ptr(), 8);
1110            self.buffer.set_len(self.buffer.len() + 15);
1111        }
1112        Ok(())
1113    }
1114
1115    #[inline(always)]
1116    fn write_array_len(&mut self, len: usize) -> Result<()> {
1117        match len {
1118            0..=15 => {
1119                self.buffer.push(FIXARRAY_START | (len as u8));
1120                Ok(())
1121            }
1122            16..=65535 => {
1123                self.buffer.reserve(3);
1124                unsafe {
1125                    let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
1126                    *ptr = ARRAY16_MARKER;
1127                    ptr.add(1)
1128                        .copy_from_nonoverlapping((len as u16).to_be_bytes().as_ptr(), 2);
1129                    self.buffer.set_len(self.buffer.len() + 3);
1130                }
1131                Ok(())
1132            }
1133            _ => {
1134                self.buffer.reserve(5);
1135                unsafe {
1136                    let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
1137                    *ptr = ARRAY32_MARKER;
1138                    ptr.add(1)
1139                        .copy_from_nonoverlapping((len as u32).to_be_bytes().as_ptr(), 4);
1140                    self.buffer.set_len(self.buffer.len() + 5);
1141                }
1142                Ok(())
1143            }
1144        }
1145    }
1146
1147    #[inline(always)]
1148    fn write_map_len(&mut self, len: usize) -> Result<()> {
1149        match len {
1150            0..=15 => {
1151                self.buffer.push(FIXMAP_START | (len as u8));
1152                Ok(())
1153            }
1154            16..=65535 => {
1155                self.buffer.reserve(3);
1156                unsafe {
1157                    let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
1158                    *ptr = MAP16_MARKER;
1159                    ptr.add(1)
1160                        .copy_from_nonoverlapping((len as u16).to_be_bytes().as_ptr(), 2);
1161                    self.buffer.set_len(self.buffer.len() + 3);
1162                }
1163                Ok(())
1164            }
1165            _ => {
1166                self.buffer.reserve(5);
1167                unsafe {
1168                    let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
1169                    *ptr = MAP32_MARKER;
1170                    ptr.add(1)
1171                        .copy_from_nonoverlapping((len as u32).to_be_bytes().as_ptr(), 4);
1172                    self.buffer.set_len(self.buffer.len() + 5);
1173                }
1174                Ok(())
1175            }
1176        }
1177    }
1178
1179    #[inline(always)]
1180    fn write_ext(&mut self, type_id: i8, data: &[u8]) -> Result<()> {
1181        let len = data.len();
1182        match len {
1183            1 => {
1184                self.buffer.reserve(3);
1185                unsafe {
1186                    let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
1187                    *ptr = FIXEXT1_MARKER;
1188                    *ptr.add(1) = type_id as u8;
1189                    *ptr.add(2) = data[0];
1190                    self.buffer.set_len(self.buffer.len() + 3);
1191                }
1192                Ok(())
1193            }
1194            2 => {
1195                self.buffer.reserve(4);
1196                unsafe {
1197                    let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
1198                    *ptr = FIXEXT2_MARKER;
1199                    *ptr.add(1) = type_id as u8;
1200                    ptr.add(2).copy_from_nonoverlapping(data.as_ptr(), 2);
1201                    self.buffer.set_len(self.buffer.len() + 4);
1202                }
1203                Ok(())
1204            }
1205            4 => {
1206                self.buffer.reserve(6);
1207                unsafe {
1208                    let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
1209                    *ptr = FIXEXT4_MARKER;
1210                    *ptr.add(1) = type_id as u8;
1211                    ptr.add(2).copy_from_nonoverlapping(data.as_ptr(), 4);
1212                    self.buffer.set_len(self.buffer.len() + 6);
1213                }
1214                Ok(())
1215            }
1216            8 => {
1217                self.buffer.reserve(10);
1218                unsafe {
1219                    let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
1220                    *ptr = FIXEXT8_MARKER;
1221                    *ptr.add(1) = type_id as u8;
1222                    ptr.add(2).copy_from_nonoverlapping(data.as_ptr(), 8);
1223                    self.buffer.set_len(self.buffer.len() + 10);
1224                }
1225                Ok(())
1226            }
1227            16 => {
1228                self.buffer.reserve(18);
1229                unsafe {
1230                    let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
1231                    *ptr = FIXEXT16_MARKER;
1232                    *ptr.add(1) = type_id as u8;
1233                    ptr.add(2).copy_from_nonoverlapping(data.as_ptr(), 16);
1234                    self.buffer.set_len(self.buffer.len() + 18);
1235                }
1236                Ok(())
1237            }
1238            0..=255 => {
1239                self.buffer.reserve(2 + len);
1240                unsafe {
1241                    let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
1242                    *ptr = EXT8_MARKER;
1243                    *ptr.add(1) = len as u8;
1244                    ptr.add(2).copy_from_nonoverlapping(data.as_ptr(), len);
1245                    self.buffer.set_len(self.buffer.len() + 2 + len);
1246                }
1247                Ok(())
1248            }
1249            256..=65535 => {
1250                self.buffer.reserve(3 + len);
1251                unsafe {
1252                    let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
1253                    *ptr = EXT16_MARKER;
1254                    let len_bytes = (len as u16).to_be_bytes();
1255                    ptr.add(1).copy_from_nonoverlapping(len_bytes.as_ptr(), 2);
1256                    ptr.add(3).copy_from_nonoverlapping(data.as_ptr(), len);
1257                    self.buffer.set_len(self.buffer.len() + 3 + len);
1258                }
1259                Ok(())
1260            }
1261            _ => {
1262                self.buffer.reserve(5 + len);
1263                unsafe {
1264                    let ptr = self.buffer.as_mut_ptr().add(self.buffer.len());
1265                    *ptr = EXT32_MARKER;
1266                    let len_bytes = (len as u32).to_be_bytes();
1267                    ptr.add(1).copy_from_nonoverlapping(len_bytes.as_ptr(), 4);
1268                    ptr.add(5).copy_from_nonoverlapping(data.as_ptr(), len);
1269                    self.buffer.set_len(self.buffer.len() + 5 + len);
1270                }
1271                Ok(())
1272            }
1273        }
1274    }
1275}
1276
1277#[cfg(feature = "std")]
1278pub struct IOWriter<W: std::io::Write> {
1279    writer: W,
1280}
1281
1282#[cfg(feature = "std")]
1283impl<W: std::io::Write> IOWriter<W> {
1284    pub fn new(writer: W) -> Self {
1285        IOWriter { writer }
1286    }
1287
1288    #[inline(always)]
1289    fn write_all(&mut self, data: &[u8]) -> Result<()> {
1290        self.writer.write_all(data).map_err(|e| Error::IoError(e))
1291    }
1292}
1293
1294#[cfg(feature = "std")]
1295impl<W: std::io::Write> Write for IOWriter<W> {
1296    #[inline(always)]
1297    fn write_nil(&mut self) -> Result<()> {
1298        self.write_all(&[NIL_MARKER])?;
1299        Ok(())
1300    }
1301
1302    #[inline(always)]
1303    fn write_boolean(&mut self, b: bool) -> Result<()> {
1304        self.write_all(&[if b { TRUE_MARKER } else { FALSE_MARKER }])?;
1305        Ok(())
1306    }
1307
1308    #[inline(always)]
1309    fn write_u8(&mut self, u: u8) -> Result<()> {
1310        if u <= 127 {
1311            self.write_all(&[u])?;
1312        } else {
1313            self.write_all(&[UINT8_MARKER, u])?;
1314        }
1315        Ok(())
1316    }
1317
1318    #[inline(always)]
1319    fn write_u16(&mut self, u: u16) -> Result<()> {
1320        match u {
1321            0..=127 => {
1322                self.write_all(&[u as u8])?;
1323                Ok(())
1324            }
1325            128..=255 => {
1326                self.write_all(&[UINT8_MARKER, u as u8])?;
1327                Ok(())
1328            }
1329            _ => {
1330                let len_bytes = (u as u16).to_be_bytes();
1331                self.write_all(&[UINT16_MARKER, len_bytes[0], len_bytes[1]])?;
1332                Ok(())
1333            }
1334        }
1335    }
1336
1337    #[inline(always)]
1338    fn write_u32(&mut self, u: u32) -> Result<()> {
1339        match u {
1340            0..=127 => {
1341                self.write_all(&[u as u8])?;
1342                Ok(())
1343            }
1344            128..=255 => {
1345                self.write_all(&[UINT8_MARKER, u as u8])?;
1346                Ok(())
1347            }
1348            256..=65535 => {
1349                let len_bytes = (u as u16).to_be_bytes();
1350                self.write_all(&[UINT16_MARKER, len_bytes[0], len_bytes[1]])?;
1351                Ok(())
1352            }
1353            _ => {
1354                let len_bytes = u.to_be_bytes();
1355                self.write_all(&[
1356                    UINT32_MARKER,
1357                    len_bytes[0],
1358                    len_bytes[1],
1359                    len_bytes[2],
1360                    len_bytes[3],
1361                ])?;
1362                Ok(())
1363            }
1364        }
1365    }
1366
1367    #[inline(always)]
1368    fn write_u64(&mut self, u: u64) -> Result<()> {
1369        match u {
1370            0..=127 => {
1371                self.write_all(&[u as u8])?;
1372                Ok(())
1373            }
1374            128..=255 => {
1375                self.write_all(&[UINT8_MARKER, u as u8])?;
1376                Ok(())
1377            }
1378            256..=65535 => {
1379                let len_bytes = (u as u16).to_be_bytes();
1380                self.write_all(&[UINT16_MARKER, len_bytes[0], len_bytes[1]])?;
1381                Ok(())
1382            }
1383            65536..=4294967295 => {
1384                let len_bytes = (u as u32).to_be_bytes();
1385                self.write_all(&[
1386                    UINT32_MARKER,
1387                    len_bytes[0],
1388                    len_bytes[1],
1389                    len_bytes[2],
1390                    len_bytes[3],
1391                ])?;
1392                Ok(())
1393            }
1394            _ => {
1395                let len_bytes = u.to_be_bytes();
1396                self.write_all(&[
1397                    UINT64_MARKER,
1398                    len_bytes[0],
1399                    len_bytes[1],
1400                    len_bytes[2],
1401                    len_bytes[3],
1402                    len_bytes[4],
1403                    len_bytes[5],
1404                    len_bytes[6],
1405                    len_bytes[7],
1406                ])?;
1407                Ok(())
1408            }
1409        }
1410    }
1411
1412    #[inline(always)]
1413    fn write_i8(&mut self, i: i8) -> Result<()> {
1414        match i {
1415            0..=127 => {
1416                self.write_all(&[i as u8])?;
1417                Ok(())
1418            }
1419            -32..=-1 => {
1420                self.write_all(&[0xe0 | ((i + 32) as u8)])?;
1421                Ok(())
1422            }
1423            _ => {
1424                self.write_all(&[INT8_MARKER, i as u8])?;
1425                Ok(())
1426            }
1427        }
1428    }
1429
1430    #[inline(always)]
1431    fn write_i16(&mut self, i: i16) -> Result<()> {
1432        match i {
1433            0..=127 => {
1434                self.write_all(&[i as u8])?;
1435                Ok(())
1436            }
1437            -32..=-1 => {
1438                self.write_all(&[0xe0 | ((i + 32) as u8)])?;
1439                Ok(())
1440            }
1441            -128..=127 => {
1442                self.write_all(&[INT8_MARKER, i as u8])?;
1443                Ok(())
1444            }
1445            _ => {
1446                let len_bytes = (i as i16).to_be_bytes();
1447                self.write_all(&[INT16_MARKER, len_bytes[0], len_bytes[1]])?;
1448                Ok(())
1449            }
1450        }
1451    }
1452
1453    #[inline(always)]
1454    fn write_i32(&mut self, i: i32) -> Result<()> {
1455        match i {
1456            0..=127 => {
1457                self.write_all(&[i as u8])?;
1458                Ok(())
1459            }
1460            -32..=-1 => {
1461                self.write_all(&[0xe0 | ((i + 32) as u8)])?;
1462                Ok(())
1463            }
1464            -128..=127 => {
1465                self.write_all(&[INT8_MARKER, i as u8])?;
1466                Ok(())
1467            }
1468            -32768..=32767 => {
1469                let len_bytes = (i as i16).to_be_bytes();
1470                self.write_all(&[INT16_MARKER, len_bytes[0], len_bytes[1]])?;
1471                Ok(())
1472            }
1473            _ => {
1474                let len_bytes = (i as i32).to_be_bytes();
1475                self.write_all(&[
1476                    INT32_MARKER,
1477                    len_bytes[0],
1478                    len_bytes[1],
1479                    len_bytes[2],
1480                    len_bytes[3],
1481                ])?;
1482                Ok(())
1483            }
1484        }
1485    }
1486
1487    #[inline(always)]
1488    fn write_i64(&mut self, i: i64) -> Result<()> {
1489        match i {
1490            0..=127 => {
1491                self.write_all(&[i as u8])?;
1492                Ok(())
1493            }
1494            -32..=-1 => {
1495                self.write_all(&[0xe0 | ((i + 32) as u8)])?;
1496                Ok(())
1497            }
1498            -128..=127 => {
1499                self.write_all(&[INT8_MARKER, i as u8])?;
1500                Ok(())
1501            }
1502            -32768..=32767 => {
1503                let len_bytes = (i as i16).to_be_bytes();
1504                self.write_all(&[INT16_MARKER, len_bytes[0], len_bytes[1]])?;
1505                Ok(())
1506            }
1507            -2147483648..=2147483647 => {
1508                let len_bytes = (i as i32).to_be_bytes();
1509                self.write_all(&[
1510                    INT32_MARKER,
1511                    len_bytes[0],
1512                    len_bytes[1],
1513                    len_bytes[2],
1514                    len_bytes[3],
1515                ])?;
1516                Ok(())
1517            }
1518            _ => {
1519                let len_bytes = (i as i64).to_be_bytes();
1520                self.write_all(&[
1521                    INT64_MARKER,
1522                    len_bytes[0],
1523                    len_bytes[1],
1524                    len_bytes[2],
1525                    len_bytes[3],
1526                    len_bytes[4],
1527                    len_bytes[5],
1528                    len_bytes[6],
1529                    len_bytes[7],
1530                ])?;
1531                Ok(())
1532            }
1533        }
1534    }
1535
1536    #[inline(always)]
1537    fn write_f32(&mut self, f: f32) -> Result<()> {
1538        let len_bytes = f.to_be_bytes();
1539        self.write_all(&[
1540            FLOAT32_MARKER,
1541            len_bytes[0],
1542            len_bytes[1],
1543            len_bytes[2],
1544            len_bytes[3],
1545        ])?;
1546        Ok(())
1547    }
1548
1549    #[inline(always)]
1550    fn write_f64(&mut self, f: f64) -> Result<()> {
1551        let len_bytes = f.to_be_bytes();
1552        self.write_all(&[
1553            FLOAT64_MARKER,
1554            len_bytes[0],
1555            len_bytes[1],
1556            len_bytes[2],
1557            len_bytes[3],
1558            len_bytes[4],
1559            len_bytes[5],
1560            len_bytes[6],
1561            len_bytes[7],
1562        ])?;
1563        Ok(())
1564    }
1565
1566    fn write_string(&mut self, s: &str) -> Result<()> {
1567        let len = s.len();
1568        match len {
1569            0..=31 => {
1570                self.write_all(&[0xa0 | (len as u8)])?;
1571                self.write_all(s.as_bytes())?;
1572                Ok(())
1573            }
1574            32..=255 => {
1575                self.write_all(&[STR8_MARKER, len as u8])?;
1576                self.write_all(s.as_bytes())?;
1577                Ok(())
1578            }
1579            256..=65535 => {
1580                let len_bytes = (len as u16).to_be_bytes();
1581                self.write_all(&[STR16_MARKER, len_bytes[0], len_bytes[1]])?;
1582                self.write_all(s.as_bytes())?;
1583                Ok(())
1584            }
1585            _ => {
1586                let len_bytes = (len as u32).to_be_bytes();
1587                self.write_all(&[
1588                    STR32_MARKER,
1589                    len_bytes[0],
1590                    len_bytes[1],
1591                    len_bytes[2],
1592                    len_bytes[3],
1593                ])?;
1594                self.write_all(s.as_bytes())?;
1595                Ok(())
1596            }
1597        }
1598    }
1599
1600    #[inline(always)]
1601    fn write_binary(&mut self, data: &[u8]) -> Result<()> {
1602        let len = data.len();
1603        match len {
1604            0..=31 => {
1605                self.write_all(&[0xb0 | (len as u8)])?;
1606                self.write_all(data)?;
1607                Ok(())
1608            }
1609            32..=255 => {
1610                self.write_all(&[BIN8_MARKER, len as u8])?;
1611                self.write_all(data)?;
1612                Ok(())
1613            }
1614            256..=65535 => {
1615                let len_bytes = (len as u16).to_be_bytes();
1616                self.write_all(&[BIN16_MARKER, len_bytes[0], len_bytes[1]])?;
1617                self.write_all(data)?;
1618                Ok(())
1619            }
1620            _ => {
1621                let len_bytes = (len as u32).to_be_bytes();
1622                self.write_all(&[
1623                    BIN32_MARKER,
1624                    len_bytes[0],
1625                    len_bytes[1],
1626                    len_bytes[2],
1627                    len_bytes[3],
1628                ])?;
1629                self.write_all(data)?;
1630                Ok(())
1631            }
1632        }
1633    }
1634
1635    #[inline(always)]
1636    fn write_timestamp(&mut self, seconds: i64, nanoseconds: u32) -> Result<()> {
1637        if nanoseconds >= 1_000_000_000 {
1638            return Err(Error::InvalidTimestamp);
1639        }
1640
1641        // timestamp 32: sec in [0, 2^32-1], nsec == 0
1642        if nanoseconds == 0 && (0..=u32::MAX as i64).contains(&seconds) {
1643            let sec_bytes = (seconds as u32).to_be_bytes();
1644            self.write_all(&[
1645                TIMESTAMP32_MARKER,
1646                0xff,
1647                sec_bytes[0],
1648                sec_bytes[1],
1649                sec_bytes[2],
1650                sec_bytes[3],
1651            ])?;
1652            return Ok(());
1653        }
1654
1655        // timestamp 64: sec in [0, 2^34-1]
1656        if (0..=(1i64 << 34) - 1).contains(&seconds) {
1657            let data = ((nanoseconds as u64) << 34) | (seconds as u64);
1658            let data_bytes = data.to_be_bytes();
1659            self.write_all(&[
1660                TIMESTAMP64_MARKER,
1661                0xff,
1662                data_bytes[0],
1663                data_bytes[1],
1664                data_bytes[2],
1665                data_bytes[3],
1666                data_bytes[4],
1667                data_bytes[5],
1668                data_bytes[6],
1669                data_bytes[7],
1670            ])?;
1671            return Ok(());
1672        }
1673
1674        // timestamp 96
1675        let sec_bytes = (seconds as i64).to_be_bytes();
1676        let nsec_bytes = nanoseconds.to_be_bytes();
1677        self.write_all(&[
1678            TIMESTAMP96_MARKER,
1679            12,
1680            0xff,
1681            nsec_bytes[0],
1682            nsec_bytes[1],
1683            nsec_bytes[2],
1684            nsec_bytes[3],
1685            sec_bytes[0],
1686            sec_bytes[1],
1687            sec_bytes[2],
1688            sec_bytes[3],
1689            sec_bytes[4],
1690            sec_bytes[5],
1691            sec_bytes[6],
1692            sec_bytes[7],
1693        ])?;
1694        Ok(())
1695    }
1696
1697    #[inline(always)]
1698    fn write_array_len(&mut self, len: usize) -> Result<()> {
1699        match len {
1700            0..=15 => {
1701                self.write_all(&[FIXARRAY_START | (len as u8)])?;
1702                Ok(())
1703            }
1704            16..=65535 => {
1705                let len_bytes = (len as u16).to_be_bytes();
1706                self.write_all(&[ARRAY16_MARKER, len_bytes[0], len_bytes[1]])?;
1707                Ok(())
1708            }
1709            _ => {
1710                let len_bytes = (len as u32).to_be_bytes();
1711                self.write_all(&[
1712                    ARRAY32_MARKER,
1713                    len_bytes[0],
1714                    len_bytes[1],
1715                    len_bytes[2],
1716                    len_bytes[3],
1717                ])?;
1718                Ok(())
1719            }
1720        }
1721    }
1722
1723    #[inline(always)]
1724    fn write_map_len(&mut self, len: usize) -> Result<()> {
1725        match len {
1726            0..=15 => {
1727                self.write_all(&[FIXMAP_START | (len as u8)])?;
1728                Ok(())
1729            }
1730            16..=65535 => {
1731                let len_bytes = (len as u16).to_be_bytes();
1732                self.write_all(&[MAP16_MARKER, len_bytes[0], len_bytes[1]])?;
1733                Ok(())
1734            }
1735            _ => {
1736                let len_bytes = (len as u32).to_be_bytes();
1737                self.write_all(&[
1738                    MAP32_MARKER,
1739                    len_bytes[0],
1740                    len_bytes[1],
1741                    len_bytes[2],
1742                    len_bytes[3],
1743                ])?;
1744                Ok(())
1745            }
1746        }
1747    }
1748
1749    #[inline(always)]
1750    fn write_ext(&mut self, type_id: i8, data: &[u8]) -> Result<()> {
1751        let len = data.len();
1752        match len {
1753            1 => {
1754                self.write_all(&[FIXEXT1_MARKER, type_id as u8, data[0]])?;
1755                Ok(())
1756            }
1757            2 => {
1758                self.write_all(&[FIXEXT2_MARKER, type_id as u8, data[0], data[1]])?;
1759                Ok(())
1760            }
1761            4 => {
1762                self.write_all(&[
1763                    FIXEXT4_MARKER,
1764                    type_id as u8,
1765                    data[0],
1766                    data[1],
1767                    data[2],
1768                    data[3],
1769                ])?;
1770                Ok(())
1771            }
1772            8 => {
1773                self.write_all(&[
1774                    FIXEXT8_MARKER,
1775                    type_id as u8,
1776                    data[0],
1777                    data[1],
1778                    data[2],
1779                    data[3],
1780                    data[4],
1781                    data[5],
1782                    data[6],
1783                    data[7],
1784                ])?;
1785                Ok(())
1786            }
1787            16 => {
1788                self.write_all(&[
1789                    FIXEXT16_MARKER,
1790                    type_id as u8,
1791                    data[0],
1792                    data[1],
1793                    data[2],
1794                    data[3],
1795                    data[4],
1796                    data[5],
1797                    data[6],
1798                    data[7],
1799                    data[8],
1800                    data[9],
1801                    data[10],
1802                    data[11],
1803                    data[12],
1804                    data[13],
1805                    data[14],
1806                    data[15],
1807                ])?;
1808                Ok(())
1809            }
1810            0..=255 => {
1811                self.write_all(&[EXT8_MARKER, len as u8, type_id as u8])?;
1812                self.write_all(data)?;
1813                Ok(())
1814            }
1815            256..=65535 => {
1816                let len_bytes = (len as u16).to_be_bytes();
1817                self.write_all(&[EXT16_MARKER, len_bytes[0], len_bytes[1]])?;
1818                self.write_all(data)?;
1819                Ok(())
1820            }
1821            _ => {
1822                let len_bytes = (len as u32).to_be_bytes();
1823                self.write_all(&[
1824                    EXT32_MARKER,
1825                    len_bytes[0],
1826                    len_bytes[1],
1827                    len_bytes[2],
1828                    len_bytes[3],
1829                ])?;
1830                self.write_all(data)?;
1831                Ok(())
1832            }
1833        }
1834    }
1835}
zerompk/write.rs

zerompk/
write.rs
