bincode_next/features/
impl_std.rs

1use crate::config::Config;
2use crate::config::internal::InternalFingerprintGuard;
3use crate::de::BorrowDecode;
4use crate::de::BorrowDecoder;
5use crate::de::Decode;
6use crate::de::Decoder;
7use crate::de::DecoderImpl;
8use crate::de::read::Reader;
9use crate::enc::Encode;
10use crate::enc::Encoder;
11use crate::enc::EncoderImpl;
12use crate::enc::write::Writer;
13use crate::error::DecodeError;
14use crate::error::EncodeError;
15use crate::impl_borrow_decode;
16use core::time::Duration;
17use std::collections::HashMap;
18use std::collections::HashSet;
19use std::ffi::CStr;
20use std::ffi::CString;
21use std::hash::Hash;
22use std::io::Read;
23use std::net::IpAddr;
24use std::net::Ipv4Addr;
25use std::net::Ipv6Addr;
26use std::net::SocketAddr;
27use std::net::SocketAddrV4;
28use std::net::SocketAddrV6;
29use std::path::Path;
30use std::path::PathBuf;
31use std::sync::Mutex;
32use std::sync::RwLock;
33use std::time::SystemTime;
34
35/// 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`.
36///
37/// See the [config] module for more information about config options.
38///
39/// [config]: config/index.html
40///
41/// # Errors
42///
43/// Returns a `DecodeError` if the reader fails or the data is invalid.
44#[inline(always)]
45#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
46pub fn decode_from_std_read<D: Decode<()>, C: Config, R: std::io::Read>(
47    src: &mut R,
48    config: C,
49) -> Result<D, DecodeError>
50where
51    C::Mode: crate::config::InternalFingerprintGuard<D, C>,
52{
53    decode_from_std_read_with_context(src, config, ())
54}
55
56/// 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`.
57///
58/// See the [config] module for more information about config options.
59///
60/// [config]: config/index.html
61///
62/// # Errors
63///
64/// Returns a `DecodeError` if the reader fails or the data is invalid.
65#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
66#[inline(always)]
67pub fn decode_from_std_read_with_context<Context, D: Decode<Context>, C: Config, R: std::io::Read>(
68    src: &mut R,
69    config: C,
70    context: Context,
71) -> Result<D, DecodeError>
72where
73    C::Mode: crate::config::InternalFingerprintGuard<D, C>,
74{
75    let mut reader = IoReader::new(src);
76    C::Mode::decode_check(&config, &mut reader)?;
77    let mut decoder = DecoderImpl::<_, C, Context>::new(reader, config, context);
78    D::decode(&mut decoder)
79}
80
81/// A reader that reads from a `std::io::Read`.
82pub struct IoReader<R> {
83    reader: R,
84}
85
86impl<R> IoReader<R> {
87    /// Create a new `IoReader` from the given reader.
88    pub const fn new(reader: R) -> Self {
89        Self { reader }
90    }
91}
92
93impl<R> Reader for IoReader<R>
94where
95    R: std::io::Read,
96{
97    #[inline(always)]
98    fn read(
99        &mut self,
100        bytes: &mut [u8],
101    ) -> Result<(), DecodeError> {
102        self.reader.read_exact(bytes).map_err(|inner| {
103            if inner.kind() == std::io::ErrorKind::UnexpectedEof {
104                crate::error::cold_decode_error_unexpected_end::<()>(bytes.len()).unwrap_err()
105            } else {
106                crate::error::cold_decode_error_io::<()>(inner, bytes.len()).unwrap_err()
107            }
108        })
109    }
110}
111
112impl<R> Reader for std::io::BufReader<R>
113where
114    R: std::io::Read,
115{
116    #[inline(always)]
117    fn read(
118        &mut self,
119        bytes: &mut [u8],
120    ) -> Result<(), DecodeError> {
121        self.read_exact(bytes).map_err(|inner| {
122            if inner.kind() == std::io::ErrorKind::UnexpectedEof {
123                crate::error::cold_decode_error_unexpected_end::<()>(bytes.len()).unwrap_err()
124            } else {
125                crate::error::cold_decode_error_io::<()>(inner, bytes.len()).unwrap_err()
126            }
127        })
128    }
129
130    #[inline(always)]
131    fn peek_read(
132        &mut self,
133        n: usize,
134    ) -> Option<&[u8]> {
135        self.buffer().get(..n)
136    }
137
138    #[inline(always)]
139    fn consume(
140        &mut self,
141        n: usize,
142    ) {
143        <Self as std::io::BufRead>::consume(self, n);
144    }
145}
146
147/// Encode the given value into any type that implements `std::io::Write`, e.g. `std::fs::File`, with the given `Config`.
148///
149/// See the [config] module for more information.
150/// Returns the amount of bytes written.
151///
152/// [config]: config/index.html
153///
154/// # Errors
155///
156/// Returns an `EncodeError` if the writer fails.
157#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
158#[inline]
159pub fn encode_into_std_write<E: Encode, C: Config, W: std::io::Write>(
160    val: E,
161    dst: &mut W,
162    config: C,
163) -> Result<usize, EncodeError>
164where
165    C::Mode: crate::config::InternalFingerprintGuard<E, C>,
166{
167    let mut writer = IoWriter::new(dst);
168    C::Mode::encode_check(&config, &mut writer)?;
169    let mut encoder = EncoderImpl::<_, C>::new(writer, config);
170    val.encode(&mut encoder)?;
171    let mut final_writer = encoder.into_writer();
172    final_writer.flush()?;
173    Ok(final_writer.bytes_written())
174}
175
176/// A writer that writes to a `std::io::Write`.
177pub struct IoWriter<'a, W: std::io::Write> {
178    writer: &'a mut W,
179    buffer: [u8; 2048],
180    buffer_len: usize,
181    bytes_written: usize,
182}
183
184impl<'a, W: std::io::Write> IoWriter<'a, W> {
185    /// Create a new `IoWriter` from the given writer.
186    pub const fn new(writer: &'a mut W) -> Self {
187        Self {
188            writer,
189            buffer: [0; 2048],
190            buffer_len: 0,
191            bytes_written: 0,
192        }
193    }
194
195    /// Returns the number of bytes written to the underlying writer.
196    ///
197    /// # Errors
198    ///
199    /// Returns `EncodeError` if the encoding fails.
200    #[must_use]
201    pub const fn bytes_written(&self) -> usize {
202        self.bytes_written
203    }
204
205    /// Flushes any buffered data to the underlying writer.
206    ///
207    /// # Errors
208    ///
209    /// Returns an `EncodeError` if the writer flushing fails.
210    #[inline(always)]
211    pub fn flush(&mut self) -> Result<(), EncodeError> {
212        if self.buffer_len > 0 {
213            self.writer
214                .write_all(&self.buffer[..self.buffer_len])
215                .map_err(|inner| {
216                    crate::error::cold_encode_error_io::<()>(
217                        inner,
218                        self.bytes_written - self.buffer_len,
219                    )
220                    .unwrap_err()
221                })?;
222            self.buffer_len = 0;
223        }
224        Ok(())
225    }
226}
227
228impl<W: std::io::Write> Writer for IoWriter<'_, W> {
229    #[inline(always)]
230    fn write(
231        &mut self,
232        bytes: &[u8],
233    ) -> Result<(), EncodeError> {
234        if crate::utils::is_likely!(bytes.len() <= self.buffer.len() - self.buffer_len) {
235            self.buffer[self.buffer_len..self.buffer_len + bytes.len()].copy_from_slice(bytes);
236            self.buffer_len += bytes.len();
237        } else {
238            self.flush()?;
239            if crate::utils::is_likely!(bytes.len() >= self.buffer.len()) {
240                self.writer.write_all(bytes).map_err(|inner| {
241                    crate::error::cold_encode_error_io::<()>(inner, self.bytes_written).unwrap_err()
242                })?;
243            } else {
244                self.buffer[..bytes.len()].copy_from_slice(bytes);
245                self.buffer_len = bytes.len();
246            }
247        }
248        self.bytes_written += bytes.len();
249        Ok(())
250    }
251}
252
253impl<W: std::io::Write> Drop for IoWriter<'_, W> {
254    #[inline(always)]
255    fn drop(&mut self) {
256        let _ = self.flush();
257    }
258}
259
260impl Encode for &CStr {
261    #[inline(always)]
262    fn encode<E: Encoder>(
263        &self,
264        encoder: &mut E,
265    ) -> Result<(), EncodeError> {
266        self.to_bytes().encode(encoder)
267    }
268}
269
270impl Encode for CString {
271    #[inline(always)]
272    fn encode<E: Encoder>(
273        &self,
274        encoder: &mut E,
275    ) -> Result<(), EncodeError> {
276        self.as_bytes().encode(encoder)
277    }
278}
279
280impl<Context> Decode<Context> for CString {
281    #[inline(always)]
282    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
283        let vec = std::vec::Vec::decode(decoder)?;
284        Self::new(vec).map_err(|inner| {
285            crate::error::cold_decode_error_c_string_nul_error::<()>(inner.nul_position())
286                .unwrap_err()
287        })
288    }
289}
290impl_borrow_decode!(CString);
291
292impl<T> Encode for Mutex<T>
293where
294    T: Encode,
295{
296    #[inline(always)]
297    fn encode<E: Encoder>(
298        &self,
299        encoder: &mut E,
300    ) -> Result<(), EncodeError> {
301        let t = self.lock().map_err(|_| {
302            crate::error::cold_encode_error_lock_failed::<()>(core::any::type_name::<Self>())
303                .unwrap_err()
304        })?;
305        t.encode(encoder)
306    }
307}
308
309impl<Context, T> Decode<Context> for Mutex<T>
310where
311    T: Decode<Context>,
312{
313    #[inline(always)]
314    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
315        let t = T::decode(decoder)?;
316        Ok(Self::new(t))
317    }
318}
319impl<'de, T, Context> BorrowDecode<'de, Context> for Mutex<T>
320where
321    T: BorrowDecode<'de, Context>,
322{
323    #[inline(always)]
324    fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
325        decoder: &mut D
326    ) -> Result<Self, DecodeError> {
327        let t = T::borrow_decode(decoder)?;
328        Ok(Self::new(t))
329    }
330}
331
332impl<T> Encode for RwLock<T>
333where
334    T: Encode,
335{
336    #[inline(always)]
337    fn encode<E: Encoder>(
338        &self,
339        encoder: &mut E,
340    ) -> Result<(), EncodeError> {
341        let t = self.read().map_err(|_| {
342            crate::error::cold_encode_error_lock_failed::<()>(core::any::type_name::<Self>())
343                .unwrap_err()
344        })?;
345        t.encode(encoder)
346    }
347}
348
349impl<Context, T> Decode<Context> for RwLock<T>
350where
351    T: Decode<Context>,
352{
353    #[inline(always)]
354    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
355        let t = T::decode(decoder)?;
356        Ok(Self::new(t))
357    }
358}
359impl<'de, T, Context> BorrowDecode<'de, Context> for RwLock<T>
360where
361    T: BorrowDecode<'de, Context>,
362{
363    #[inline(always)]
364    fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
365        decoder: &mut D
366    ) -> Result<Self, DecodeError> {
367        let t = T::borrow_decode(decoder)?;
368        Ok(Self::new(t))
369    }
370}
371
372impl Encode for SystemTime {
373    #[inline]
374    fn encode<E: Encoder>(
375        &self,
376        encoder: &mut E,
377    ) -> Result<(), EncodeError> {
378        let duration = self.duration_since(Self::UNIX_EPOCH).map_err(|e| {
379            crate::error::cold_encode_error_invalid_system_time::<()>(
380                e,
381                std::boxed::Box::new(*self),
382            )
383            .unwrap_err()
384        })?;
385        duration.encode(encoder)
386    }
387}
388
389impl<Context> Decode<Context> for SystemTime {
390    #[inline]
391    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
392        let duration = Duration::decode(decoder)?;
393        Self::UNIX_EPOCH.checked_add(duration).ok_or_else(|| {
394            crate::error::cold_decode_error_invalid_system_time::<()>(duration).unwrap_err()
395        })
396    }
397}
398impl_borrow_decode!(SystemTime);
399
400impl Encode for &'_ Path {
401    #[inline(always)]
402    fn encode<E: Encoder>(
403        &self,
404        encoder: &mut E,
405    ) -> Result<(), EncodeError> {
406        self.to_str()
407            .ok_or_else(|| {
408                crate::error::cold_encode_error_invalid_path_characters::<()>().unwrap_err()
409            })?
410            .encode(encoder)
411    }
412}
413
414impl<'de, Context> BorrowDecode<'de, Context> for &'de Path {
415    #[inline(always)]
416    fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
417        decoder: &mut D
418    ) -> Result<Self, DecodeError> {
419        let str = <&'de str>::borrow_decode(decoder)?;
420        Ok(Path::new(str))
421    }
422}
423
424impl Encode for PathBuf {
425    #[inline(always)]
426    fn encode<E: Encoder>(
427        &self,
428        encoder: &mut E,
429    ) -> Result<(), EncodeError> {
430        self.as_path().encode(encoder)
431    }
432}
433
434impl<Context> Decode<Context> for PathBuf {
435    #[inline(always)]
436    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
437        let string = std::string::String::decode(decoder)?;
438        Ok(string.into())
439    }
440}
441impl_borrow_decode!(PathBuf);
442
443impl Encode for IpAddr {
444    #[inline(always)]
445    fn encode<E: Encoder>(
446        &self,
447        encoder: &mut E,
448    ) -> Result<(), EncodeError> {
449        match self {
450            | Self::V4(v4) => {
451                0u32.encode(encoder)?;
452                v4.encode(encoder)
453            },
454            | Self::V6(v6) => {
455                1u32.encode(encoder)?;
456                v6.encode(encoder)
457            },
458        }
459    }
460}
461
462impl<Context> Decode<Context> for IpAddr {
463    #[inline(always)]
464    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
465        match u32::decode(decoder)? {
466            | 0 => Ok(Self::V4(Ipv4Addr::decode(decoder)?)),
467            | 1 => Ok(Self::V6(Ipv6Addr::decode(decoder)?)),
468            | found => {
469                crate::error::cold_decode_error_unexpected_variant(
470                    core::any::type_name::<Self>(),
471                    &crate::error::AllowedEnumVariants::Range { min: 0, max: 1 },
472                    found,
473                )
474            },
475        }
476    }
477}
478impl_borrow_decode!(IpAddr);
479
480impl Encode for Ipv4Addr {
481    #[inline(always)]
482    fn encode<E: Encoder>(
483        &self,
484        encoder: &mut E,
485    ) -> Result<(), EncodeError> {
486        encoder.writer().write(&self.octets())
487    }
488}
489
490impl<Context> Decode<Context> for Ipv4Addr {
491    #[inline(always)]
492    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
493        let mut buff = [0u8; 4];
494        decoder.reader().read(&mut buff)?;
495        Ok(Self::from(buff))
496    }
497}
498impl_borrow_decode!(Ipv4Addr);
499
500impl Encode for Ipv6Addr {
501    #[inline(always)]
502    fn encode<E: Encoder>(
503        &self,
504        encoder: &mut E,
505    ) -> Result<(), EncodeError> {
506        encoder.writer().write(&self.octets())
507    }
508}
509
510impl<Context> Decode<Context> for Ipv6Addr {
511    #[inline(always)]
512    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
513        let mut buff = [0u8; 16];
514        decoder.reader().read(&mut buff)?;
515        Ok(Self::from(buff))
516    }
517}
518impl_borrow_decode!(Ipv6Addr);
519
520impl Encode for SocketAddr {
521    #[inline(always)]
522    fn encode<E: Encoder>(
523        &self,
524        encoder: &mut E,
525    ) -> Result<(), EncodeError> {
526        match self {
527            | Self::V4(v4) => {
528                0u32.encode(encoder)?;
529                v4.encode(encoder)
530            },
531            | Self::V6(v6) => {
532                1u32.encode(encoder)?;
533                v6.encode(encoder)
534            },
535        }
536    }
537}
538
539impl<Context> Decode<Context> for SocketAddr {
540    #[inline(always)]
541    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
542        match u32::decode(decoder)? {
543            | 0 => Ok(Self::V4(SocketAddrV4::decode(decoder)?)),
544            | 1 => Ok(Self::V6(SocketAddrV6::decode(decoder)?)),
545            | found => {
546                crate::error::cold_decode_error_unexpected_variant(
547                    core::any::type_name::<Self>(),
548                    &crate::error::AllowedEnumVariants::Range { min: 0, max: 1 },
549                    found,
550                )
551            },
552        }
553    }
554}
555impl_borrow_decode!(SocketAddr);
556
557impl Encode for SocketAddrV4 {
558    #[inline(always)]
559    fn encode<E: Encoder>(
560        &self,
561        encoder: &mut E,
562    ) -> Result<(), EncodeError> {
563        self.ip().encode(encoder)?;
564        self.port().encode(encoder)
565    }
566}
567
568impl<Context> Decode<Context> for SocketAddrV4 {
569    #[inline(always)]
570    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
571        let ip = Ipv4Addr::decode(decoder)?;
572        let port = u16::decode(decoder)?;
573        Ok(Self::new(ip, port))
574    }
575}
576impl_borrow_decode!(SocketAddrV4);
577
578impl Encode for SocketAddrV6 {
579    #[inline(always)]
580    fn encode<E: Encoder>(
581        &self,
582        encoder: &mut E,
583    ) -> Result<(), EncodeError> {
584        self.ip().encode(encoder)?;
585        self.port().encode(encoder)?;
586        if !encoder.config().is_compact_net() {
587            self.flowinfo().encode(encoder)?;
588            self.scope_id().encode(encoder)?;
589        }
590        Ok(())
591    }
592}
593
594impl<Context> Decode<Context> for SocketAddrV6 {
595    #[inline(always)]
596    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
597        let ip = Ipv6Addr::decode(decoder)?;
598        let port = u16::decode(decoder)?;
599        if decoder.config().is_compact_net() {
600            Ok(Self::new(ip, port, 0, 0))
601        } else {
602            let flowinfo = u32::decode(decoder)?;
603            let scope_id = u32::decode(decoder)?;
604            Ok(Self::new(ip, port, flowinfo, scope_id))
605        }
606    }
607}
608impl_borrow_decode!(SocketAddrV6);
609
610impl<K, V, S> Encode for HashMap<K, V, S>
611where
612    K: Encode,
613    V: Encode,
614{
615    #[inline(always)]
616    fn encode<E: Encoder>(
617        &self,
618        encoder: &mut E,
619    ) -> Result<(), EncodeError> {
620        use crate::config::Format;
621        let format = <E::C as crate::config::InternalFormatConfig>::FORMAT;
622        if format == Format::CborDeterministic {
623            crate::enc::cbor::encode_map_deterministic::<E, _, _, _>(encoder, self.iter())
624        } else if format == Format::BincodeDeterministic {
625            #[cfg(feature = "alloc")]
626            return crate::enc::deterministic::encode_map_deterministic::<E, _, _, _>(
627                encoder,
628                self.iter(),
629            );
630            #[cfg(not(feature = "alloc"))]
631            return crate::error::cold_encode_error_other(
632                "Deterministic encoding requires the 'alloc' feature",
633            );
634        } else {
635            encoder.encode_map_len(self.len())?;
636            for (k, v) in self {
637                Encode::encode(k, encoder)?;
638                Encode::encode(v, encoder)?;
639            }
640            Ok(())
641        }
642    }
643}
644
645impl<Context, K, V, S> Decode<Context> for HashMap<K, V, S>
646where
647    K: Decode<Context> + Eq + std::hash::Hash,
648    V: Decode<Context>,
649    S: std::hash::BuildHasher + Default,
650{
651    #[inline]
652    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
653        let len = decoder.decode_map_len()?;
654        let is_bincode = matches!(
655            <D::C as crate::config::InternalFormatConfig>::FORMAT,
656            crate::config::Format::Bincode | crate::config::Format::BincodeDeterministic
657        );
658        let is_deterministic = matches!(
659            <D::C as crate::config::InternalFormatConfig>::FORMAT,
660            crate::config::Format::BincodeDeterministic
661        );
662        if !is_bincode && len == usize::MAX {
663            let mut map = Self::with_hasher(S::default());
664            while decoder.reader().peek_u8() != Some(0xFF) {
665                let k = K::decode(decoder)?;
666                let v = V::decode(decoder)?;
667                map.insert(k, v);
668            }
669            decoder.reader().read_u8()?; // consume 0xFF
670            return Ok(map);
671        }
672        decoder.claim_container_read::<(K, V)>(len)?;
673
674        let hash_builder: S = Default::default();
675        let mut map = Self::with_capacity_and_hasher(len, hash_builder);
676        for _ in 0..len {
677            decoder.unclaim_bytes_read(core::mem::size_of::<(K, V)>());
678            let k = K::decode(decoder)?;
679            let v = V::decode(decoder)?;
680            if is_deterministic {
681                if map.insert(k, v).is_some() {
682                    return crate::error::cold_decode_error_duplicate_map_key();
683                }
684            } else {
685                map.insert(k, v);
686            }
687        }
688        Ok(map)
689    }
690}
691impl<'de, K, V, S, Context> BorrowDecode<'de, Context> for HashMap<K, V, S>
692where
693    K: BorrowDecode<'de, Context> + Eq + std::hash::Hash,
694    V: BorrowDecode<'de, Context>,
695    S: std::hash::BuildHasher + Default,
696{
697    #[inline]
698    fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
699        decoder: &mut D
700    ) -> Result<Self, DecodeError> {
701        let len = decoder.decode_map_len()?;
702        let is_bincode = matches!(
703            <D::C as crate::config::InternalFormatConfig>::FORMAT,
704            crate::config::Format::Bincode | crate::config::Format::BincodeDeterministic
705        );
706        let is_deterministic = matches!(
707            <D::C as crate::config::InternalFormatConfig>::FORMAT,
708            crate::config::Format::BincodeDeterministic
709        );
710        if !is_bincode && len == usize::MAX {
711            let mut map = Self::with_hasher(S::default());
712            while decoder.reader().peek_u8() != Some(0xFF) {
713                let k = K::borrow_decode(decoder)?;
714                let v = V::borrow_decode(decoder)?;
715                map.insert(k, v);
716            }
717            decoder.reader().read_u8()?; // consume 0xFF
718            return Ok(map);
719        }
720        decoder.claim_container_read::<(K, V)>(len)?;
721
722        let hash_builder: S = Default::default();
723        let mut map = Self::with_capacity_and_hasher(len, hash_builder);
724        for _ in 0..len {
725            decoder.unclaim_bytes_read(core::mem::size_of::<(K, V)>());
726            let k = K::borrow_decode(decoder)?;
727            let v = V::borrow_decode(decoder)?;
728            if is_deterministic {
729                if map.insert(k, v).is_some() {
730                    return crate::error::cold_decode_error_duplicate_map_key();
731                }
732            } else {
733                map.insert(k, v);
734            }
735        }
736        Ok(map)
737    }
738}
739
740impl<Context, T, S> Decode<Context> for HashSet<T, S>
741where
742    T: Decode<Context> + Eq + Hash,
743    S: std::hash::BuildHasher + Default,
744{
745    #[inline]
746    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
747        let len = decoder.decode_slice_len()?;
748        let is_bincode = matches!(
749            <D::C as crate::config::InternalFormatConfig>::FORMAT,
750            crate::config::Format::Bincode | crate::config::Format::BincodeDeterministic
751        );
752        let is_deterministic = matches!(
753            <D::C as crate::config::InternalFormatConfig>::FORMAT,
754            crate::config::Format::BincodeDeterministic
755        );
756        if !is_bincode && len == usize::MAX {
757            let mut map = Self::with_hasher(S::default());
758            while decoder.reader().peek_u8() != Some(0xFF) {
759                let key = T::decode(decoder)?;
760                map.insert(key);
761            }
762            decoder.reader().read_u8()?; // consume 0xFF
763            return Ok(map);
764        }
765        decoder.claim_container_read::<T>(len)?;
766
767        let hash_builder: S = Default::default();
768        let mut map: Self = Self::with_capacity_and_hasher(len, hash_builder);
769        for _ in 0..len {
770            decoder.unclaim_bytes_read(core::mem::size_of::<T>());
771            let key = T::decode(decoder)?;
772            if is_deterministic {
773                if !map.insert(key) {
774                    return crate::error::cold_decode_error_duplicate_map_key();
775                }
776            } else {
777                map.insert(key);
778            }
779        }
780        Ok(map)
781    }
782}
783
784impl<'de, T, S, Context> BorrowDecode<'de, Context> for HashSet<T, S>
785where
786    T: BorrowDecode<'de, Context> + Eq + Hash,
787    S: std::hash::BuildHasher + Default,
788{
789    #[inline]
790    fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
791        decoder: &mut D
792    ) -> Result<Self, DecodeError> {
793        let len = decoder.decode_slice_len()?;
794        let is_bincode = matches!(
795            <D::C as crate::config::InternalFormatConfig>::FORMAT,
796            crate::config::Format::Bincode | crate::config::Format::BincodeDeterministic
797        );
798        let is_deterministic = matches!(
799            <D::C as crate::config::InternalFormatConfig>::FORMAT,
800            crate::config::Format::BincodeDeterministic
801        );
802        if !is_bincode && len == usize::MAX {
803            let mut map = Self::with_hasher(S::default());
804            while decoder.reader().peek_u8() != Some(0xFF) {
805                let key = T::borrow_decode(decoder)?;
806                map.insert(key);
807            }
808            decoder.reader().read_u8()?; // consume 0xFF
809            return Ok(map);
810        }
811        decoder.claim_container_read::<T>(len)?;
812
813        let mut map = Self::with_capacity_and_hasher(len, S::default());
814        for _ in 0..len {
815            decoder.unclaim_bytes_read(core::mem::size_of::<T>());
816            let key = T::borrow_decode(decoder)?;
817            if is_deterministic {
818                if !map.insert(key) {
819                    return crate::error::cold_decode_error_duplicate_map_key();
820                }
821            } else {
822                map.insert(key);
823            }
824        }
825        Ok(map)
826    }
827}
828
829impl<T, S> Encode for HashSet<T, S>
830where
831    T: Encode,
832{
833    #[inline(always)]
834    fn encode<E: Encoder>(
835        &self,
836        encoder: &mut E,
837    ) -> Result<(), EncodeError> {
838        use crate::config::Format;
839        let format = <E::C as crate::config::InternalFormatConfig>::FORMAT;
840        if format == Format::CborDeterministic {
841            crate::enc::cbor::encode_slice_deterministic::<E, _, _>(encoder, self.iter())
842        } else if format == Format::BincodeDeterministic {
843            #[cfg(feature = "alloc")]
844            return crate::enc::deterministic::encode_slice_deterministic::<E, _, _>(
845                encoder,
846                self.iter(),
847            );
848            #[cfg(not(feature = "alloc"))]
849            return crate::error::cold_encode_error_other(
850                "Deterministic encoding requires the 'alloc' feature",
851            );
852        } else {
853            encoder.encode_slice_len(self.len())?;
854            for item in self {
855                item.encode(encoder)?;
856            }
857            Ok(())
858        }
859    }
860}
bincode_next/features/impl_std.rs

bincode_next/features/
impl_std.rs
