serde_bytes/
ser.rs

1use crate::Bytes;
2use serde::Serializer;
3
4#[cfg(any(feature = "std", feature = "alloc"))]
5use crate::ByteBuf;
6
7#[cfg(feature = "alloc")]
8use alloc::borrow::Cow;
9#[cfg(all(feature = "std", not(feature = "alloc")))]
10use std::borrow::Cow;
11
12#[cfg(feature = "alloc")]
13use alloc::boxed::Box;
14
15#[cfg(feature = "alloc")]
16use alloc::vec::Vec;
17
18/// Types that can be serialized via `#[serde(with = "serde_bytes")]`.
19pub trait Serialize {
20    #[allow(missing_docs)]
21    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
22    where
23        S: Serializer;
24}
25
26impl Serialize for [u8] {
27    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
28    where
29        S: Serializer,
30    {
31        serializer.serialize_bytes(self)
32    }
33}
34
35#[cfg(any(feature = "std", feature = "alloc"))]
36impl Serialize for Vec<u8> {
37    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
38    where
39        S: Serializer,
40    {
41        serializer.serialize_bytes(self)
42    }
43}
44
45impl Serialize for Bytes {
46    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
47    where
48        S: Serializer,
49    {
50        serializer.serialize_bytes(self)
51    }
52}
53
54#[cfg(any(feature = "std", feature = "alloc"))]
55impl Serialize for ByteBuf {
56    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
57    where
58        S: Serializer,
59    {
60        serializer.serialize_bytes(self)
61    }
62}
63
64#[cfg(any(feature = "std", feature = "alloc"))]
65impl<'a> Serialize for Cow<'a, [u8]> {
66    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
67    where
68        S: Serializer,
69    {
70        serializer.serialize_bytes(self)
71    }
72}
73
74#[cfg(any(feature = "std", feature = "alloc"))]
75impl<'a> Serialize for Cow<'a, Bytes> {
76    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
77    where
78        S: Serializer,
79    {
80        serializer.serialize_bytes(self)
81    }
82}
83
84impl<'a, T> Serialize for &'a T
85where
86    T: ?Sized + Serialize,
87{
88    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
89    where
90        S: Serializer,
91    {
92        (**self).serialize(serializer)
93    }
94}
95
96#[cfg(any(feature = "std", feature = "alloc"))]
97impl<T> Serialize for Box<T>
98where
99    T: ?Sized + Serialize,
100{
101    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
102    where
103        S: Serializer,
104    {
105        (**self).serialize(serializer)
106    }
107}