impl_serde_serialize_error/
lib.rs

1//! Crate deprecated. Use newer and more universal [impl_serialize!](https://crates.io/crates/impl_serialize) instead.
2//! This library provides a simple procedural macro for fast implementing error methods in
3//! [serde::Serializer](https://docs.rs/serde/latest/serde/trait.Serializer.html) trait.
4
5/// Implements error method for [serde::Serializer](https://docs.rs/serde/latest/serde/trait.Serializer.html)
6/// 
7/// # Examples
8///
9/// ```
10/// use impl_serde_serialize_error::impl_serde_serialize_error;
11/// use serde::ser;
12/// # use thiserror::Error;
13/// # 
14/// # #[derive(Debug, Error)]
15/// # enum SerializationError {
16/// #     #[error("Cannot serialize value")]
17/// #     CannotSerialize,
18/// #     #[error("Custom({0})")]
19/// #     Custom(String)
20/// # }
21/// # 
22/// # impl serde::ser::Error for SerializationError {
23/// #     fn custom<T>(msg:T) -> Self
24/// #     where T: std::fmt::Display
25/// #     {
26/// #         SerializationError::Custom(msg.to_string())
27/// #     }
28/// # }
29/// # 
30/// struct MySerializer;
31/// 
32/// impl ser::Serializer for MySerializer {
33/// #    type Ok = ();
34/// #    type Error = SerializationError;
35/// #
36/// #   type SerializeMap = ser::Impossible<Self::Ok, Self::Error>;
37/// #   type SerializeSeq = ser::Impossible<Self::Ok, Self::Error>;
38/// #   type SerializeStruct = ser::Impossible<Self::Ok, Self::Error>;
39/// #   type SerializeStructVariant = ser::Impossible<Self::Ok, Self::Error>;
40/// #   type SerializeTuple = ser::Impossible<Self::Ok, Self::Error>;
41/// #   type SerializeTupleStruct = ser::Impossible<Self::Ok, Self::Error>;
42/// #   type SerializeTupleVariant = ser::Impossible<Self::Ok, Self::Error>;
43/// #
44///     //for one type
45///     impl_serde_serialize_error!(SerializationError::CannotSerialize, bool);
46/// 
47///     //for many types
48///     impl_serde_serialize_error!(SerializationError::CannotSerialize, [bytes, i8, i16]);
49/// #
50/// # impl_serde_serialize_error!(
51/// #     SerializationError::CannotSerialize, [
52/// #         i32, i64,
53/// #         u8, u16, u32, u64,
54/// #         f32, f64,
55/// #         char,
56/// #         str,
57/// #         none, some, unit,
58/// #         unit_struct, unit_variant,
59/// #         newtype_struct, newtype_variant,
60/// #         seq, map,
61/// #         tuple, tuple_struct, tuple_variant,
62/// #         struct, struct_variant
63/// #     ]
64/// # );
65/// }
66/// 
67/// ```
68#[macro_export]
69macro_rules! impl_serde_serialize_error {
70    ($error:expr, [$($type:ident),+]) => {
71        $(
72            impl_serde_serialize_error!($error, $type);
73        )+
74    };
75
76    ($error:expr, bool) => {
77        fn serialize_bool(self, _v: bool) -> Result<Self::Ok, Self::Error> {
78            Err($error)
79        }
80    };
81
82    ($error:expr, i8) => {
83        fn serialize_i8(self, _v: i8) -> Result<Self::Ok, Self::Error> {
84            Err($error)
85        }
86    };
87
88    ($error:expr, i16) => {
89        fn serialize_i16(self, _v: i16) -> Result<Self::Ok, Self::Error> {
90            Err($error)
91        }
92    };
93
94    ($error:expr, i32) => {
95        fn serialize_i32(self, _v: i32) -> Result<Self::Ok, Self::Error> {
96            Err($error)
97        }
98    };
99
100    ($error:expr, i64) => {
101        fn serialize_i64(self, _v: i64) -> Result<Self::Ok, Self::Error> {
102            Err($error)
103        }
104    };
105
106    ($error:expr, u8) => {
107        fn serialize_u8(self, _v: u8) -> Result<Self::Ok, Self::Error> {
108            Err($error)
109        }
110    };
111
112    ($error:expr, u16) => {
113        fn serialize_u16(self, _v: u16) -> Result<Self::Ok, Self::Error> {
114            Err($error)
115        }
116    };
117
118    ($error:expr, u32) => {
119        fn serialize_u32(self, _v: u32) -> Result<Self::Ok, Self::Error> {
120            Err($error)
121        }
122    };
123
124    ($error:expr, u64) => {
125        fn serialize_u64(self, _v: u64) -> Result<Self::Ok, Self::Error> {
126            Err($error)
127        }
128    };
129
130    ($error:expr, f32) => {
131        fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> {
132            Err($error)
133        }
134    };
135
136    ($error:expr, f64) => {
137        fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Self::Error> {
138            Err($error)
139        }
140    };
141
142    ($error:expr, char) => {
143        fn serialize_char(self, _v: char) -> Result<Self::Ok, Self::Error> {
144            Err($error)
145        }
146    };
147
148    ($error:expr, str) => {
149        fn serialize_str(self, _v: &str) -> Result<Self::Ok, Self::Error> {
150            Err($error)
151        }
152    };
153
154    ($error:expr, bytes) => {
155        fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> {
156            Err($error)
157        }
158    };
159
160    ($error:expr, none) => {
161        fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
162            Err($error)
163        }
164    };
165
166    ($error:expr, unit) => {
167        fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
168            Err($error)
169        }
170    };
171
172    ($error:expr, some) => {
173        fn serialize_some<T: ?Sized + serde::ser::Serialize>(self, _value: &T) -> Result<Self::Ok, Self::Error> {
174            Err($error)
175        }
176    };
177
178    ($error:expr, unit_struct) => {
179        fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
180            Err($error)
181        }
182    };
183
184    ($error:expr, unit_variant) => {
185        fn serialize_unit_variant(self, _name: &'static str, _variant_index: u32, _variant: &'static str) -> Result<Self::Ok, Self::Error> {
186            Err($error)
187        }
188    };
189
190    ($error:expr, newtype_struct) => {
191        fn serialize_newtype_struct<T: ?Sized + serde::ser::Serialize>(self, _name: &'static str, _value: &T) -> Result<Self::Ok, Self::Error> {
192            Err($error)
193        }
194    };
195
196    ($error:expr, newtype_variant) => {
197        fn serialize_newtype_variant<T: ?Sized + serde::ser::Serialize>(self, _name: &'static str, _variant_index: u32, _variant: &'static str, _value: &T) -> Result<Self::Ok, Self::Error> {
198            Err($error)
199        }
200    };
201
202    ($error:expr, seq) => {
203        fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
204            Err($error)
205        }
206    };
207
208    ($error:expr, tuple) => {
209        fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
210            Err($error)
211        }
212    };
213
214    ($error:expr, tuple_struct) => {
215        fn serialize_tuple_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeTupleStruct, Self::Error> {
216            Err($error)
217        }
218    };
219
220    ($error:expr, tuple_variant) => {
221        fn serialize_tuple_variant(self, _name: &'static str, _variant_index: u32, _variant: &'static str, _len: usize) -> Result<Self::SerializeTupleVariant, Self::Error> {
222            Err($error)
223        }
224    };
225
226    ($error:expr, map) => {
227        fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
228            Err($error)
229        }
230    };
231
232    ($error:expr, struct) => {
233        fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct, Self::Error> {
234            Err($error)
235        }
236    };
237
238    ($error:expr, struct_variant) => {
239        fn serialize_struct_variant(self, _name: &'static str, _variant_index: u32, _variant: &'static str, _len: usize) -> Result<Self::SerializeStructVariant, Self::Error> {
240            Err($error)
241        }
242    };
243}
244
245#[cfg(test)]
246mod tests {
247    use serde::ser;
248    use thiserror::Error;
249
250    #[derive(Debug, Error)]
251    enum SerializationError {
252        #[error("Cannot serialize value")]
253        CannotSerialize,
254        #[error("Custom({0})")]
255        Custom(String)
256    }
257
258    impl serde::ser::Error for SerializationError {
259        fn custom<T>(msg:T) -> Self
260        where T: std::fmt::Display
261        {
262            SerializationError::Custom(msg.to_string())
263        }
264    }
265
266    #[test]
267    fn all_errors() {
268        struct MySerializer;
269
270        impl ser::Serializer for MySerializer {
271            type Error = SerializationError;
272            type Ok = ();
273
274            type SerializeMap = ser::Impossible<Self::Ok, Self::Error>;
275            type SerializeSeq = ser::Impossible<Self::Ok, Self::Error>;
276            type SerializeStruct = ser::Impossible<Self::Ok, Self::Error>;
277            type SerializeStructVariant = ser::Impossible<Self::Ok, Self::Error>;
278            type SerializeTuple = ser::Impossible<Self::Ok, Self::Error>;
279            type SerializeTupleStruct = ser::Impossible<Self::Ok, Self::Error>;
280            type SerializeTupleVariant = ser::Impossible<Self::Ok, Self::Error>;
281            
282            impl_serde_serialize_error!(
283                SerializationError::CannotSerialize, [
284                    bool,
285                    bytes,
286                    i8, i16, i32, i64,
287                    u8, u16, u32, u64,
288                    f32, f64,
289                    char,
290                    str,
291                    none, some, unit,
292                    unit_struct, unit_variant,
293                    newtype_struct, newtype_variant,
294                    seq, map,
295                    tuple, tuple_struct, tuple_variant,
296                    struct, struct_variant
297                ]
298            );
299        }
300    }
301}
impl_serde_serialize_error/lib.rs

impl_serde_serialize_error/
lib.rs
