/rust/registry/src/index.crates.io-6f17d22bba15001f/serde_bytes-0.11.17/src/ser.rs

Source (jump to first uncovered line)
use crate::{ByteArray, Bytes};
use serde::Serializer;

#[cfg(any(feature = "std", feature = "alloc"))]
use crate::ByteBuf;

#[cfg(feature = "alloc")]
use alloc::borrow::Cow;
#[cfg(all(feature = "std", not(feature = "alloc")))]
use std::borrow::Cow;

#[cfg(feature = "alloc")]
use alloc::boxed::Box;

#[cfg(feature = "alloc")]
use alloc::vec::Vec;

/// Types that can be serialized via `#[serde(with = "serde_bytes")]`.
pub trait Serialize {
    #[allow(missing_docs)]
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer;
}

impl Serialize for [u8] {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        serializer.serialize_bytes(self)
    }
}

#[cfg(any(feature = "std", feature = "alloc"))]
impl Serialize for Vec<u8> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        serializer.serialize_bytes(self)
    }
}

impl Serialize for Bytes {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        serializer.serialize_bytes(self)
    }
}

impl<const N: usize> Serialize for [u8; N] {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        serializer.serialize_bytes(self)
    }
}

impl<const N: usize> Serialize for ByteArray<N> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        serializer.serialize_bytes(&**self)
    }
}

#[cfg(any(feature = "std", feature = "alloc"))]
impl Serialize for ByteBuf {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        serializer.serialize_bytes(self)
    }
}

#[cfg(any(feature = "std", feature = "alloc"))]
impl<'a> Serialize for Cow<'a, [u8]> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        serializer.serialize_bytes(self)
    }
}

#[cfg(any(feature = "std", feature = "alloc"))]
impl<'a> Serialize for Cow<'a, Bytes> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        serializer.serialize_bytes(self)
    }
}

impl<T> Serialize for &T
where
    T: ?Sized + Serialize,
{
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        (**self).serialize(serializer)
    }
}

#[cfg(any(feature = "std", feature = "alloc"))]
impl<T> Serialize for Box<T>
where
    T: ?Sized + Serialize,
{
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        (**self).serialize(serializer)
    }
}

impl<T> Serialize for Option<T>
where
    T: Serialize,
{
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        struct AsBytes<T>(T);

        impl<T> serde::Serialize for AsBytes<T>
        where
            T: Serialize,
        {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
            where
                S: Serializer,
            {
                self.0.serialize(serializer)
            }
        }

        match self {
            Some(b) => serializer.serialize_some(&AsBytes(b)),
            None => serializer.serialize_none(),
        }
    }
}

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

Coverage Report

Created: 2025-07-18 06:16