serde/ser/
impossible.rs

1//! This module contains `Impossible` serializer and its implementations.
2
3use crate::lib::*;
4
5use crate::ser::{
6    self, Serialize, SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant,
7    SerializeTuple, SerializeTupleStruct, SerializeTupleVariant,
8};
9
10/// Helper type for implementing a `Serializer` that does not support
11/// serializing one of the compound types.
12///
13/// This type cannot be instantiated, but implements every one of the traits
14/// corresponding to the [`Serializer`] compound types: [`SerializeSeq`],
15/// [`SerializeTuple`], [`SerializeTupleStruct`], [`SerializeTupleVariant`],
16/// [`SerializeMap`], [`SerializeStruct`], and [`SerializeStructVariant`].
17///
18/// ```edition2021
19/// # use serde::ser::{Serializer, Impossible};
20/// # use serde::__private::doc::Error;
21/// #
22/// # struct MySerializer;
23/// #
24/// impl Serializer for MySerializer {
25///     type Ok = ();
26///     type Error = Error;
27///
28///     type SerializeSeq = Impossible<(), Error>;
29///     /* other associated types */
30///
31///     /// This data format does not support serializing sequences.
32///     fn serialize_seq(self,
33///                      len: Option<usize>)
34///                      -> Result<Self::SerializeSeq, Error> {
35///         // Given Impossible cannot be instantiated, the only
36///         // thing we can do here is to return an error.
37/// #         stringify! {
38///         Err(...)
39/// #         };
40/// #         unimplemented!()
41///     }
42///
43///     /* other Serializer methods */
44/// #     serde::__serialize_unimplemented! {
45/// #         bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str bytes none some
46/// #         unit unit_struct unit_variant newtype_struct newtype_variant
47/// #         tuple tuple_struct tuple_variant map struct struct_variant
48/// #     }
49/// }
50/// ```
51///
52/// [`Serializer`]: trait.Serializer.html
53/// [`SerializeSeq`]: trait.SerializeSeq.html
54/// [`SerializeTuple`]: trait.SerializeTuple.html
55/// [`SerializeTupleStruct`]: trait.SerializeTupleStruct.html
56/// [`SerializeTupleVariant`]: trait.SerializeTupleVariant.html
57/// [`SerializeMap`]: trait.SerializeMap.html
58/// [`SerializeStruct`]: trait.SerializeStruct.html
59/// [`SerializeStructVariant`]: trait.SerializeStructVariant.html
60pub struct Impossible<Ok, Error> {
61    void: Void,
62    ok: PhantomData<Ok>,
63    error: PhantomData<Error>,
64}
65
66enum Void {}
67
68impl<Ok, Error> SerializeSeq for Impossible<Ok, Error>
69where
70    Error: ser::Error,
71{
72    type Ok = Ok;
73    type Error = Error;
74
75    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Error>
76    where
77        T: ?Sized + Serialize,
78    {
79        let _ = value;
80        match self.void {}
81    }
82
83    fn end(self) -> Result<Ok, Error> {
84        match self.void {}
85    }
86}
87
88impl<Ok, Error> SerializeTuple for Impossible<Ok, Error>
89where
90    Error: ser::Error,
91{
92    type Ok = Ok;
93    type Error = Error;
94
95    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Error>
96    where
97        T: ?Sized + Serialize,
98    {
99        let _ = value;
100        match self.void {}
101    }
102
103    fn end(self) -> Result<Ok, Error> {
104        match self.void {}
105    }
106}
107
108impl<Ok, Error> SerializeTupleStruct for Impossible<Ok, Error>
109where
110    Error: ser::Error,
111{
112    type Ok = Ok;
113    type Error = Error;
114
115    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Error>
116    where
117        T: ?Sized + Serialize,
118    {
119        let _ = value;
120        match self.void {}
121    }
122
123    fn end(self) -> Result<Ok, Error> {
124        match self.void {}
125    }
126}
127
128impl<Ok, Error> SerializeTupleVariant for Impossible<Ok, Error>
129where
130    Error: ser::Error,
131{
132    type Ok = Ok;
133    type Error = Error;
134
135    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Error>
136    where
137        T: ?Sized + Serialize,
138    {
139        let _ = value;
140        match self.void {}
141    }
142
143    fn end(self) -> Result<Ok, Error> {
144        match self.void {}
145    }
146}
147
148impl<Ok, Error> SerializeMap for Impossible<Ok, Error>
149where
150    Error: ser::Error,
151{
152    type Ok = Ok;
153    type Error = Error;
154
155    fn serialize_key<T>(&mut self, key: &T) -> Result<(), Error>
156    where
157        T: ?Sized + Serialize,
158    {
159        let _ = key;
160        match self.void {}
161    }
162
163    fn serialize_value<T>(&mut self, value: &T) -> Result<(), Error>
164    where
165        T: ?Sized + Serialize,
166    {
167        let _ = value;
168        match self.void {}
169    }
170
171    fn end(self) -> Result<Ok, Error> {
172        match self.void {}
173    }
174}
175
176impl<Ok, Error> SerializeStruct for Impossible<Ok, Error>
177where
178    Error: ser::Error,
179{
180    type Ok = Ok;
181    type Error = Error;
182
183    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Error>
184    where
185        T: ?Sized + Serialize,
186    {
187        let _ = key;
188        let _ = value;
189        match self.void {}
190    }
191
192    fn end(self) -> Result<Ok, Error> {
193        match self.void {}
194    }
195}
196
197impl<Ok, Error> SerializeStructVariant for Impossible<Ok, Error>
198where
199    Error: ser::Error,
200{
201    type Ok = Ok;
202    type Error = Error;
203
204    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Error>
205    where
206        T: ?Sized + Serialize,
207    {
208        let _ = key;
209        let _ = value;
210        match self.void {}
211    }
212
213    fn end(self) -> Result<Ok, Error> {
214        match self.void {}
215    }
216}
serde/ser/impossible.rs

serde/ser/
impossible.rs
