cu-bincode 2.0.2

A binary serialization / deserialization strategy for transforming structs into bytes and vice versa!
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

use super::{
    read::{BorrowReader, Reader},
    BorrowDecoder, Decoder,
};
use crate::{config::Config, error::DecodeError, utils::Sealed};

/// 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.
///
/// ```
/// # extern crate cu_bincode as bincode;
/// # let slice: &[u8] = &[0, 0, 0, 0];
/// # let some_reader = bincode::de::read::SliceReader::new(slice);
/// use bincode::de::{DecoderImpl, Decode};
/// let mut context = ();
/// let mut decoder = DecoderImpl::new(some_reader, bincode::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 fn new(reader: R, config: C, context: Context) -> DecoderImpl<R, C, Context> {
        DecoderImpl {
            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 R = R;

    type C = C;
    type Context = Context;

    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> {
        // 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`
            self.bytes_read = self
                .bytes_read
                .checked_add(n)
                .ok_or(DecodeError::LimitExceeded)?;
            if self.bytes_read > limit {
                Err(DecodeError::LimitExceeded)
            } else {
                Ok(())
            }
        } 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 R = D::R;

    type C = D::C;

    type Context = Context;

    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.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()
    }
}