serde/ser/
fmt.rs

1use crate::lib::*;
2use crate::ser::{Error, Impossible, Serialize, Serializer};
3
4impl Error for fmt::Error {
5    fn custom<T: Display>(_msg: T) -> Self {
6        fmt::Error
7    }
8}
9
10macro_rules! fmt_primitives {
11    ($($f:ident: $t:ty,)*) => {
12        $(
13            fn $f(self, v: $t) -> fmt::Result {
14                Display::fmt(&v, self)
15            }
16        )*
17    };
18}
19
20/// ```edition2021
21/// use serde::ser::Serialize;
22/// use serde_derive::Serialize;
23/// use std::fmt::{self, Display};
24///
25/// #[derive(Serialize)]
26/// #[serde(rename_all = "kebab-case")]
27/// pub enum MessageType {
28///     StartRequest,
29///     EndRequest,
30/// }
31///
32/// impl Display for MessageType {
33///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
34///         self.serialize(f)
35///     }
36/// }
37/// ```
38impl<'a> Serializer for &mut fmt::Formatter<'a> {
39    type Ok = ();
40    type Error = fmt::Error;
41    type SerializeSeq = Impossible<(), fmt::Error>;
42    type SerializeTuple = Impossible<(), fmt::Error>;
43    type SerializeTupleStruct = Impossible<(), fmt::Error>;
44    type SerializeTupleVariant = Impossible<(), fmt::Error>;
45    type SerializeMap = Impossible<(), fmt::Error>;
46    type SerializeStruct = Impossible<(), fmt::Error>;
47    type SerializeStructVariant = Impossible<(), fmt::Error>;
48
49    fmt_primitives! {
50        serialize_bool: bool,
51        serialize_i8: i8,
52        serialize_i16: i16,
53        serialize_i32: i32,
54        serialize_i64: i64,
55        serialize_i128: i128,
56        serialize_u8: u8,
57        serialize_u16: u16,
58        serialize_u32: u32,
59        serialize_u64: u64,
60        serialize_u128: u128,
61        serialize_f32: f32,
62        serialize_f64: f64,
63        serialize_char: char,
64        serialize_str: &str,
65        serialize_unit_struct: &'static str,
66    }
67
68    fn serialize_unit_variant(
69        self,
70        _name: &'static str,
71        _variant_index: u32,
72        variant: &'static str,
73    ) -> fmt::Result {
74        Display::fmt(variant, self)
75    }
76
77    fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> fmt::Result
78    where
79        T: ?Sized + Serialize,
80    {
81        Serialize::serialize(value, self)
82    }
83
84    fn serialize_bytes(self, _v: &[u8]) -> fmt::Result {
85        Err(fmt::Error)
86    }
87
88    fn serialize_none(self) -> fmt::Result {
89        Err(fmt::Error)
90    }
91
92    fn serialize_some<T>(self, _value: &T) -> fmt::Result
93    where
94        T: ?Sized + Serialize,
95    {
96        Err(fmt::Error)
97    }
98
99    fn serialize_unit(self) -> fmt::Result {
100        Err(fmt::Error)
101    }
102
103    fn serialize_newtype_variant<T>(
104        self,
105        _name: &'static str,
106        _variant_index: u32,
107        _variant: &'static str,
108        _value: &T,
109    ) -> fmt::Result
110    where
111        T: ?Sized + Serialize,
112    {
113        Err(fmt::Error)
114    }
115
116    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, fmt::Error> {
117        Err(fmt::Error)
118    }
119
120    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, fmt::Error> {
121        Err(fmt::Error)
122    }
123
124    fn serialize_tuple_struct(
125        self,
126        _name: &'static str,
127        _len: usize,
128    ) -> Result<Self::SerializeTupleStruct, fmt::Error> {
129        Err(fmt::Error)
130    }
131
132    fn serialize_tuple_variant(
133        self,
134        _name: &'static str,
135        _variant_index: u32,
136        _variant: &'static str,
137        _len: usize,
138    ) -> Result<Self::SerializeTupleVariant, fmt::Error> {
139        Err(fmt::Error)
140    }
141
142    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, fmt::Error> {
143        Err(fmt::Error)
144    }
145
146    fn serialize_struct(
147        self,
148        _name: &'static str,
149        _len: usize,
150    ) -> Result<Self::SerializeStruct, fmt::Error> {
151        Err(fmt::Error)
152    }
153
154    fn serialize_struct_variant(
155        self,
156        _name: &'static str,
157        _variant_index: u32,
158        _variant: &'static str,
159        _len: usize,
160    ) -> Result<Self::SerializeStructVariant, fmt::Error> {
161        Err(fmt::Error)
162    }
163
164    fn collect_str<T>(self, value: &T) -> fmt::Result
165    where
166        T: ?Sized + Display,
167    {
168        Display::fmt(value, self)
169    }
170}
serde/ser/fmt.rs

serde/ser/
fmt.rs
