serde_urlencoded/ser/
pair.rs

Help
1use crate::ser::key::KeySink;
2use crate::ser::part::PartSerializer;
3use crate::ser::value::ValueSink;
4use crate::ser::Error;
5use form_urlencoded::Serializer as UrlEncodedSerializer;
6use form_urlencoded::Target as UrlEncodedTarget;
7use serde::ser;
8use std::borrow::Cow;
9use std::mem;
10
11pub struct PairSerializer<'input, 'target, Target: UrlEncodedTarget> {
12    urlencoder: &'target mut UrlEncodedSerializer<'input, Target>,
13    state: PairState,
14}
15
16impl<'input, 'target, Target> PairSerializer<'input, 'target, Target>
17where
18    Target: 'target + UrlEncodedTarget,
19{
20    pub fn new(
21        urlencoder: &'target mut UrlEncodedSerializer<'input, Target>,
22    ) -> Self {
23        PairSerializer {
24            urlencoder,
25            state: PairState::WaitingForKey,
26        }
27    }
28}
29
30impl<'input, 'target, Target> ser::Serializer
31    for PairSerializer<'input, 'target, Target>
32where
33    Target: 'target + UrlEncodedTarget,
34{
35    type Ok = ();
36    type Error = Error;
37    type SerializeSeq = ser::Impossible<(), Error>;
38    type SerializeTuple = Self;
39    type SerializeTupleStruct = ser::Impossible<(), Error>;
40    type SerializeTupleVariant = ser::Impossible<(), Error>;
41    type SerializeMap = ser::Impossible<(), Error>;
42    type SerializeStruct = ser::Impossible<(), Error>;
43    type SerializeStructVariant = ser::Impossible<(), Error>;
44
45    fn serialize_bool(self, _v: bool) -> Result<(), Error> {
46        Err(Error::unsupported_pair())
47    }
48
49    fn serialize_i8(self, _v: i8) -> Result<(), Error> {
50        Err(Error::unsupported_pair())
51    }
52
53    fn serialize_i16(self, _v: i16) -> Result<(), Error> {
54        Err(Error::unsupported_pair())
55    }
56
57    fn serialize_i32(self, _v: i32) -> Result<(), Error> {
58        Err(Error::unsupported_pair())
59    }
60
61    fn serialize_i64(self, _v: i64) -> Result<(), Error> {
62        Err(Error::unsupported_pair())
63    }
64
65    fn serialize_u8(self, _v: u8) -> Result<(), Error> {
66        Err(Error::unsupported_pair())
67    }
68
69    fn serialize_u16(self, _v: u16) -> Result<(), Error> {
70        Err(Error::unsupported_pair())
71    }
72
73    fn serialize_u32(self, _v: u32) -> Result<(), Error> {
74        Err(Error::unsupported_pair())
75    }
76
77    fn serialize_u64(self, _v: u64) -> Result<(), Error> {
78        Err(Error::unsupported_pair())
79    }
80
81    fn serialize_f32(self, _v: f32) -> Result<(), Error> {
82        Err(Error::unsupported_pair())
83    }
84
85    fn serialize_f64(self, _v: f64) -> Result<(), Error> {
86        Err(Error::unsupported_pair())
87    }
88
89    fn serialize_char(self, _v: char) -> Result<(), Error> {
90        Err(Error::unsupported_pair())
91    }
92
93    fn serialize_str(self, _value: &str) -> Result<(), Error> {
94        Err(Error::unsupported_pair())
95    }
96
97    fn serialize_bytes(self, _value: &[u8]) -> Result<(), Error> {
98        Err(Error::unsupported_pair())
99    }
100
101    fn serialize_unit(self) -> Result<(), Error> {
102        Err(Error::unsupported_pair())
103    }
104
105    fn serialize_unit_struct(self, _name: &'static str) -> Result<(), Error> {
106        Err(Error::unsupported_pair())
107    }
108
109    fn serialize_unit_variant(
110        self,
111        _name: &'static str,
112        _variant_index: u32,
113        _variant: &'static str,
114    ) -> Result<(), Error> {
115        Err(Error::unsupported_pair())
116    }
117
118    fn serialize_newtype_struct<T: ?Sized + ser::Serialize>(
119        self,
120        _name: &'static str,
121        value: &T,
122    ) -> Result<(), Error> {
123        value.serialize(self)
124    }
125
126    fn serialize_newtype_variant<T: ?Sized + ser::Serialize>(
127        self,
128        _name: &'static str,
129        _variant_index: u32,
130        _variant: &'static str,
131        _value: &T,
132    ) -> Result<(), Error> {
133        Err(Error::unsupported_pair())
134    }
135
136    fn serialize_none(self) -> Result<(), Error> {
137        Ok(())
138    }
139
140    fn serialize_some<T: ?Sized + ser::Serialize>(
141        self,
142        value: &T,
143    ) -> Result<(), Error> {
144        value.serialize(self)
145    }
146
147    fn serialize_seq(
148        self,
149        _len: Option<usize>,
150    ) -> Result<Self::SerializeSeq, Error> {
151        Err(Error::unsupported_pair())
152    }
153
154    fn serialize_tuple(self, len: usize) -> Result<Self, Error> {
155        if len == 2 {
156            Ok(self)
157        } else {
158            Err(Error::unsupported_pair())
159        }
160    }
161
162    fn serialize_tuple_struct(
163        self,
164        _name: &'static str,
165        _len: usize,
166    ) -> Result<Self::SerializeTupleStruct, Error> {
167        Err(Error::unsupported_pair())
168    }
169
170    fn serialize_tuple_variant(
171        self,
172        _name: &'static str,
173        _variant_index: u32,
174        _variant: &'static str,
175        _len: usize,
176    ) -> Result<Self::SerializeTupleVariant, Error> {
177        Err(Error::unsupported_pair())
178    }
179
180    fn serialize_map(
181        self,
182        _len: Option<usize>,
183    ) -> Result<Self::SerializeMap, Error> {
184        Err(Error::unsupported_pair())
185    }
186
187    fn serialize_struct(
188        self,
189        _name: &'static str,
190        _len: usize,
191    ) -> Result<Self::SerializeStruct, Error> {
192        Err(Error::unsupported_pair())
193    }
194
195    fn serialize_struct_variant(
196        self,
197        _name: &'static str,
198        _variant_index: u32,
199        _variant: &'static str,
200        _len: usize,
201    ) -> Result<Self::SerializeStructVariant, Error> {
202        Err(Error::unsupported_pair())
203    }
204}
205
206impl<'input, 'target, Target> ser::SerializeTuple
207    for PairSerializer<'input, 'target, Target>
208where
209    Target: 'target + UrlEncodedTarget,
210{
211    type Ok = ();
212    type Error = Error;
213
214    fn serialize_element<T: ?Sized + ser::Serialize>(
215        &mut self,
216        value: &T,
217    ) -> Result<(), Error> {
218        match mem::replace(&mut self.state, PairState::Done) {
219            PairState::WaitingForKey => {
220                let key_sink = KeySink::new(|key| Ok(key.into()));
221                let key_serializer = PartSerializer::new(key_sink);
222                self.state = PairState::WaitingForValue {
223                    key: value.serialize(key_serializer)?,
224                };
225                Ok(())
226            }
227            PairState::WaitingForValue { key } => {
228                let result = {
229                    let value_sink = ValueSink::new(self.urlencoder, &key);
230                    let value_serializer = PartSerializer::new(value_sink);
231                    value.serialize(value_serializer)
232                };
233                if result.is_ok() {
234                    self.state = PairState::Done;
235                } else {
236                    self.state = PairState::WaitingForValue { key };
237                }
238                result
239            }
240            PairState::Done => Err(Error::done()),
241        }
242    }
243
244    fn end(self) -> Result<(), Error> {
245        if let PairState::Done = self.state {
246            Ok(())
247        } else {
248            Err(Error::not_done())
249        }
250    }
251}
252
253enum PairState {
254    WaitingForKey,
255    WaitingForValue { key: Cow<'static, str> },
256    Done,
257}
258
259impl Error {
260    fn done() -> Self {
261        Error::Custom("this pair has already been serialized".into())
262    }
263
264    fn not_done() -> Self {
265        Error::Custom("this pair has not yet been serialized".into())
266    }
267
268    fn unsupported_pair() -> Self {
269        Error::Custom("unsupported pair".into())
270    }
271}
serde_urlencoded/ser/pair.rs

serde_urlencoded/ser/
pair.rs
