bincode/features/
impl_alloc.rs

1use crate::{
2    BorrowDecode, Config,
3    de::{BorrowDecoder, Decode, Decoder, read::Reader},
4    enc::{
5        self, Encode, Encoder,
6        write::{SizeWriter, Writer},
7    },
8    error::{DecodeError, EncodeError},
9    impl_borrow_decode,
10};
11use alloc::{
12    borrow::{Cow, ToOwned},
13    boxed::Box,
14    collections::*,
15    rc::Rc,
16    string::String,
17    vec::Vec,
18};
19
20#[cfg(target_has_atomic = "ptr")]
21use alloc::sync::Arc;
22
23#[derive(Default)]
24pub(crate) struct VecWriter {
25    inner: Vec<u8>,
26}
27
28impl VecWriter {
29    /// Create a new vec writer with the given capacity
30    pub fn with_capacity(cap: usize) -> Self {
31        Self {
32            inner: Vec::with_capacity(cap),
33        }
34    }
35    // May not be used in all feature combinations
36    #[allow(dead_code)]
37    pub(crate) fn collect(self) -> Vec<u8> {
38        self.inner
39    }
40}
41
42impl enc::write::Writer for VecWriter {
43    #[inline(always)]
44    fn write(&mut self, bytes: &[u8]) -> Result<(), EncodeError> {
45        self.inner.extend_from_slice(bytes);
46        Ok(())
47    }
48}
49
50/// Encode the given value into a `Vec<u8>` with the given `Config`. See the [config] module for more information.
51///
52/// [config]: config/index.html
53#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
54pub fn encode_to_vec<E: enc::Encode, C: Config>(val: E, config: C) -> Result<Vec<u8>, EncodeError> {
55    let size = {
56        let mut size_writer = enc::EncoderImpl::<_, C>::new(SizeWriter::default(), config);
57        val.encode(&mut size_writer)?;
58        size_writer.into_writer().bytes_written
59    };
60    let writer = VecWriter::with_capacity(size);
61    let mut encoder = enc::EncoderImpl::<_, C>::new(writer, config);
62    val.encode(&mut encoder)?;
63    Ok(encoder.into_writer().inner)
64}
65
66impl<Context, T> Decode<Context> for BinaryHeap<T>
67where
68    T: Decode<Context> + Ord,
69{
70    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
71        Ok(Vec::<T>::decode(decoder)?.into())
72    }
73}
74impl<'de, T, Context> BorrowDecode<'de, Context> for BinaryHeap<T>
75where
76    T: BorrowDecode<'de, Context> + Ord,
77{
78    fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
79        decoder: &mut D,
80    ) -> Result<Self, DecodeError> {
81        Ok(Vec::<T>::borrow_decode(decoder)?.into())
82    }
83}
84
85impl<T> Encode for BinaryHeap<T>
86where
87    T: Encode + Ord,
88{
89    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
90        self.as_slice().encode(encoder)
91    }
92}
93
94impl<Context, K, V> Decode<Context> for BTreeMap<K, V>
95where
96    K: Decode<Context> + Ord,
97    V: Decode<Context>,
98{
99    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
100        let len = crate::de::decode_slice_len(decoder)?;
101        decoder.claim_container_read::<(K, V)>(len)?;
102
103        let mut map = BTreeMap::new();
104        for _ in 0..len {
105            // See the documentation on `unclaim_bytes_read` as to why we're doing this here
106            decoder.unclaim_bytes_read(core::mem::size_of::<(K, V)>());
107
108            let key = K::decode(decoder)?;
109            let value = V::decode(decoder)?;
110            map.insert(key, value);
111        }
112        Ok(map)
113    }
114}
115impl<'de, K, V, Context> BorrowDecode<'de, Context> for BTreeMap<K, V>
116where
117    K: BorrowDecode<'de, Context> + Ord,
118    V: BorrowDecode<'de, Context>,
119{
120    fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
121        decoder: &mut D,
122    ) -> Result<Self, DecodeError> {
123        let len = crate::de::decode_slice_len(decoder)?;
124        decoder.claim_container_read::<(K, V)>(len)?;
125
126        let mut map = BTreeMap::new();
127        for _ in 0..len {
128            // See the documentation on `unclaim_bytes_read` as to why we're doing this here
129            decoder.unclaim_bytes_read(core::mem::size_of::<(K, V)>());
130
131            let key = K::borrow_decode(decoder)?;
132            let value = V::borrow_decode(decoder)?;
133            map.insert(key, value);
134        }
135        Ok(map)
136    }
137}
138
139impl<K, V> Encode for BTreeMap<K, V>
140where
141    K: Encode + Ord,
142    V: Encode,
143{
144    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
145        crate::enc::encode_slice_len(encoder, self.len())?;
146        for (key, val) in self.iter() {
147            key.encode(encoder)?;
148            val.encode(encoder)?;
149        }
150        Ok(())
151    }
152}
153
154impl<Context, T> Decode<Context> for BTreeSet<T>
155where
156    T: Decode<Context> + Ord,
157{
158    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
159        let len = crate::de::decode_slice_len(decoder)?;
160        decoder.claim_container_read::<T>(len)?;
161
162        let mut map = BTreeSet::new();
163        for _ in 0..len {
164            // See the documentation on `unclaim_bytes_read` as to why we're doing this here
165            decoder.unclaim_bytes_read(core::mem::size_of::<T>());
166
167            let key = T::decode(decoder)?;
168            map.insert(key);
169        }
170        Ok(map)
171    }
172}
173impl<'de, T, Context> BorrowDecode<'de, Context> for BTreeSet<T>
174where
175    T: BorrowDecode<'de, Context> + Ord,
176{
177    fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
178        decoder: &mut D,
179    ) -> Result<Self, DecodeError> {
180        let len = crate::de::decode_slice_len(decoder)?;
181        decoder.claim_container_read::<T>(len)?;
182
183        let mut map = BTreeSet::new();
184        for _ in 0..len {
185            // See the documentation on `unclaim_bytes_read` as to why we're doing this here
186            decoder.unclaim_bytes_read(core::mem::size_of::<T>());
187
188            let key = T::borrow_decode(decoder)?;
189            map.insert(key);
190        }
191        Ok(map)
192    }
193}
194
195impl<T> Encode for BTreeSet<T>
196where
197    T: Encode + Ord,
198{
199    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
200        crate::enc::encode_slice_len(encoder, self.len())?;
201        for item in self.iter() {
202            item.encode(encoder)?;
203        }
204        Ok(())
205    }
206}
207
208impl<Context, T> Decode<Context> for VecDeque<T>
209where
210    T: Decode<Context>,
211{
212    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
213        Ok(Vec::<T>::decode(decoder)?.into())
214    }
215}
216impl<'de, T, Context> BorrowDecode<'de, Context> for VecDeque<T>
217where
218    T: BorrowDecode<'de, Context>,
219{
220    fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
221        decoder: &mut D,
222    ) -> Result<Self, DecodeError> {
223        Ok(Vec::<T>::borrow_decode(decoder)?.into())
224    }
225}
226
227impl<T> Encode for VecDeque<T>
228where
229    T: Encode,
230{
231    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
232        crate::enc::encode_slice_len(encoder, self.len())?;
233        if unty::type_equal::<T, u8>() {
234            let slices: (&[T], &[T]) = self.as_slices();
235            // Safety: T is u8 so turning this into `&[u8]` is okay
236            let slices: (&[u8], &[u8]) = unsafe {
237                (
238                    core::slice::from_raw_parts(slices.0.as_ptr().cast(), slices.0.len()),
239                    core::slice::from_raw_parts(slices.1.as_ptr().cast(), slices.1.len()),
240                )
241            };
242
243            encoder.writer().write(slices.0)?;
244            encoder.writer().write(slices.1)?;
245        } else {
246            for item in self.iter() {
247                item.encode(encoder)?;
248            }
249        }
250        Ok(())
251    }
252}
253
254impl<Context, T> Decode<Context> for Vec<T>
255where
256    T: Decode<Context>,
257{
258    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
259        let len = crate::de::decode_slice_len(decoder)?;
260
261        if unty::type_equal::<T, u8>() {
262            decoder.claim_container_read::<T>(len)?;
263            // optimize for reading u8 vecs
264            let mut vec = alloc::vec![0u8; len];
265            decoder.reader().read(&mut vec)?;
266            // Safety: Vec<T> is Vec<u8>
267            Ok(unsafe { core::mem::transmute::<Vec<u8>, Vec<T>>(vec) })
268        } else {
269            decoder.claim_container_read::<T>(len)?;
270
271            let mut vec = Vec::with_capacity(len);
272            for _ in 0..len {
273                // See the documentation on `unclaim_bytes_read` as to why we're doing this here
274                decoder.unclaim_bytes_read(core::mem::size_of::<T>());
275
276                vec.push(T::decode(decoder)?);
277            }
278            Ok(vec)
279        }
280    }
281}
282
283impl<'de, T, Context> BorrowDecode<'de, Context> for Vec<T>
284where
285    T: BorrowDecode<'de, Context>,
286{
287    fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
288        decoder: &mut D,
289    ) -> Result<Self, DecodeError> {
290        let len = crate::de::decode_slice_len(decoder)?;
291
292        if unty::type_equal::<T, u8>() {
293            decoder.claim_container_read::<T>(len)?;
294            // optimize for reading u8 vecs
295            let mut vec = alloc::vec![0u8; len];
296            decoder.reader().read(&mut vec)?;
297            // Safety: Vec<T> is Vec<u8>
298            Ok(unsafe { core::mem::transmute::<Vec<u8>, Vec<T>>(vec) })
299        } else {
300            decoder.claim_container_read::<T>(len)?;
301
302            let mut vec = Vec::with_capacity(len);
303            for _ in 0..len {
304                // See the documentation on `unclaim_bytes_read` as to why we're doing this here
305                decoder.unclaim_bytes_read(core::mem::size_of::<T>());
306
307                vec.push(T::borrow_decode(decoder)?);
308            }
309            Ok(vec)
310        }
311    }
312}
313
314impl<T> Encode for Vec<T>
315where
316    T: Encode,
317{
318    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
319        crate::enc::encode_slice_len(encoder, self.len())?;
320        if unty::type_equal::<T, u8>() {
321            // Safety: T == u8
322            let slice: &[u8] = unsafe { core::mem::transmute(self.as_slice()) };
323            encoder.writer().write(slice)?;
324            Ok(())
325        } else {
326            for item in self.iter() {
327                item.encode(encoder)?;
328            }
329            Ok(())
330        }
331    }
332}
333
334impl<Context> Decode<Context> for String {
335    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
336        let bytes = Vec::<u8>::decode(decoder)?;
337        String::from_utf8(bytes).map_err(|e| DecodeError::Utf8 {
338            inner: e.utf8_error(),
339        })
340    }
341}
342impl_borrow_decode!(String);
343
344impl<Context> Decode<Context> for Box<str> {
345    fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
346        String::decode(decoder).map(String::into_boxed_str)
347    }
348}
349impl_borrow_decode!(Box<str>);
350
351impl Encode for String {
352    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
353        self.as_bytes().encode(encoder)
354    }
355}
356
357impl<Context, T> Decode<Context> for Box<T>
358where
359    T: Decode<Context>,
360{
361    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
362        let t = T::decode(decoder)?;
363        Ok(Box::new(t))
364    }
365}
366impl<'de, T, Context> BorrowDecode<'de, Context> for Box<T>
367where
368    T: BorrowDecode<'de, Context>,
369{
370    fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
371        decoder: &mut D,
372    ) -> Result<Self, DecodeError> {
373        let t = T::borrow_decode(decoder)?;
374        Ok(Box::new(t))
375    }
376}
377
378impl<T> Encode for Box<T>
379where
380    T: Encode + ?Sized,
381{
382    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
383        T::encode(self, encoder)
384    }
385}
386
387impl<Context, T> Decode<Context> for Box<[T]>
388where
389    T: Decode<Context> + 'static,
390{
391    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
392        let vec = Vec::decode(decoder)?;
393        Ok(vec.into_boxed_slice())
394    }
395}
396
397impl<'de, T, Context> BorrowDecode<'de, Context> for Box<[T]>
398where
399    T: BorrowDecode<'de, Context> + 'de,
400{
401    fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
402        decoder: &mut D,
403    ) -> Result<Self, DecodeError> {
404        let vec = Vec::borrow_decode(decoder)?;
405        Ok(vec.into_boxed_slice())
406    }
407}
408
409impl<Context, T> Decode<Context> for Cow<'_, T>
410where
411    T: ToOwned + ?Sized,
412    <T as ToOwned>::Owned: Decode<Context>,
413{
414    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
415        let t = <T as ToOwned>::Owned::decode(decoder)?;
416        Ok(Cow::Owned(t))
417    }
418}
419impl<'cow, T, Context> BorrowDecode<'cow, Context> for Cow<'cow, T>
420where
421    T: ToOwned + ?Sized,
422    &'cow T: BorrowDecode<'cow, Context>,
423{
424    fn borrow_decode<D: BorrowDecoder<'cow, Context = Context>>(
425        decoder: &mut D,
426    ) -> Result<Self, DecodeError> {
427        let t = <&T>::borrow_decode(decoder)?;
428        Ok(Cow::Borrowed(t))
429    }
430}
431
432impl<T> Encode for Cow<'_, T>
433where
434    T: ToOwned + ?Sized,
435    for<'a> &'a T: Encode,
436{
437    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
438        self.as_ref().encode(encoder)
439    }
440}
441
442#[test]
443fn test_cow_round_trip() {
444    let start = Cow::Borrowed("Foo");
445    let encoded = crate::encode_to_vec(&start, crate::config::standard()).unwrap();
446    let (end, _) =
447        crate::borrow_decode_from_slice::<Cow<str>, _>(&encoded, crate::config::standard())
448            .unwrap();
449    assert_eq!(start, end);
450    let (end, _) =
451        crate::decode_from_slice::<Cow<str>, _>(&encoded, crate::config::standard()).unwrap();
452    assert_eq!(start, end);
453}
454
455impl<Context, T> Decode<Context> for Rc<T>
456where
457    T: Decode<Context>,
458{
459    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
460        let t = T::decode(decoder)?;
461        Ok(Rc::new(t))
462    }
463}
464
465impl<Context> Decode<Context> for Rc<str> {
466    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
467        let decoded = String::decode(decoder)?;
468        Ok(decoded.into())
469    }
470}
471
472impl<'de, T, Context> BorrowDecode<'de, Context> for Rc<T>
473where
474    T: BorrowDecode<'de, Context>,
475{
476    fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
477        decoder: &mut D,
478    ) -> Result<Self, DecodeError> {
479        let t = T::borrow_decode(decoder)?;
480        Ok(Rc::new(t))
481    }
482}
483
484impl<'de, Context> BorrowDecode<'de, Context> for Rc<str> {
485    fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
486        decoder: &mut D,
487    ) -> Result<Self, DecodeError> {
488        let decoded = String::decode(decoder)?;
489        Ok(decoded.into())
490    }
491}
492
493impl<T> Encode for Rc<T>
494where
495    T: Encode + ?Sized,
496{
497    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
498        T::encode(self, encoder)
499    }
500}
501
502impl<Context, T> Decode<Context> for Rc<[T]>
503where
504    T: Decode<Context> + 'static,
505{
506    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
507        let vec = Vec::decode(decoder)?;
508        Ok(vec.into())
509    }
510}
511
512impl<'de, T, Context> BorrowDecode<'de, Context> for Rc<[T]>
513where
514    T: BorrowDecode<'de, Context> + 'de,
515{
516    fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
517        decoder: &mut D,
518    ) -> Result<Self, DecodeError> {
519        let vec = Vec::borrow_decode(decoder)?;
520        Ok(vec.into())
521    }
522}
523
524#[cfg(target_has_atomic = "ptr")]
525impl<Context, T> Decode<Context> for Arc<T>
526where
527    T: Decode<Context>,
528{
529    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
530        let t = T::decode(decoder)?;
531        Ok(Arc::new(t))
532    }
533}
534
535#[cfg(target_has_atomic = "ptr")]
536impl<Context> Decode<Context> for Arc<str> {
537    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
538        let decoded = String::decode(decoder)?;
539        Ok(decoded.into())
540    }
541}
542
543#[cfg(target_has_atomic = "ptr")]
544impl<'de, T, Context> BorrowDecode<'de, Context> for Arc<T>
545where
546    T: BorrowDecode<'de, Context>,
547{
548    fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
549        decoder: &mut D,
550    ) -> Result<Self, DecodeError> {
551        let t = T::borrow_decode(decoder)?;
552        Ok(Arc::new(t))
553    }
554}
555
556#[cfg(target_has_atomic = "ptr")]
557impl<'de, Context> BorrowDecode<'de, Context> for Arc<str> {
558    fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
559        decoder: &mut D,
560    ) -> Result<Self, DecodeError> {
561        let decoded = String::decode(decoder)?;
562        Ok(decoded.into())
563    }
564}
565
566#[cfg(target_has_atomic = "ptr")]
567impl<T> Encode for Arc<T>
568where
569    T: Encode + ?Sized,
570{
571    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
572        T::encode(self, encoder)
573    }
574}
575
576#[cfg(target_has_atomic = "ptr")]
577impl<Context, T> Decode<Context> for Arc<[T]>
578where
579    T: Decode<Context> + 'static,
580{
581    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
582        let vec = Vec::decode(decoder)?;
583        Ok(vec.into())
584    }
585}
586
587#[cfg(target_has_atomic = "ptr")]
588impl<'de, T, Context> BorrowDecode<'de, Context> for Arc<[T]>
589where
590    T: BorrowDecode<'de, Context> + 'de,
591{
592    fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
593        decoder: &mut D,
594    ) -> Result<Self, DecodeError> {
595        let vec = Vec::borrow_decode(decoder)?;
596        Ok(vec.into())
597    }
598}
bincode/features/impl_alloc.rs

bincode/features/
impl_alloc.rs
