bincode-next 3.0.0-rc.2

A compact, ultra-fast binary serialization format for Rust, optimized for networking and storage!
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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166

use super::BorrowDecoder;
use super::Decoder;
use super::read::BorrowReader;
use super::read::Reader;
use crate::config::Config;
use crate::error::DecodeError;
use crate::error_path::BincodeErrorPathCovered;
use crate::utils::Sealed;

impl<R, C: Config, Context> BincodeErrorPathCovered<0> for DecoderImpl<R, C, Context> {}
impl<C, D: Decoder + ?Sized> BincodeErrorPathCovered<0> for WithContext<'_, D, C> {}


/// A Decoder that reads bytes from a given reader `R`.
///
/// This struct should rarely be used.
/// In most cases, prefer any of the `decode` functions.
///
/// The `ByteOrder` that is chosen will impact the endianness that
/// is used to read integers out of the reader.
///
/// ```
/// # let slice: &[u8] = &[0, 0, 0, 0];
/// # let some_reader = bincode_next::de::read::SliceReader::new(slice);
/// use bincode_next::de::Decode;
/// use bincode_next::de::DecoderImpl;
/// let mut context = ();
/// let mut decoder = DecoderImpl::new(some_reader, bincode_next::config::standard(), &mut context);
/// // this u32 can be any Decode
/// let value = u32::decode(&mut decoder).unwrap();
/// ```
pub struct DecoderImpl<R, C: Config, Context> {
    reader: R,
    config: C,
    bytes_read: usize,
    context: Context,
}

impl<R: Reader, C: Config, Context> DecoderImpl<R, C, Context> {
    /// Construct a new Decoder
    pub const fn new(
        reader: R,
        config: C,
        context: Context,
    ) -> Self {
        Self {
            reader,
            config,
            bytes_read: 0,
            context,
        }
    }
}

impl<R, C: Config, Context> Sealed for DecoderImpl<R, C, Context> {}

impl<'de, R: BorrowReader<'de>, C: Config, Context> BorrowDecoder<'de>
    for DecoderImpl<R, C, Context>
{
    type BR = R;

    fn borrow_reader(&mut self) -> &mut Self::BR {
        &mut self.reader
    }
}

impl<R: Reader, C: Config, Context> Decoder for DecoderImpl<R, C, Context> {
    type C = C;
    type Context = Context;
    type R = R;

    fn reader(&mut self) -> &mut Self::R {
        &mut self.reader
    }

    fn config(&self) -> &Self::C {
        &self.config
    }

    #[inline]
    fn claim_bytes_read(
        &mut self,
        n: usize,
    ) -> Result<(), DecodeError> {
        Self::assert_covered();
        // C::LIMIT is a const so this check should get compiled away
        if let Some(limit) = C::LIMIT {
            // Make sure we don't accidentally overflow `bytes_read`
            if let Some(sum) = self.bytes_read.checked_add(n) {
                if sum > limit {
                    return crate::error::cold_decode_error_limit_exceeded();
                }
                self.bytes_read = sum;
                Ok(())
            } else {
                crate::error::cold_decode_error_limit_exceeded()
            }
        } else {
            Ok(())
        }
    }

    #[inline]
    fn unclaim_bytes_read(
        &mut self,
        n: usize,
    ) {
        // C::LIMIT is a const so this check should get compiled away
        if C::LIMIT.is_some() {
            // We should always be claiming more than we unclaim, so this should never underflow
            self.bytes_read -= n;
        }
    }

    fn context(&mut self) -> &mut Self::Context {
        &mut self.context
    }
}

pub struct WithContext<'a, D: ?Sized, C> {
    pub(crate) decoder: &'a mut D,
    pub(crate) context: C,
}

impl<C, D: Decoder + ?Sized> Sealed for WithContext<'_, D, C> {}

impl<Context, D: Decoder + ?Sized> Decoder for WithContext<'_, D, Context> {
    type C = D::C;
    type Context = Context;
    type R = D::R;

    fn context(&mut self) -> &mut Self::Context {
        &mut self.context
    }

    fn reader(&mut self) -> &mut Self::R {
        self.decoder.reader()
    }

    fn config(&self) -> &Self::C {
        self.decoder.config()
    }

    fn claim_bytes_read(
        &mut self,
        n: usize,
    ) -> Result<(), DecodeError> {
        Self::assert_covered();
        self.decoder.claim_bytes_read(n)
    }

    fn unclaim_bytes_read(
        &mut self,
        n: usize,
    ) {
        self.decoder.unclaim_bytes_read(n);
    }
}

impl<'de, C, D: BorrowDecoder<'de>> BorrowDecoder<'de> for WithContext<'_, D, C> {
    type BR = D::BR;

    fn borrow_reader(&mut self) -> &mut Self::BR {
        self.decoder.borrow_reader()
    }
}