compact_encoding/
types.rs

1//! Basic types of compact_encoding.
2use std::convert::TryFrom;
3use std::fmt;
4use std::ops::Range;
5
6const U16_SIGNIFIER: u8 = 0xfd;
7const U32_SIGNIFIER: u8 = 0xfe;
8const U64_SIGNIFIER: u8 = 0xff;
9
10/// Specific type [EncodingError]
11#[derive(fmt::Debug)]
12pub enum EncodingErrorKind {
13    /// Encoding or decoding did not stay between [State] `start` and `end`.
14    OutOfBounds,
15    /// Buffer data overflowed type during encoding or decoding.
16    Overflow,
17    /// Buffer contained invalid data during decoding.
18    InvalidData,
19}
20
21/// Encoding/decoding error.
22#[derive(fmt::Debug)]
23pub struct EncodingError {
24    /// Specific type of error
25    pub kind: EncodingErrorKind,
26    /// Message for the error
27    pub message: String,
28}
29
30impl EncodingError {
31    /// Create EncodingError
32    pub fn new(kind: EncodingErrorKind, message: &str) -> Self {
33        Self {
34            kind,
35            message: message.to_string(),
36        }
37    }
38}
39
40impl fmt::Display for EncodingError {
41    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
42        let prefix = match self.kind {
43            EncodingErrorKind::OutOfBounds => "Compact encoding failed, out of bounds",
44            EncodingErrorKind::Overflow => "Compact encoding failed, overflow",
45            EncodingErrorKind::InvalidData => "Compact encoding failed, invalid data",
46        };
47        write!(f, "{}: {}", prefix, self.message)
48    }
49}
50
51impl From<EncodingError> for std::io::Error {
52    fn from(e: EncodingError) -> Self {
53        match e.kind {
54            EncodingErrorKind::InvalidData => {
55                std::io::Error::new(std::io::ErrorKind::InvalidData, format!("{e}"))
56            }
57            _ => std::io::Error::new(std::io::ErrorKind::Other, format!("{e}")),
58        }
59    }
60}
61
62/// State.
63#[derive(Debug, Clone)]
64pub struct State {
65    /// Start position
66    start: usize,
67    /// End position
68    end: usize,
69}
70
71impl Default for State {
72    /// Create empty state
73    fn default() -> Self {
74        Self::new()
75    }
76}
77
78impl State {
79    /// Create empty state
80    pub fn new() -> State {
81        State::new_with_start_and_end(0, 0)
82    }
83
84    /// Create a state and buffer with an already known size.
85    /// With this, you can/must skip the preencode step.
86    pub fn new_with_size(size: usize) -> (State, Box<[u8]>) {
87        (
88            State::new_with_start_and_end(0, size),
89            vec![0; size].into_boxed_slice(),
90        )
91    }
92
93    /// Create a state with a start and end already known.
94    pub fn new_with_start_and_end(start: usize, end: usize) -> State {
95        State { start, end }
96    }
97
98    /// Create a state from existing buffer.
99    pub fn from_buffer(buffer: &[u8]) -> State {
100        State::new_with_start_and_end(0, buffer.len())
101    }
102
103    /// Start value
104    pub fn start(&self) -> usize {
105        self.start
106    }
107
108    /// Set start value
109    pub fn set_start(&mut self, value: usize) -> Result<(), EncodingError> {
110        if value > self.end {
111            return Err(EncodingError::new(
112                EncodingErrorKind::OutOfBounds,
113                &format!("Value exceeded state.end: {} > {}", value, self.end),
114            ));
115        }
116        self.start = value;
117        Ok(())
118    }
119
120    /// End value
121    pub fn end(&self) -> usize {
122        self.end
123    }
124
125    /// Set end value
126    pub fn set_end(&mut self, value: usize) {
127        self.end = value;
128    }
129
130    /// Add to start handling overflow and out of bounds.
131    pub fn add_start(&mut self, increment: usize) -> Result<usize, EncodingError> {
132        self.start = self.start.checked_add(increment).ok_or_else(|| {
133            EncodingError::new(
134                EncodingErrorKind::Overflow,
135                &format!(
136                    "State.start overflowed: {} + {} > {}",
137                    self.start,
138                    increment,
139                    usize::MAX
140                ),
141            )
142        })?;
143        if self.start > self.end {
144            Err(EncodingError::new(
145                EncodingErrorKind::OutOfBounds,
146                &format!(
147                    "State.start exceeded state.end: {} > {}",
148                    self.start, self.end
149                ),
150            ))
151        } else {
152            Ok(self.start)
153        }
154    }
155
156    /// Add to end handling overflow
157    pub fn add_end(&mut self, increment: usize) -> Result<usize, EncodingError> {
158        self.end = self.end.checked_add(increment).ok_or_else(|| {
159            EncodingError::new(
160                EncodingErrorKind::Overflow,
161                &format!(
162                    "State.end overflowed: {} + {} > {}",
163                    self.end,
164                    increment,
165                    usize::MAX
166                ),
167            )
168        })?;
169        Ok(self.end)
170    }
171
172    /// After calling preencode(), this allocates the right size buffer to the heap.
173    /// Follow this with the same number of encode() steps to fill the created buffer.
174    pub fn create_buffer(&self) -> Box<[u8]> {
175        vec![0; self.end].into_boxed_slice()
176    }
177
178    /// Safely set single byte to buffer at state.start and then increment state.start, returning
179    /// new state.start.
180    pub fn set_byte_to_buffer(
181        &mut self,
182        value: u8,
183        buffer: &mut [u8],
184    ) -> Result<usize, EncodingError> {
185        if buffer.len() <= self.start {
186            Err(EncodingError::new(
187                EncodingErrorKind::OutOfBounds,
188                &format!(
189                    "Length of buffer {} too small to fit single byte",
190                    buffer.len()
191                ),
192            ))
193        } else {
194            buffer[self.start] = value;
195            self.add_start(1)
196        }
197    }
198
199    /// Safely set byte slice to buffer at state.start and then increment state.start with slice
200    /// length, returning new state.start.
201    pub fn set_slice_to_buffer(
202        &mut self,
203        value: &[u8],
204        buffer: &mut [u8],
205    ) -> Result<usize, EncodingError> {
206        self.set_slice_to_buffer_fixed(value, buffer, value.len())
207    }
208
209    /// Safely set byte slice of fixed len to buffer at state.start and then increment state.start with slice
210    /// length, returning new state.start.
211    pub fn set_slice_to_buffer_fixed(
212        &mut self,
213        value: &[u8],
214        buffer: &mut [u8],
215        size: usize,
216    ) -> Result<usize, EncodingError> {
217        if value.len() < size {
218            return Err(EncodingError::new(
219                EncodingErrorKind::OutOfBounds,
220                &format!(
221                    "Length of value {} too small to fit fixed size {}",
222                    value.len(),
223                    size
224                ),
225            ));
226        }
227        let value_end = size.checked_add(self.start).ok_or_else(|| {
228            EncodingError::new(
229                EncodingErrorKind::Overflow,
230                &format!(
231                    "Value end overflowed: {} + {} > {}",
232                    size,
233                    self.start,
234                    usize::MAX
235                ),
236            )
237        })?;
238        if buffer.len() < value_end {
239            Err(EncodingError::new(
240                EncodingErrorKind::OutOfBounds,
241                &format!(
242                    "Length of buffer {} too small to fit slice of length {}",
243                    buffer.len(),
244                    size
245                ),
246            ))
247        } else {
248            buffer[self.start..value_end].copy_from_slice(value);
249            self.add_start(size)
250        }
251    }
252
253    /// Validate `size` can be decoded from `buffer`, return current start.
254    pub fn validate(&mut self, size: usize, buffer: &[u8]) -> Result<Range<usize>, EncodingError> {
255        let value_end = size.checked_add(self.start).ok_or_else(|| {
256            EncodingError::new(
257                EncodingErrorKind::Overflow,
258                &format!(
259                    "Value end overflowed during validate: {} + {} > {}",
260                    size,
261                    self.start,
262                    usize::MAX
263                ),
264            )
265        })?;
266
267        if buffer.len() < value_end {
268            Err(EncodingError::new(
269                EncodingErrorKind::Overflow,
270                &format!("Buffer length {} too small for size {}", buffer.len(), size,),
271            ))
272        } else {
273            Ok(self.start..value_end)
274        }
275    }
276
277    /// Preencode a string slice
278    pub fn preencode_str(&mut self, value: &str) -> Result<usize, EncodingError> {
279        self.preencode_usize_var(&value.len())?;
280        self.add_end(value.len())
281    }
282
283    /// Encode a string slice
284    pub fn encode_str(&mut self, value: &str, buffer: &mut [u8]) -> Result<usize, EncodingError> {
285        let len = value.len();
286        self.encode_usize_var(&len, buffer)?;
287        self.set_slice_to_buffer(value.as_bytes(), buffer)
288    }
289
290    /// Decode a String
291    pub fn decode_string(&mut self, buffer: &[u8]) -> Result<String, EncodingError> {
292        let len = self.decode_usize_var(buffer)?;
293        let range = self.validate(len, buffer)?;
294        let value = std::str::from_utf8(&buffer[range]).map_err(|err| {
295            EncodingError::new(
296                EncodingErrorKind::InvalidData,
297                &format!("String is invalid UTF-8, {err}"),
298            )
299        })?;
300        self.add_start(len)?;
301        Ok(value.to_string())
302    }
303
304    /// Preencode a variable length usigned int
305    pub fn preencode_uint_var<T: From<u32> + Ord>(
306        &mut self,
307        uint: &T,
308    ) -> Result<usize, EncodingError> {
309        let increment: usize = if *uint < T::from(U16_SIGNIFIER.into()) {
310            1
311        } else if *uint <= T::from(0xffff) {
312            3
313        } else if *uint <= T::from(0xffffffff) {
314            5
315        } else {
316            9
317        };
318        self.add_end(increment)
319    }
320
321    /// Decode a fixed length u8
322    pub fn decode_u8(&mut self, buffer: &[u8]) -> Result<u8, EncodingError> {
323        self.validate(1, buffer)?;
324        let value: u8 = buffer[self.start];
325        self.add_start(1)?;
326        Ok(value)
327    }
328
329    /// Decode a fixed length u16
330    pub fn decode_u16(&mut self, buffer: &[u8]) -> Result<u16, EncodingError> {
331        self.validate(2, buffer)?;
332        let value: u16 = (buffer[self.start] as u16) | ((buffer[self.start + 1] as u16) << 8);
333        self.add_start(2)?;
334        Ok(value)
335    }
336
337    /// Encode a variable length u32
338    pub fn encode_u32_var(
339        &mut self,
340        value: &u32,
341        buffer: &mut [u8],
342    ) -> Result<usize, EncodingError> {
343        if *value < U16_SIGNIFIER.into() {
344            let bytes = value.to_le_bytes();
345            self.set_byte_to_buffer(bytes[0], buffer)
346        } else if *value <= 0xffff {
347            self.set_byte_to_buffer(U16_SIGNIFIER, buffer)?;
348            self.encode_uint16_bytes(&value.to_le_bytes(), buffer)
349        } else {
350            self.set_byte_to_buffer(U32_SIGNIFIER, buffer)?;
351            self.encode_uint32_bytes(&value.to_le_bytes(), buffer)
352        }
353    }
354
355    /// Encode u32 to 4 LE bytes.
356    pub fn encode_u32(&mut self, uint: u32, buffer: &mut [u8]) -> Result<usize, EncodingError> {
357        self.encode_uint32_bytes(&uint.to_le_bytes(), buffer)
358    }
359
360    /// Decode a variable length u32
361    #[allow(clippy::comparison_chain)]
362    pub fn decode_u32_var(&mut self, buffer: &[u8]) -> Result<u32, EncodingError> {
363        self.validate(1, buffer)?;
364        let first = buffer[self.start];
365        self.add_start(1)?;
366        if first < U16_SIGNIFIER {
367            Ok(first.into())
368        } else if first == U16_SIGNIFIER {
369            Ok(self.decode_u16(buffer)?.into())
370        } else {
371            self.decode_u32(buffer)
372        }
373    }
374
375    /// Decode a fixed length u32
376    pub fn decode_u32(&mut self, buffer: &[u8]) -> Result<u32, EncodingError> {
377        self.validate(4, buffer)?;
378        let value: u32 = (buffer[self.start] as u32)
379            | ((buffer[self.start + 1] as u32) << 8)
380            | ((buffer[self.start + 2] as u32) << 16)
381            | ((buffer[self.start + 3] as u32) << 24);
382        self.add_start(4)?;
383        Ok(value)
384    }
385
386    /// Encode a variable length u64
387    pub fn encode_u64_var(
388        &mut self,
389        value: &u64,
390        buffer: &mut [u8],
391    ) -> Result<usize, EncodingError> {
392        if *value < U16_SIGNIFIER.into() {
393            let bytes = value.to_le_bytes();
394            self.set_byte_to_buffer(bytes[0], buffer)
395        } else if *value <= 0xffff {
396            self.set_byte_to_buffer(U16_SIGNIFIER, buffer)?;
397            self.encode_uint16_bytes(&value.to_le_bytes(), buffer)
398        } else if *value <= 0xffffffff {
399            self.set_byte_to_buffer(U32_SIGNIFIER, buffer)?;
400            self.encode_uint32_bytes(&value.to_le_bytes(), buffer)
401        } else {
402            self.set_byte_to_buffer(U64_SIGNIFIER, buffer)?;
403            self.encode_uint64_bytes(&value.to_le_bytes(), buffer)
404        }
405    }
406
407    /// Encode u64 to 8 LE bytes.
408    pub fn encode_u64(&mut self, uint: u64, buffer: &mut [u8]) -> Result<usize, EncodingError> {
409        self.encode_uint64_bytes(&uint.to_le_bytes(), buffer)
410    }
411
412    /// Decode a variable length u64
413    pub fn decode_u64_var(&mut self, buffer: &[u8]) -> Result<u64, EncodingError> {
414        self.validate(1, buffer)?;
415        let first = buffer[self.start];
416        self.add_start(1)?;
417        if first < U16_SIGNIFIER {
418            Ok(first.into())
419        } else if first == U16_SIGNIFIER {
420            Ok(self.decode_u16(buffer)?.into())
421        } else if first == U32_SIGNIFIER {
422            Ok(self.decode_u32(buffer)?.into())
423        } else {
424            self.decode_u64(buffer)
425        }
426    }
427
428    /// Decode a fixed length u64
429    pub fn decode_u64(&mut self, buffer: &[u8]) -> Result<u64, EncodingError> {
430        self.validate(8, buffer)?;
431        let value: u64 = (buffer[self.start] as u64)
432            | ((buffer[self.start + 1] as u64) << 8)
433            | ((buffer[self.start + 2] as u64) << 16)
434            | ((buffer[self.start + 3] as u64) << 24)
435            | ((buffer[self.start + 4] as u64) << 32)
436            | ((buffer[self.start + 5] as u64) << 40)
437            | ((buffer[self.start + 6] as u64) << 48)
438            | ((buffer[self.start + 7] as u64) << 56);
439        self.add_start(8)?;
440        Ok(value)
441    }
442
443    /// Preencode a byte buffer
444    pub fn preencode_buffer(&mut self, value: &[u8]) -> Result<usize, EncodingError> {
445        let len = value.len();
446        self.preencode_usize_var(&len)?;
447        self.add_end(len)
448    }
449
450    /// Preencode a vector byte buffer
451    pub fn preencode_buffer_vec(&mut self, value: &Vec<u8>) -> Result<usize, EncodingError> {
452        let len = value.len();
453        self.preencode_usize_var(&len)?;
454        self.add_end(len)
455    }
456
457    /// Encode a byte buffer
458    pub fn encode_buffer(
459        &mut self,
460        value: &[u8],
461        buffer: &mut [u8],
462    ) -> Result<usize, EncodingError> {
463        let len = value.len();
464        self.encode_usize_var(&len, buffer)?;
465        self.set_slice_to_buffer(value, buffer)
466    }
467
468    /// Decode a byte buffer
469    pub fn decode_buffer(&mut self, buffer: &[u8]) -> Result<Box<[u8]>, EncodingError> {
470        Ok(self.decode_buffer_vec(buffer)?.into_boxed_slice())
471    }
472
473    /// Decode a vector byte buffer
474    pub fn decode_buffer_vec(&mut self, buffer: &[u8]) -> Result<Vec<u8>, EncodingError> {
475        let len = self.decode_usize_var(buffer)?;
476        let range = self.validate(len, buffer)?;
477        let value = buffer[range].to_vec();
478        self.add_start(value.len())?;
479        Ok(value)
480    }
481
482    /// Preencode a raw byte buffer. Only possible to use if this is the last value
483    /// of the State.
484    pub fn preencode_raw_buffer(&mut self, value: &Vec<u8>) -> Result<usize, EncodingError> {
485        self.add_end(value.len())
486    }
487
488    /// Encode a raw byte buffer. Only possible to use if this is the last value
489    /// of the State.
490    pub fn encode_raw_buffer(
491        &mut self,
492        value: &[u8],
493        buffer: &mut [u8],
494    ) -> Result<usize, EncodingError> {
495        self.set_slice_to_buffer(value, buffer)
496    }
497
498    /// Decode a raw byte buffer. Only possible to use if this is the last value
499    /// of the State.
500    pub fn decode_raw_buffer(&mut self, buffer: &[u8]) -> Result<Vec<u8>, EncodingError> {
501        if self.start >= self.end {
502            return Err(EncodingError::new(
503                EncodingErrorKind::OutOfBounds,
504                &format!("State.start {} >= state.end {}", self.start, self.end),
505            ));
506        }
507        let range = self.validate(self.end - self.start, buffer)?;
508        let value = buffer[range].to_vec();
509        self.start = self.end;
510        Ok(value)
511    }
512
513    /// Preencode a fixed 16 byte buffer
514    pub fn preencode_fixed_16(&mut self) -> Result<usize, EncodingError> {
515        self.add_end(16)
516    }
517
518    /// Encode a fixed 16 byte buffer
519    pub fn encode_fixed_16(
520        &mut self,
521        value: &[u8],
522        buffer: &mut [u8],
523    ) -> Result<usize, EncodingError> {
524        self.set_slice_to_buffer_fixed(value, buffer, 16)
525    }
526
527    /// Decode a fixed 16 byte buffer
528    pub fn decode_fixed_16(&mut self, buffer: &[u8]) -> Result<Box<[u8]>, EncodingError> {
529        let range = self.validate(16, buffer)?;
530        let value = buffer[range].to_vec().into_boxed_slice();
531        self.add_start(16)?;
532        Ok(value)
533    }
534
535    /// Preencode a fixed 32 byte buffer
536    pub fn preencode_fixed_32(&mut self) -> Result<usize, EncodingError> {
537        self.add_end(32)
538    }
539
540    /// Encode a fixed 32 byte buffer
541    pub fn encode_fixed_32(
542        &mut self,
543        value: &[u8],
544        buffer: &mut [u8],
545    ) -> Result<usize, EncodingError> {
546        self.set_slice_to_buffer_fixed(value, buffer, 32)
547    }
548
549    /// Decode a fixed 32 byte buffer
550    pub fn decode_fixed_32(&mut self, buffer: &[u8]) -> Result<Box<[u8]>, EncodingError> {
551        let range = self.validate(32, buffer)?;
552        let value = buffer[range].to_vec().into_boxed_slice();
553        self.add_start(32)?;
554        Ok(value)
555    }
556
557    /// Preencode a string array
558    pub fn preencode_string_array(&mut self, value: &Vec<String>) -> Result<usize, EncodingError> {
559        let len = value.len();
560        self.preencode_usize_var(&len)?;
561        for string_value in value.iter() {
562            self.preencode_str(string_value)?;
563        }
564        Ok(self.end)
565    }
566
567    /// Encode a String array
568    pub fn encode_string_array(
569        &mut self,
570        value: &Vec<String>,
571        buffer: &mut [u8],
572    ) -> Result<usize, EncodingError> {
573        let len = value.len();
574        self.encode_usize_var(&len, buffer)?;
575        for string_value in value {
576            self.encode_str(string_value, buffer)?;
577        }
578        Ok(self.end)
579    }
580
581    /// Decode a String array
582    pub fn decode_string_array(&mut self, buffer: &[u8]) -> Result<Vec<String>, EncodingError> {
583        let len = self.decode_usize_var(buffer)?;
584        let mut value = Vec::with_capacity(len);
585        for _ in 0..len {
586            value.push(self.decode_string(buffer)?);
587        }
588        Ok(value)
589    }
590
591    /// Preencode an u32 array
592    pub fn preencode_u32_array(&mut self, value: &Vec<u32>) -> Result<usize, EncodingError> {
593        let len = value.len();
594        self.preencode_usize_var(&len)?;
595        let total_len = len.checked_mul(4).ok_or_else(|| {
596            EncodingError::new(
597                EncodingErrorKind::Overflow,
598                &format!(
599                    "Vec<u32> total length overflowed: {} * 4 > {}",
600                    len,
601                    usize::MAX
602                ),
603            )
604        })?;
605        self.add_end(total_len)
606    }
607
608    /// Encode an u32 array
609    pub fn encode_u32_array(
610        &mut self,
611        value: &Vec<u32>,
612        buffer: &mut [u8],
613    ) -> Result<usize, EncodingError> {
614        let len = value.len();
615        self.encode_usize_var(&len, buffer)?;
616        for entry in value {
617            self.encode_u32(*entry, buffer)?;
618        }
619        Ok(self.start())
620    }
621
622    /// Decode an u32 array
623    pub fn decode_u32_array(&mut self, buffer: &[u8]) -> Result<Vec<u32>, EncodingError> {
624        let len = self.decode_usize_var(buffer)?;
625        let mut value: Vec<u32> = Vec::with_capacity(len);
626        for _ in 0..len {
627            value.push(self.decode_u32(buffer)?);
628        }
629        Ok(value)
630    }
631
632    /// Preencode a fixed 32 byte value array
633    pub fn preencode_fixed_32_array(
634        &mut self,
635        value: &Vec<[u8; 32]>,
636    ) -> Result<usize, EncodingError> {
637        let len = value.len();
638        self.preencode(&len)?;
639        let size = len.checked_mul(32).ok_or_else(|| {
640            EncodingError::new(
641                EncodingErrorKind::Overflow,
642                &format!(
643                    "Vec<[u8; 32]> byte size overflowed: {} * 32 > {}",
644                    len,
645                    usize::MAX
646                ),
647            )
648        })?;
649        self.add_end(size)?;
650        Ok(self.end())
651    }
652
653    /// Encode a fixed 32 byte value array
654    pub fn encode_fixed_32_array(
655        &mut self,
656        value: &Vec<[u8; 32]>,
657        buffer: &mut [u8],
658    ) -> Result<usize, EncodingError> {
659        self.encode(&value.len(), buffer)?;
660        for entry in value {
661            self.set_slice_to_buffer_fixed(entry, buffer, 32)?;
662        }
663        Ok(self.start())
664    }
665
666    /// Decode a fixed 32 byte value array
667    pub fn decode_fixed_32_array(&mut self, buffer: &[u8]) -> Result<Vec<[u8; 32]>, EncodingError> {
668        let len: usize = self.decode(buffer)?;
669        let mut entries: Vec<[u8; 32]> = Vec::with_capacity(len);
670        for _ in 0..len {
671            let range = self.validate(32, buffer)?;
672            entries.push(buffer[range].try_into().map_err(|err| {
673                EncodingError::new(
674                    EncodingErrorKind::InvalidData,
675                    &format!("Could not convert byte slice to [u8; 32], {err}"),
676                )
677            })?);
678            self.add_start(32)?;
679        }
680        Ok(entries)
681    }
682
683    /// Preencode a variable length usize
684    pub fn preencode_usize_var(&mut self, value: &usize) -> Result<usize, EncodingError> {
685        // This repeats the logic from above that works for u8 -> u64, but sadly not usize
686        let increment: usize = if *value < U16_SIGNIFIER.into() {
687            1
688        } else if *value <= 0xffff {
689            3
690        } else if *value <= 0xffffffff {
691            5
692        } else {
693            9
694        };
695        self.add_end(increment)
696    }
697
698    /// Encode a variable length usize
699    pub fn encode_usize_var(
700        &mut self,
701        value: &usize,
702        buffer: &mut [u8],
703    ) -> Result<usize, EncodingError> {
704        if *value < U16_SIGNIFIER.into() {
705            let bytes = value.to_le_bytes();
706            self.set_byte_to_buffer(bytes[0], buffer)
707        } else if *value <= 0xffff {
708            self.set_byte_to_buffer(U16_SIGNIFIER, buffer)?;
709            self.encode_uint16_bytes(&value.to_le_bytes(), buffer)
710        } else if *value <= 0xffffffff {
711            self.set_byte_to_buffer(U32_SIGNIFIER, buffer)?;
712            self.encode_uint32_bytes(&value.to_le_bytes(), buffer)
713        } else {
714            self.set_byte_to_buffer(U64_SIGNIFIER, buffer)?;
715            self.encode_uint64_bytes(&value.to_le_bytes(), buffer)
716        }
717    }
718
719    /// Decode a variable length usize.
720    pub fn decode_usize_var(&mut self, buffer: &[u8]) -> Result<usize, EncodingError> {
721        self.validate(1, buffer)?;
722        let first = buffer[self.start];
723        self.add_start(1)?;
724        // NB: the from_le_bytes needs a [u8; 2] and that can't be efficiently
725        // created from a byte slice.
726        if first < U16_SIGNIFIER {
727            Ok(first.into())
728        } else if first == U16_SIGNIFIER {
729            Ok(self.decode_u16(buffer)?.into())
730        } else if first == U32_SIGNIFIER {
731            usize::try_from(self.decode_u32(buffer)?).map_err(|_| {
732                EncodingError::new(
733                    EncodingErrorKind::Overflow,
734                    "Attempted converting to a 32 bit usize on below 32 bit system",
735                )
736            })
737        } else {
738            usize::try_from(self.decode_u64(buffer)?).map_err(|_| {
739                EncodingError::new(
740                    EncodingErrorKind::Overflow,
741                    "Attempted converting to a 64 bit usize on below 64 bit system",
742                )
743            })
744        }
745    }
746
747    /// Encode a 2 byte unsigned integer. NB: assumes `bytes` buffer large enough, hence not public!
748    fn encode_uint16_bytes(
749        &mut self,
750        bytes: &[u8],
751        buffer: &mut [u8],
752    ) -> Result<usize, EncodingError> {
753        self.set_slice_to_buffer(&bytes[..2], buffer)
754    }
755
756    /// Encode a 4 byte unsigned integer. NB: assumes `bytes` buffer large enough, hence not public!
757    fn encode_uint32_bytes(
758        &mut self,
759        bytes: &[u8],
760        buffer: &mut [u8],
761    ) -> Result<usize, EncodingError> {
762        self.encode_uint16_bytes(bytes, buffer)?;
763        self.set_slice_to_buffer(&bytes[2..4], buffer)
764    }
765
766    /// Encode an 8 byte unsigned integer. NB: assumes `bytes` buffer large enough, hence not public!
767    fn encode_uint64_bytes(
768        &mut self,
769        bytes: &[u8],
770        buffer: &mut [u8],
771    ) -> Result<usize, EncodingError> {
772        self.encode_uint32_bytes(bytes, buffer)?;
773        self.set_slice_to_buffer(&bytes[4..8], buffer)
774    }
775}
776
777/// Compact Encoding
778pub trait CompactEncoding<T>
779where
780    T: fmt::Debug,
781{
782    /// Preencode
783    fn preencode(&mut self, value: &T) -> Result<usize, EncodingError>;
784
785    /// Encode
786    fn encode(&mut self, value: &T, buffer: &mut [u8]) -> Result<usize, EncodingError>;
787
788    /// Decode
789    fn decode(&mut self, buffer: &[u8]) -> Result<T, EncodingError>;
790}
compact_encoding/types.rs

compact_encoding/
types.rs
