serde_bytes/
ser.rs

1#[cfg(feature = "alloc")]
2use alloc::borrow::Cow;
3#[cfg(feature = "alloc")]
4use alloc::boxed::Box;
5#[cfg(feature = "alloc")]
6use alloc::vec::Vec;
7#[cfg(all(feature = "std", not(feature = "alloc")))]
8use std::borrow::Cow;
9
10use serde::Serializer;
11
12#[cfg(any(feature = "std", feature = "alloc"))]
13use crate::ByteBuf;
14use crate::{ByteArray, Bytes};
15
16/// Types that can be serialized via `#[serde(with = "serde_bytes")]`.
17pub trait Serialize {
18    #[allow(missing_docs)]
19    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
20    where
21        S: Serializer;
22}
23
24impl Serialize for [u8] {
25    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
26    where
27        S: Serializer,
28    {
29        serializer.serialize_bytes(self)
30    }
31}
32
33#[cfg(any(feature = "std", feature = "alloc"))]
34impl Serialize for Vec<u8> {
35    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
36    where
37        S: Serializer,
38    {
39        serializer.serialize_bytes(self)
40    }
41}
42
43impl Serialize for Bytes {
44    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
45    where
46        S: Serializer,
47    {
48        serializer.serialize_bytes(self)
49    }
50}
51
52impl<const N: usize> Serialize for [u8; N] {
53    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
54    where
55        S: Serializer,
56    {
57        serializer.serialize_bytes(self)
58    }
59}
60
61impl<const N: usize> Serialize for ByteArray<N> {
62    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
63    where
64        S: Serializer,
65    {
66        serializer.serialize_bytes(&**self)
67    }
68}
69
70#[cfg(any(feature = "std", feature = "alloc"))]
71impl Serialize for ByteBuf {
72    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
73    where
74        S: Serializer,
75    {
76        serializer.serialize_bytes(self)
77    }
78}
79
80#[cfg(any(feature = "std", feature = "alloc"))]
81impl<'a> Serialize for Cow<'a, [u8]> {
82    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
83    where
84        S: Serializer,
85    {
86        serializer.serialize_bytes(self)
87    }
88}
89
90#[cfg(any(feature = "std", feature = "alloc"))]
91impl<'a> Serialize for Cow<'a, Bytes> {
92    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
93    where
94        S: Serializer,
95    {
96        serializer.serialize_bytes(self)
97    }
98}
99
100impl<T> Serialize for &T
101where
102    T: ?Sized + Serialize,
103{
104    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
105    where
106        S: Serializer,
107    {
108        (**self).serialize(serializer)
109    }
110}
111
112#[cfg(any(feature = "std", feature = "alloc"))]
113impl<T> Serialize for Box<T>
114where
115    T: ?Sized + Serialize,
116{
117    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
118    where
119        S: Serializer,
120    {
121        (**self).serialize(serializer)
122    }
123}
124
125impl<T> Serialize for Option<T>
126where
127    T: Serialize,
128{
129    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
130    where
131        S: Serializer,
132    {
133        struct AsBytes<T>(T);
134
135        impl<T> serde::Serialize for AsBytes<T>
136        where
137            T: Serialize,
138        {
139            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
140            where
141                S: Serializer,
142            {
143                self.0.serialize(serializer)
144            }
145        }
146
147        match self {
148            Some(b) => serializer.serialize_some(&AsBytes(b)),
149            None => serializer.serialize_none(),
150        }
151    }
152}
serde_bytes/ser.rs

serde_bytes/
ser.rs
