bincode/features/
impl_std.rs

1use crate::DecodeUntrusted;
2use crate::{
3    config::Config,
4    de::{read::Reader, BorrowDecode, BorrowDecoder, Decode, Decoder, DecoderImpl},
5    enc::{write::Writer, Encode, Encoder, EncoderImpl},
6    error::{DecodeError, EncodeError},
7    impl_borrow_decode,
8};
9use core::time::Duration;
10use std::{
11    collections::{HashMap, HashSet},
12    ffi::{CStr, CString},
13    hash::Hash,
14    io::Read,
15    net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6},
16    path::{Path, PathBuf},
17    sync::{Mutex, RwLock},
18    time::SystemTime,
19};
20
21/// Decode type `D` from the given reader with the given `Config`. The reader can be any type that implements `std::io::Read`, e.g. `std::fs::File`.
22///
23/// See the [config] module for more information about config options.
24///
25/// [config]: config/index.html
26#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
27pub fn decode_from_std_read<D: Decode<()>, C: Config, R: std::io::Read>(
28    src: &mut R,
29    config: C,
30) -> Result<D, DecodeError> {
31    decode_from_std_read_with_context(src, config, ())
32}
33
34/// Decode type `D` from the given reader with the given `Config` and `Context`. The reader can be any type that implements `std::io::Read`, e.g. `std::fs::File`.
35///
36/// See the [config] module for more information about config options.
37///
38/// [config]: config/index.html
39#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
40pub fn decode_from_std_read_with_context<
41    Context,
42    D: Decode<Context>,
43    C: Config,
44    R: std::io::Read,
45>(
46    src: &mut R,
47    config: C,
48    context: Context,
49) -> Result<D, DecodeError> {
50    let reader = IoReader::new(src);
51    let mut decoder = DecoderImpl::<_, C, Context>::new(reader, config, context);
52    D::decode(&mut decoder)
53}
54
55/// Decode from a standard reader with the [untrusted collection safeguards](crate#untrusted-input).
56#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
57pub fn decode_from_std_read_untrusted<D: DecodeUntrusted<()>, C: Config, R: std::io::Read>(
58    src: &mut R,
59    config: C,
60) -> Result<D, DecodeError> {
61    decode_from_std_read_untrusted_with_context(src, config, ())
62}
63
64/// Decode from a standard reader with a context and the [untrusted collection safeguards](crate#untrusted-input).
65#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
66pub fn decode_from_std_read_untrusted_with_context<
67    Context,
68    D: DecodeUntrusted<Context>,
69    C: Config,
70    R: std::io::Read,
71>(
72    src: &mut R,
73    config: C,
74    context: Context,
75) -> Result<D, DecodeError> {
76    let reader = IoReader::new(src);
77    let mut decoder = DecoderImpl::new_untrusted(reader, config, context);
78    D::decode_untrusted(&mut decoder)
79}
80
81/// Adapts a standard reader for bincode's [`Reader`] trait.
82///
83/// This is also the reader type returned by the owned Serde decoder constructors.
84pub struct IoReader<R> {
85    reader: R,
86}
87
88impl<R> IoReader<R> {
89    /// Wrap a standard reader.
90    pub const fn new(reader: R) -> Self {
91        Self { reader }
92    }
93}
94
95impl<R> Reader for IoReader<R>
96where
97    R: std::io::Read,
98{
99    #[inline(always)]
100    fn read(&mut self, bytes: &mut [u8]) -> Result<(), DecodeError> {
101        self.reader
102            .read_exact(bytes)
103            .map_err(|inner| DecodeError::Io {
104                inner,
105                additional: bytes.len(),
106            })
107    }
108}
109
110impl<R> Reader for std::io::BufReader<R>
111where
112    R: std::io::Read,
113{
114    fn read(&mut self, bytes: &mut [u8]) -> Result<(), DecodeError> {
115        self.read_exact(bytes).map_err(|inner| DecodeError::Io {
116            inner,
117            additional: bytes.len(),
118        })
119    }
120
121    #[inline]
122    fn peek_read(&mut self, n: usize) -> Option<&[u8]> {
123        self.buffer().get(..n)
124    }
125
126    #[inline]
127    fn consume(&mut self, n: usize) {
128        <Self as std::io::BufRead>::consume(self, n);
129    }
130}
131
132/// Encode the given value into any type that implements `std::io::Write`, e.g. `std::fs::File`, with the given `Config`.
133/// See the [config] module for more information.
134/// Returns the amount of bytes written.
135///
136/// [config]: config/index.html
137#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
138pub fn encode_into_std_write<E: Encode, C: Config, W: std::io::Write>(
139    val: E,
140    dst: &mut W,
141    config: C,
142) -> Result<usize, EncodeError> {
143    let writer = IoWriter::new(dst);
144    let mut encoder = EncoderImpl::<_, C>::new(writer, config);
145    val.encode(&mut encoder)?;
146    Ok(encoder.into_writer().bytes_written())
147}
148
149pub(crate) struct IoWriter<'a, W: std::io::Write> {
150    writer: &'a mut W,
151    bytes_written: usize,
152}
153
154impl<'a, W: std::io::Write> IoWriter<'a, W> {
155    pub fn new(writer: &'a mut W) -> Self {
156        Self {
157            writer,
158            bytes_written: 0,
159        }
160    }
161
162    pub const fn bytes_written(&self) -> usize {
163        self.bytes_written
164    }
165}
166
167impl<W: std::io::Write> Writer for IoWriter<'_, W> {
168    #[inline(always)]
169    fn write(&mut self, bytes: &[u8]) -> Result<(), EncodeError> {
170        self.writer
171            .write_all(bytes)
172            .map_err(|inner| EncodeError::Io {
173                inner,
174                index: self.bytes_written,
175            })?;
176        self.bytes_written += bytes.len();
177        Ok(())
178    }
179}
180
181impl Encode for &CStr {
182    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
183        self.to_bytes().encode(encoder)
184    }
185}
186
187impl Encode for CString {
188    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
189        self.as_bytes().encode(encoder)
190    }
191}
192
193impl<Context> Decode<Context> for CString {
194    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
195        let vec = std::vec::Vec::decode(decoder)?;
196        CString::new(vec).map_err(|inner| DecodeError::CStringNulError {
197            position: inner.nul_position(),
198        })
199    }
200}
201impl_borrow_decode!(CString);
202
203impl<T> Encode for Mutex<T>
204where
205    T: Encode,
206{
207    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
208        let t = self.lock().map_err(|_| EncodeError::LockFailed {
209            type_name: core::any::type_name::<Mutex<T>>(),
210        })?;
211        t.encode(encoder)
212    }
213}
214
215impl<Context, T> Decode<Context> for Mutex<T>
216where
217    T: Decode<Context>,
218{
219    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
220        let t = T::decode(decoder)?;
221        Ok(Mutex::new(t))
222    }
223}
224impl<'de, T, Context> BorrowDecode<'de, Context> for Mutex<T>
225where
226    T: BorrowDecode<'de, Context>,
227{
228    fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
229        decoder: &mut D,
230    ) -> Result<Self, DecodeError> {
231        let t = T::borrow_decode(decoder)?;
232        Ok(Mutex::new(t))
233    }
234}
235
236impl<T> Encode for RwLock<T>
237where
238    T: Encode,
239{
240    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
241        let t = self.read().map_err(|_| EncodeError::LockFailed {
242            type_name: core::any::type_name::<RwLock<T>>(),
243        })?;
244        t.encode(encoder)
245    }
246}
247
248impl<Context, T> Decode<Context> for RwLock<T>
249where
250    T: Decode<Context>,
251{
252    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
253        let t = T::decode(decoder)?;
254        Ok(RwLock::new(t))
255    }
256}
257impl<'de, T, Context> BorrowDecode<'de, Context> for RwLock<T>
258where
259    T: BorrowDecode<'de, Context>,
260{
261    fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
262        decoder: &mut D,
263    ) -> Result<Self, DecodeError> {
264        let t = T::borrow_decode(decoder)?;
265        Ok(RwLock::new(t))
266    }
267}
268
269impl Encode for SystemTime {
270    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
271        let duration = self.duration_since(SystemTime::UNIX_EPOCH).map_err(|e| {
272            EncodeError::InvalidSystemTime {
273                inner: e,
274                time: std::boxed::Box::new(*self),
275            }
276        })?;
277        duration.encode(encoder)
278    }
279}
280
281impl<Context> Decode<Context> for SystemTime {
282    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
283        let duration = Duration::decode(decoder)?;
284        match SystemTime::UNIX_EPOCH.checked_add(duration) {
285            Some(t) => Ok(t),
286            None => Err(DecodeError::InvalidSystemTime { duration }),
287        }
288    }
289}
290impl_borrow_decode!(SystemTime);
291
292impl Encode for &'_ Path {
293    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
294        match self.to_str() {
295            Some(str) => str.encode(encoder),
296            None => Err(EncodeError::InvalidPathCharacters),
297        }
298    }
299}
300
301impl<'de, Context> BorrowDecode<'de, Context> for &'de Path {
302    fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
303        decoder: &mut D,
304    ) -> Result<Self, DecodeError> {
305        let str = <&'de str>::borrow_decode(decoder)?;
306        Ok(Path::new(str))
307    }
308}
309
310impl Encode for PathBuf {
311    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
312        self.as_path().encode(encoder)
313    }
314}
315
316impl<Context> Decode<Context> for PathBuf {
317    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
318        let string = std::string::String::decode(decoder)?;
319        Ok(string.into())
320    }
321}
322impl_borrow_decode!(PathBuf);
323
324impl Encode for IpAddr {
325    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
326        match self {
327            IpAddr::V4(v4) => {
328                0u32.encode(encoder)?;
329                v4.encode(encoder)
330            }
331            IpAddr::V6(v6) => {
332                1u32.encode(encoder)?;
333                v6.encode(encoder)
334            }
335        }
336    }
337}
338
339impl<Context> Decode<Context> for IpAddr {
340    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
341        match u32::decode(decoder)? {
342            0 => Ok(IpAddr::V4(Ipv4Addr::decode(decoder)?)),
343            1 => Ok(IpAddr::V6(Ipv6Addr::decode(decoder)?)),
344            found => Err(DecodeError::UnexpectedVariant {
345                allowed: &crate::error::AllowedEnumVariants::Range { min: 0, max: 1 },
346                found,
347                type_name: core::any::type_name::<IpAddr>(),
348            }),
349        }
350    }
351}
352impl_borrow_decode!(IpAddr);
353
354impl Encode for Ipv4Addr {
355    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
356        encoder.writer().write(&self.octets())
357    }
358}
359
360impl<Context> Decode<Context> for Ipv4Addr {
361    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
362        let mut buff = [0u8; 4];
363        decoder.reader().read(&mut buff)?;
364        Ok(Self::from(buff))
365    }
366}
367impl_borrow_decode!(Ipv4Addr);
368
369impl Encode for Ipv6Addr {
370    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
371        encoder.writer().write(&self.octets())
372    }
373}
374
375impl<Context> Decode<Context> for Ipv6Addr {
376    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
377        let mut buff = [0u8; 16];
378        decoder.reader().read(&mut buff)?;
379        Ok(Self::from(buff))
380    }
381}
382impl_borrow_decode!(Ipv6Addr);
383
384impl Encode for SocketAddr {
385    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
386        match self {
387            SocketAddr::V4(v4) => {
388                0u32.encode(encoder)?;
389                v4.encode(encoder)
390            }
391            SocketAddr::V6(v6) => {
392                1u32.encode(encoder)?;
393                v6.encode(encoder)
394            }
395        }
396    }
397}
398
399impl<Context> Decode<Context> for SocketAddr {
400    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
401        match u32::decode(decoder)? {
402            0 => Ok(SocketAddr::V4(SocketAddrV4::decode(decoder)?)),
403            1 => Ok(SocketAddr::V6(SocketAddrV6::decode(decoder)?)),
404            found => Err(DecodeError::UnexpectedVariant {
405                allowed: &crate::error::AllowedEnumVariants::Range { min: 0, max: 1 },
406                found,
407                type_name: core::any::type_name::<SocketAddr>(),
408            }),
409        }
410    }
411}
412impl_borrow_decode!(SocketAddr);
413
414impl Encode for SocketAddrV4 {
415    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
416        self.ip().encode(encoder)?;
417        self.port().encode(encoder)
418    }
419}
420
421impl<Context> Decode<Context> for SocketAddrV4 {
422    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
423        let ip = Ipv4Addr::decode(decoder)?;
424        let port = u16::decode(decoder)?;
425        Ok(Self::new(ip, port))
426    }
427}
428impl_borrow_decode!(SocketAddrV4);
429
430impl Encode for SocketAddrV6 {
431    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
432        self.ip().encode(encoder)?;
433        self.port().encode(encoder)
434    }
435}
436
437impl<Context> Decode<Context> for SocketAddrV6 {
438    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
439        let ip = Ipv6Addr::decode(decoder)?;
440        let port = u16::decode(decoder)?;
441        Ok(Self::new(ip, port, 0, 0))
442    }
443}
444impl_borrow_decode!(SocketAddrV6);
445
446impl std::error::Error for EncodeError {
447    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
448        match self {
449            Self::RefCellAlreadyBorrowed { inner, .. } => Some(inner),
450            Self::Io { inner, .. } => Some(inner),
451            Self::InvalidSystemTime { inner, .. } => Some(inner),
452            _ => None,
453        }
454    }
455}
456impl std::error::Error for DecodeError {
457    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
458        match self {
459            Self::Utf8 { inner } => Some(inner),
460            _ => None,
461        }
462    }
463}
464
465impl<K, V, S> Encode for HashMap<K, V, S>
466where
467    K: Encode,
468    V: Encode,
469{
470    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
471        crate::enc::encode_slice_len(encoder, self.len())?;
472        for (k, v) in self.iter() {
473            Encode::encode(k, encoder)?;
474            Encode::encode(v, encoder)?;
475        }
476        Ok(())
477    }
478}
479
480impl<Context, K, V, S> Decode<Context> for HashMap<K, V, S>
481where
482    K: Decode<Context> + Eq + std::hash::Hash,
483    V: Decode<Context>,
484    S: std::hash::BuildHasher + Default,
485{
486    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
487        let len = crate::de::decode_slice_len(decoder)?;
488        decoder.claim_container_read::<(K, V)>(len)?;
489
490        let hash_builder: S = Default::default();
491        let mut map = HashMap::with_capacity_and_hasher(len, hash_builder);
492        for _ in 0..len {
493            // See the documentation on `unclaim_bytes_read` as to why we're doing this here
494            decoder.unclaim_bytes_read(core::mem::size_of::<(K, V)>());
495
496            let k = K::decode(decoder)?;
497            let v = V::decode(decoder)?;
498            map.insert(k, v);
499        }
500        Ok(map)
501    }
502}
503impl<'de, K, V, S, Context> BorrowDecode<'de, Context> for HashMap<K, V, S>
504where
505    K: BorrowDecode<'de, Context> + Eq + std::hash::Hash,
506    V: BorrowDecode<'de, Context>,
507    S: std::hash::BuildHasher + Default,
508{
509    fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
510        decoder: &mut D,
511    ) -> Result<Self, DecodeError> {
512        let len = crate::de::decode_slice_len(decoder)?;
513        decoder.claim_container_read::<(K, V)>(len)?;
514
515        let hash_builder: S = Default::default();
516        let mut map = HashMap::with_capacity_and_hasher(len, hash_builder);
517        for _ in 0..len {
518            // See the documentation on `unclaim_bytes_read` as to why we're doing this here
519            decoder.unclaim_bytes_read(core::mem::size_of::<(K, V)>());
520
521            let k = K::borrow_decode(decoder)?;
522            let v = V::borrow_decode(decoder)?;
523            map.insert(k, v);
524        }
525        Ok(map)
526    }
527}
528
529impl<Context, T, S> Decode<Context> for HashSet<T, S>
530where
531    T: Decode<Context> + Eq + Hash,
532    S: std::hash::BuildHasher + Default,
533{
534    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
535        let len = crate::de::decode_slice_len(decoder)?;
536        decoder.claim_container_read::<T>(len)?;
537
538        let hash_builder: S = Default::default();
539        let mut map: HashSet<T, S> = HashSet::with_capacity_and_hasher(len, hash_builder);
540        for _ in 0..len {
541            // See the documentation on `unclaim_bytes_read` as to why we're doing this here
542            decoder.unclaim_bytes_read(core::mem::size_of::<T>());
543
544            let key = T::decode(decoder)?;
545            map.insert(key);
546        }
547        Ok(map)
548    }
549}
550
551impl<'de, T, S, Context> BorrowDecode<'de, Context> for HashSet<T, S>
552where
553    T: BorrowDecode<'de, Context> + Eq + Hash,
554    S: std::hash::BuildHasher + Default,
555{
556    fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
557        decoder: &mut D,
558    ) -> Result<Self, DecodeError> {
559        let len = crate::de::decode_slice_len(decoder)?;
560        decoder.claim_container_read::<T>(len)?;
561
562        let mut map = HashSet::with_capacity_and_hasher(len, S::default());
563        for _ in 0..len {
564            // See the documentation on `unclaim_bytes_read` as to why we're doing this here
565            decoder.unclaim_bytes_read(core::mem::size_of::<T>());
566
567            let key = T::borrow_decode(decoder)?;
568            map.insert(key);
569        }
570        Ok(map)
571    }
572}
573
574impl<T, S> Encode for HashSet<T, S>
575where
576    T: Encode,
577{
578    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
579        crate::enc::encode_slice_len(encoder, self.len())?;
580        for item in self.iter() {
581            item.encode(encoder)?;
582        }
583        Ok(())
584    }
585}
bincode/features/impl_std.rs

bincode/features/
impl_std.rs
