serde_bytes/
ser.rs

1use crate::{ByteArray, 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
54impl<const N: usize> Serialize for [u8; N] {
55    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
56    where
57        S: Serializer,
58    {
59        serializer.serialize_bytes(self)
60    }
61}
62
63impl<const N: usize> Serialize for ByteArray<N> {
64    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
65    where
66        S: Serializer,
67    {
68        serializer.serialize_bytes(&**self)
69    }
70}
71
72#[cfg(any(feature = "std", feature = "alloc"))]
73impl Serialize for ByteBuf {
74    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
75    where
76        S: Serializer,
77    {
78        serializer.serialize_bytes(self)
79    }
80}
81
82#[cfg(any(feature = "std", feature = "alloc"))]
83impl<'a> Serialize for Cow<'a, [u8]> {
84    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
85    where
86        S: Serializer,
87    {
88        serializer.serialize_bytes(self)
89    }
90}
91
92#[cfg(any(feature = "std", feature = "alloc"))]
93impl<'a> Serialize for Cow<'a, Bytes> {
94    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
95    where
96        S: Serializer,
97    {
98        serializer.serialize_bytes(self)
99    }
100}
101
102impl<'a, T> Serialize for &'a T
103where
104    T: ?Sized + Serialize,
105{
106    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
107    where
108        S: Serializer,
109    {
110        (**self).serialize(serializer)
111    }
112}
113
114#[cfg(any(feature = "std", feature = "alloc"))]
115impl<T> Serialize for Box<T>
116where
117    T: ?Sized + Serialize,
118{
119    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
120    where
121        S: Serializer,
122    {
123        (**self).serialize(serializer)
124    }
125}
126
127impl<T> Serialize for Option<T>
128where
129    T: Serialize,
130{
131    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
132    where
133        S: Serializer,
134    {
135        struct AsBytes<T>(T);
136
137        impl<T> serde::Serialize for AsBytes<T>
138        where
139            T: Serialize,
140        {
141            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
142            where
143                S: Serializer,
144            {
145                self.0.serialize(serializer)
146            }
147        }
148
149        match self {
150            Some(b) => serializer.serialize_some(&AsBytes(b)),
151            None => serializer.serialize_none(),
152        }
153    }
154}
serde_bytes/ser.rs

serde_bytes/
ser.rs
