epserde 0.12.6

ε-serde is an ε-copy (i.e., almost zero-copy) serialization/deserialization framework
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

/*
 * SPDX-FileCopyrightText: 2023 Inria
 * SPDX-FileCopyrightText: 2023 Sebastiano Vigna
 *
 * SPDX-License-Identifier: Apache-2.0 OR LGPL-2.1-or-later
 */

use crate::prelude::*;

use super::ReadNoStd;

/// A wrapper for a [`ReadNoStd`] that implements [`ReadWithPos`]
/// by keeping track of the current position.
#[derive(Debug)]
#[cfg_attr(feature = "mem_dbg", derive(mem_dbg::MemDbg, mem_dbg::MemSize))]
pub struct ReaderWithPos<'a, F: ReadNoStd> {
    /// What we actually read from
    backend: &'a mut F,
    /// How many bytes we have read from the start
    pos: usize,
}

impl<'a, F: ReadNoStd> ReaderWithPos<'a, F> {
    /// Create a new [`ReadWithPos`] on top of a generic [`ReadNoStd`].
    #[inline(always)]
    pub const fn new(backend: &'a mut F) -> Self {
        Self { backend, pos: 0 }
    }
}

impl<F: ReadNoStd> ReadNoStd for ReaderWithPos<'_, F> {
    fn read_exact(&mut self, buf: &mut [u8]) -> deser::Result<()> {
        self.backend.read_exact(buf)?;
        self.pos += buf.len();
        Ok(())
    }
}

impl<F: ReadNoStd> ReadWithPos for ReaderWithPos<'_, F> {
    fn pos(&self) -> usize {
        self.pos
    }

    fn align<T: AlignTo>(&mut self) -> deser::Result<()> {
        // Skip bytes as needed
        let mut padding = crate::pad_align_to(self.pos, T::align_to());
        let mut buf = [0u8; 64];
        while padding > 0 {
            let n = padding.min(buf.len());
            self.read_exact(&mut buf[..n])?;
            padding -= n;
        }
        // No alignment check, we are fully deserializing
        Ok(())
    }
}