bincode_next/features/
impl_std.rs

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

bincode_next/features/
impl_std.rs
