Skip to content

Commit 6a14f76

Browse files
dtolnaydtolnay
committed
Provide trait impl for types that can be used with serde_bytes
1 parent f8c4812 commit 6a14f76

File tree

3 files changed

+223
-10
lines changed

3 files changed

+223
-10
lines changed

‎src/de.rs‎

Lines changed: 105 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,105 @@
1+
use crate::Bytes;
2+
use serde::Deserializer;
3+
4+
#[cfg(any(feature = "std", feature = "alloc"))]
5+
use crate::ByteBuf;
6+
7+
#[cfg(feature = "alloc")]
8+
use alloc::borrow::Cow;
9+
#[cfg(all(feature = "std", not(feature = "alloc")))]
10+
use std::borrow::Cow;
11+
12+
#[cfg(feature = "alloc")]
13+
use alloc::boxed::Box;
14+
15+
#[cfg(feature = "alloc")]
16+
use alloc::vec::Vec;
17+
18+
/// Types that can be deserialized via `#[serde(with = "serde_bytes")]`.
19+
pub trait Deserialize<'de>: Sized {
20+
#[allow(missing_docs)]
21+
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
22+
where
23+
D: Deserializer<'de>;
24+
}
25+
26+
impl<'de: 'a, 'a> Deserialize<'de> for &'a [u8] {
27+
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
28+
where
29+
D: Deserializer<'de>,
30+
{
31+
// Via the serde::Deserialize impl for &[u8].
32+
serde::Deserialize::deserialize(deserializer)
33+
}
34+
}
35+
36+
#[cfg(any(feature = "std", feature = "alloc"))]
37+
impl<'de> Deserialize<'de> for Vec<u8> {
38+
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
39+
where
40+
D: Deserializer<'de>,
41+
{
42+
Deserialize::deserialize(deserializer).map(ByteBuf::into_inner)
43+
}
44+
}
45+
46+
impl<'de: 'a, 'a> Deserialize<'de> for &'a Bytes {
47+
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
48+
where
49+
D: Deserializer<'de>,
50+
{
51+
Deserialize::deserialize(deserializer).map(Bytes::new)
52+
}
53+
}
54+
55+
#[cfg(any(feature = "std", feature = "alloc"))]
56+
impl<'de> Deserialize<'de> for ByteBuf {
57+
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
58+
where
59+
D: Deserializer<'de>,
60+
{
61+
// Via the serde::Deserialize impl for ByteBuf.
62+
serde::Deserialize::deserialize(deserializer)
63+
}
64+
}
65+
66+
#[cfg(any(feature = "std", feature = "alloc"))]
67+
impl<'de: 'a, 'a> Deserialize<'de> for Cow<'a, [u8]> {
68+
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
69+
where
70+
D: Deserializer<'de>,
71+
{
72+
Deserialize::deserialize(deserializer).map(Cow::Borrowed)
73+
}
74+
}
75+
76+
#[cfg(any(feature = "std", feature = "alloc"))]
77+
impl<'de: 'a, 'a> Deserialize<'de> for Cow<'a, Bytes> {
78+
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
79+
where
80+
D: Deserializer<'de>,
81+
{
82+
Deserialize::deserialize(deserializer).map(Cow::Borrowed)
83+
}
84+
}
85+
86+
#[cfg(any(feature = "std", feature = "alloc"))]
87+
impl<'de> Deserialize<'de> for Box<[u8]> {
88+
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
89+
where
90+
D: Deserializer<'de>,
91+
{
92+
Deserialize::deserialize(deserializer).map(Vec::into_boxed_slice)
93+
}
94+
}
95+
96+
#[cfg(any(feature = "std", feature = "alloc"))]
97+
impl<'de> Deserialize<'de> for Box<Bytes> {
98+
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
99+
where
100+
D: Deserializer<'de>,
101+
{
102+
let bytes: Box<[u8]> = Deserialize::deserialize(deserializer)?;
103+
Ok(unsafe { Box::from_raw(Box::into_raw(bytes) as *mut Bytes) })
104+
}
105+
}

‎src/lib.rs‎

Lines changed: 11 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -38,25 +38,26 @@
3838
#![deny(missing_docs)]
3939

4040
mod bytes;
41+
mod de;
42+
mod ser;
4143

4244
#[cfg(any(feature = "std", feature = "alloc"))]
4345
mod bytebuf;
4446

4547
#[cfg(feature = "alloc")]
4648
extern crate alloc;
4749

48-
#[cfg(feature = "alloc")]
49-
use alloc::vec::Vec;
50-
5150
#[cfg(any(feature = "std", feature = "alloc"))]
52-
use serde::{Deserialize, Deserializer};
51+
use serde::Deserializer;
5352

5453
use serde::Serializer;
5554

56-
pub use self::bytes::Bytes;
55+
pub use crate::bytes::Bytes;
56+
pub use crate::de::Deserialize;
57+
pub use crate::ser::Serialize;
5758

5859
#[cfg(any(feature = "std", feature = "alloc"))]
59-
pub use self::bytebuf::ByteBuf;
60+
pub use crate::bytebuf::ByteBuf;
6061

6162
/// Serde `serialize_with` function to serialize bytes efficiently.
6263
///
@@ -80,10 +81,10 @@ pub use self::bytebuf::ByteBuf;
8081
/// ```
8182
pub fn serialize<T, S>(bytes: &T, serializer: S) -> Result<S::Ok, S::Error>
8283
where
83-
T: ?Sized + AsRef<[u8]>,
84+
T: Serialize,
8485
S: Serializer,
8586
{
86-
serializer.serialize_bytes(bytes.as_ref())
87+
Serialize::serialize(bytes, serializer)
8788
}
8889

8990
/// Serde `deserialize_with` function to deserialize bytes efficiently.
@@ -106,8 +107,8 @@ where
106107
#[cfg(any(feature = "std", feature = "alloc"))]
107108
pub fn deserialize<'de, T, D>(deserializer: D) -> Result<T, D::Error>
108109
where
109-
T: From<Vec<u8>>,
110+
T: Deserialize<'de>,
110111
D: Deserializer<'de>,
111112
{
112-
ByteBuf::deserialize(deserializer).map(|buf| buf.into_inner().into())
113+
Deserialize::deserialize(deserializer)
113114
}

‎src/ser.rs‎

Lines changed: 107 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,107 @@
1+
use crate::Bytes;
2+
use serde::Serializer;
3+
4+
#[cfg(any(feature = "std", feature = "alloc"))]
5+
use crate::ByteBuf;
6+
7+
#[cfg(feature = "alloc")]
8+
use alloc::borrow::Cow;
9+
#[cfg(all(feature = "std", not(feature = "alloc")))]
10+
use std::borrow::Cow;
11+
12+
#[cfg(feature = "alloc")]
13+
use alloc::boxed::Box;
14+
15+
#[cfg(feature = "alloc")]
16+
use alloc::vec::Vec;
17+
18+
/// Types that can be serialized via `#[serde(with = "serde_bytes")]`.
19+
pub 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+
26+
impl 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"))]
36+
impl 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+
45+
impl 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"))]
55+
impl 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"))]
65+
impl<'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"))]
75+
impl<'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+
84+
impl<'a, T> Serialize for &'a T
85+
where
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"))]
97+
impl<T> Serialize for Box<T>
98+
where
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+
}

0 commit comments

Comments
 (0)