serde_alter/
alter.rs

1use core::cell::Cell;
2use core::fmt::Display;
3use core::marker::PhantomData;
4use core::ops::{Deref, DerefMut};
5use serde::ser::{
6    SerializeMap,
7    SerializeSeq,
8    SerializeStruct,
9    SerializeStructVariant,
10    SerializeTuple,
11    SerializeTupleStruct,
12    SerializeTupleVariant
13};
14use serde::{Deserialize, Deserializer, Serialize, Serializer};
15
16/// Alternative [`Serializer`] implementation.
17/// 
18/// The alternative serialization is enabled by the [`Altered`] state.
19/// 
20/// Requires an implementation of either [`AlterRest`] or [`DeferRest`].
21/// 
22/// All functions are optional and defer to their default serialization.
23pub trait Alter: AlterRest {
24    /// Alternative [`serialize_bool`](Serializer::serialize_bool) implementation.
25    fn alter_bool<S: Serializer>(ser: S, v: bool) -> Result<S::Ok, S::Error> {
26        ser.serialize_bool(v)
27    }
28
29    /// Alternative [`serialize_i8`](Serializer::serialize_i8) implementation.
30    fn alter_i8<S: Serializer>(ser: S, v: i8) -> Result<S::Ok, S::Error> {
31        ser.serialize_i8(v)
32    }
33
34    /// Alternative [`serialize_i16`](Serializer::serialize_i16) implementation.
35    fn alter_i16<S: Serializer>(ser: S, v: i16) -> Result<S::Ok, S::Error> {
36        ser.serialize_i16(v)
37    }
38
39    /// Alternative [`serialize_i32`](Serializer::serialize_i32) implementation.
40    fn alter_i32<S: Serializer>(ser: S, v: i32) -> Result<S::Ok, S::Error> {
41        ser.serialize_i32(v)
42    }
43
44    /// Alternative [`serialize_i64`](Serializer::serialize_i64) implementation.
45    fn alter_i64<S: Serializer>(ser: S, v: i64) -> Result<S::Ok, S::Error> {
46        ser.serialize_i64(v)
47    }
48
49    /// Alternative [`serialize_i128`](Serializer::serialize_i128) implementation.
50    fn alter_i128<S: Serializer>(ser: S, v: i128) -> Result<S::Ok, S::Error> {
51        ser.serialize_i128(v)
52    }
53
54    /// Alternative [`serialize_u8`](Serializer::serialize_u8) implementation.
55    fn alter_u8<S: Serializer>(ser: S, v: u8) -> Result<S::Ok, S::Error> {
56        ser.serialize_u8(v)
57    }
58
59    /// Alternative [`serialize_u16`](Serializer::serialize_u16) implementation.
60    fn alter_u16<S: Serializer>(ser: S, v: u16) -> Result<S::Ok, S::Error> {
61        ser.serialize_u16(v)
62    }
63
64    /// Alternative [`serialize_u32`](Serializer::serialize_u32) implementation.
65    fn alter_u32<S: Serializer>(ser: S, v: u32) -> Result<S::Ok, S::Error> {
66        ser.serialize_u32(v)
67    }
68
69    /// Alternative [`serialize_u64`](Serializer::serialize_u64) implementation.
70    fn alter_u64<S: Serializer>(ser: S, v: u64) -> Result<S::Ok, S::Error> {
71        ser.serialize_u64(v)
72    }
73
74    /// Alternative [`serialize_u128`](Serializer::serialize_u128) implementation.
75    fn alter_u128<S: Serializer>(ser: S, v: u128) -> Result<S::Ok, S::Error> {
76        ser.serialize_u128(v)
77    }
78
79    /// Alternative [`serialize_f32`](Serializer::serialize_f32) implementation.
80    fn alter_f32<S: Serializer>(ser: S, v: f32) -> Result<S::Ok, S::Error> {
81        ser.serialize_f32(v)
82    }
83
84    /// Alternative [`serialize_f64`](Serializer::serialize_f64) implementation.
85    fn alter_f64<S: Serializer>(ser: S, v: f64) -> Result<S::Ok, S::Error> {
86        ser.serialize_f64(v)
87    }
88
89    /// Alternative [`serialize_char`](Serializer::serialize_char) implementation.
90    fn alter_char<S: Serializer>(ser: S, v: char) -> Result<S::Ok, S::Error> {
91        ser.serialize_char(v)
92    }
93
94    /// Alternative [`serialize_str`](Serializer::serialize_str) implementation.
95    fn alter_str<S: Serializer>(ser: S, v: &str) -> Result<S::Ok, S::Error> {
96        ser.serialize_str(v)
97    }
98
99    /// Alternative [`serialize_bytes`](Serializer::serialize_bytes) implementation.
100    fn alter_bytes<S: Serializer>(ser: S, v: &[u8]) -> Result<S::Ok, S::Error> {
101        ser.serialize_bytes(v)
102    }
103
104    /// Alternative [`serialize_none`](Serializer::serialize_none) implementation.
105    fn alter_none<S: Serializer>(ser: S) -> Result<S::Ok, S::Error> {
106        ser.serialize_none()
107    }
108
109    /// Alternative [`serialize_some`](Serializer::serialize_some) implementation.
110    fn alter_some<S: Serializer, T: ?Sized + Serialize>(ser: S, value: &T) -> Result<S::Ok, S::Error> {
111        ser.serialize_some(value)
112    }
113
114    /// Alternative [`serialize_unit`](Serializer::serialize_unit) implementation.
115    fn alter_unit<S: Serializer>(ser: S) -> Result<S::Ok, S::Error> {
116        ser.serialize_unit()
117    }
118
119    /// Alternative [`serialize_unit_struct`](Serializer::serialize_unit_struct) implementation.
120    fn alter_unit_struct<S: Serializer>(ser: S, name: &'static str) -> Result<S::Ok, S::Error> {
121        ser.serialize_unit_struct(name)
122    }
123
124    /// Alternative [`serialize_unit_variant`](Serializer::serialize_unit_variant) implementation.
125    fn alter_unit_variant<S: Serializer>(ser: S, name: &'static str, variant_index: u32, variant: &'static str) -> Result<S::Ok, S::Error> {
126        ser.serialize_unit_variant(name, variant_index, variant)
127    }
128
129    /// Alternative [`serialize_newtype_struct`](Serializer::serialize_newtype_struct) implementation.
130    fn alter_newtype_struct<S: Serializer, T: ?Sized + Serialize>(ser: S, name: &'static str, value: &T) -> Result<S::Ok, S::Error> {
131        ser.serialize_newtype_struct(name, value)
132    }
133
134    /// Alternative [`serialize_newtype_variant`](Serializer::serialize_newtype_variant) implementation.
135    fn alter_newtype_variant<S: Serializer, T: ?Sized + Serialize>(ser: S, name: &'static str, variant_index: u32, variant: &'static str, value: &T) -> Result<S::Ok, S::Error> {
136        ser.serialize_newtype_variant(name, variant_index, variant, value)
137    }
138
139    /// Alternative [`collect_str`](Serializer::collect_str) implementation.
140    #[cfg(feature = "std")]
141    fn collect_str<S: Serializer, T: ?Sized + Display>(ser: S, value: &T) -> Result<S::Ok, S::Error> {
142        Self::alter_str(ser, &value.to_string())
143    }
144
145    /// Alternative [`collect_str`](Serializer::collect_str) implementation.
146    #[cfg(not(feature = "std"))]
147    fn collect_str<S: Serializer, T: ?Sized + Display>(ser: S, value: &T) -> Result<S::Ok, S::Error>;
148}
149
150/// The rest of the [`Alter`] implementation.
151/// 
152/// Implement [`DeferRest`] instead for defaults.
153pub trait AlterRest {
154    /// Alternative [`SerializeSeq`](Serializer::SerializeSeq) type.
155    type AlterSeq<S: Serializer>: SerializeSeq<Ok = S::Ok, Error = S::Error>;
156
157    /// Alternative [`SerializeTuple`](Serializer::SerializeTuple) type.
158    type AlterTuple<S: Serializer>: SerializeTuple<Ok = S::Ok, Error = S::Error>;
159
160    /// Alternative [`SerializeTupleStruct`](Serializer::SerializeTupleStruct) type.
161    type AlterTupleStruct<S: Serializer>: SerializeTupleStruct<Ok = S::Ok, Error = S::Error>;
162
163    /// Alternative [`SerializeTupleVariant`](Serializer::SerializeTupleVariant) type.
164    type AlterTupleVariant<S: Serializer>: SerializeTupleVariant<Ok = S::Ok, Error = S::Error>;
165
166    /// Alternative [`SerializeMap`](Serializer::SerializeMap) type.
167    type AlterMap<S: Serializer>: SerializeMap<Ok = S::Ok, Error = S::Error>;
168
169    /// Alternative [`SerializeStruct`](Serializer::SerializeStruct) type.
170    type AlterStruct<S: Serializer>: SerializeStruct<Ok = S::Ok, Error = S::Error>;
171
172    /// Alternative [`SerializeStructVariant`](Serializer::SerializeStructVariant) type.
173    type AlterStructVariant<S: Serializer>: SerializeStructVariant<Ok = S::Ok, Error = S::Error>;
174
175    /// Alternative [`serialize_seq`](Serializer::serialize_seq) implementation.
176    fn alter_seq<S: Serializer>(ser: S, len: Option<usize>) -> Result<Self::AlterSeq<S>, S::Error>;
177
178    /// Alternative [`serialize_tuple`](Serializer::serialize_tuple) implementation.
179    fn alter_tuple<S: Serializer>(ser: S, len: usize) -> Result<Self::AlterTuple<S>, S::Error>;
180
181    /// Alternative [`serialize_tuple_struct`](Serializer::serialize_tuple_struct) implementation.
182    fn alter_tuple_struct<S: Serializer>(ser: S, name: &'static str, len: usize) -> Result<Self::AlterTupleStruct<S>, S::Error>;
183
184    /// Alternative [`serialize_tuple_variant`](Serializer::serialize_tuple_variant) implementation.
185    fn alter_tuple_variant<S: Serializer>(ser: S, name: &'static str, variant_index: u32, variant: &'static str, len: usize) -> Result<Self::AlterTupleVariant<S>, S::Error>;
186
187    /// Alternative [`serialize_map`](Serializer::serialize_map) implementation.
188    fn alter_map<S: Serializer>(ser: S, len: Option<usize>) -> Result<Self::AlterMap<S>, S::Error>;
189
190    /// Alternative [`serialize_struct`](Serializer::serialize_struct) implementation.
191    fn alter_struct<S: Serializer>(ser: S, name: &'static str, len: usize) -> Result<Self::AlterStruct<S>, S::Error>;
192
193    /// Alternative [`serialize_struct_variant`](Serializer::serialize_struct_variant) implementation.
194    fn alter_struct_variant<S: Serializer>(ser: S, name: &'static str, variant_index: u32, variant: &'static str, len: usize) -> Result<Self::AlterStructVariant<S>, S::Error>;
195}
196
197/// Default [`AlterRest`] implementation.
198pub trait DeferRest {}
199
200impl<T: DeferRest> AlterRest for T {
201    type AlterSeq<S: Serializer> = S::SerializeSeq;
202    type AlterTuple<S: Serializer> = S::SerializeTuple;
203    type AlterTupleStruct<S: Serializer> = S::SerializeTupleStruct;
204    type AlterTupleVariant<S: Serializer> = S::SerializeTupleVariant;
205    type AlterMap<S: Serializer> = S::SerializeMap;
206    type AlterStruct<S: Serializer> = S::SerializeStruct;
207    type AlterStructVariant<S: Serializer> = S::SerializeStructVariant;
208
209    fn alter_seq<S: Serializer>(ser: S, len: Option<usize>) -> Result<Self::AlterSeq<S>, S::Error> {
210        ser.serialize_seq(len)
211    }
212    fn alter_tuple<S: Serializer>(ser: S, len: usize) -> Result<Self::AlterTuple<S>, S::Error> {
213        ser.serialize_tuple(len)
214    }
215    fn alter_tuple_struct<S: Serializer>(ser: S, name: &'static str, len: usize) -> Result<Self::AlterTupleStruct<S>, S::Error> {
216        ser.serialize_tuple_struct(name, len)
217    }
218    fn alter_tuple_variant<S: Serializer>(ser: S, name: &'static str, variant_index: u32, variant: &'static str, len: usize) -> Result<Self::AlterTupleVariant<S>, S::Error> {
219        ser.serialize_tuple_variant(name, variant_index, variant, len)
220    }
221    fn alter_map<S: Serializer>(ser: S, len: Option<usize>) -> Result<Self::AlterMap<S>, S::Error> {
222        ser.serialize_map(len)
223    }
224    fn alter_struct<S: Serializer>(ser: S, name: &'static str, len: usize) -> Result<Self::AlterStruct<S>, S::Error> {
225        ser.serialize_struct(name, len)
226    }
227    fn alter_struct_variant<S: Serializer>(ser: S, name: &'static str, variant_index: u32, variant: &'static str, len: usize) -> Result<Self::AlterStructVariant<S>, S::Error> {
228        ser.serialize_struct_variant(name, variant_index, variant, len)
229    }
230}
231
232struct AlteredSer<S, Z: ?Sized>(S, Cell<u8>, PhantomData<Z>);
233
234impl<S, Z: ?Sized> AlteredSer<S, Z> {
235    fn new(ser: S) -> Self {
236        AlteredSer(ser, Cell::new(0), PhantomData::<Z>)
237    }
238}
239
240impl<S: Serializer, Z: ?Sized + Alter> Serializer for AlteredSer<S, Z> {
241    type Ok = S::Ok;
242    type Error = S::Error;
243    type SerializeSeq = AlteredSer<Z::AlterSeq<S>, Z>;
244    type SerializeTuple = AlteredSer<Z::AlterTuple<S>, Z>;
245    type SerializeTupleStruct = AlteredSer<Z::AlterTupleStruct<S>, Z>;
246    type SerializeTupleVariant = AlteredSer<Z::AlterTupleVariant<S>, Z>;
247    type SerializeMap = AlteredSer<Z::AlterMap<S>, Z>;
248    type SerializeStruct = AlteredSer<Z::AlterStruct<S>, Z>;
249    type SerializeStructVariant = AlteredSer<Z::AlterStructVariant<S>, Z>;
250
251    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
252        Z::alter_bool(self.0, v)
253    }
254    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
255        Z::alter_i8(self.0, v)
256    }
257    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
258        Z::alter_i16(self.0, v)
259    }
260    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
261        Z::alter_i32(self.0, v)
262    }
263    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
264        Z::alter_i64(self.0, v)
265    }
266    fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
267        Z::alter_i128(self.0, v)
268    }
269    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
270        Z::alter_u8(self.0, v)
271    }
272    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
273        Z::alter_u16(self.0, v)
274    }
275    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
276        Z::alter_u32(self.0, v)
277    }
278    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
279        Z::alter_u64(self.0, v)
280    }
281    fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
282        Z::alter_u128(self.0, v)
283    }
284    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
285        Z::alter_f32(self.0, v)
286    }
287    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
288        Z::alter_f64(self.0, v)
289    }
290    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
291        Z::alter_char(self.0, v)
292    }
293    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
294        Z::alter_str(self.0, v)
295    }
296    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
297        Z::alter_bytes(self.0, v)
298    }
299    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
300        Z::alter_none(self.0)
301    }
302    fn serialize_some<T: ?Sized + Serialize>(self, value: &T) -> Result<Self::Ok, Self::Error> {
303        Z::alter_some(self.0, &Altered::<_, Z>::new(value))
304    }
305    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
306        Z::alter_unit(self.0)
307    }
308    fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, Self::Error> {
309        Z::alter_unit_struct(self.0, name)
310    }
311    fn serialize_unit_variant(self, name: &'static str, variant_index: u32, variant: &'static str) -> Result<Self::Ok, Self::Error> {
312        Z::alter_unit_variant(self.0, name, variant_index, variant)
313    }
314    fn serialize_newtype_struct<T: ?Sized + Serialize>(self, name: &'static str, value: &T) -> Result<Self::Ok, Self::Error> {
315        if name == UNALTER {
316            value.serialize(self.0)
317        } else {
318            Z::alter_newtype_struct(self.0, name, &Altered::<_, Z>::new(value))
319        }
320    }
321    fn serialize_newtype_variant<T: ?Sized + Serialize>(self, name: &'static str, variant_index: u32, variant: &'static str, value: &T) -> Result<Self::Ok, Self::Error> {
322        Z::alter_newtype_variant(self.0, name, variant_index, variant, &Altered::<_, Z>::new(value))
323    }
324    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
325        Z::alter_seq(self.0, len).map(AlteredSer::new)
326    }
327    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
328        Z::alter_tuple(self.0, len).map(AlteredSer::new)
329    }
330    fn serialize_tuple_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeTupleStruct, Self::Error> {
331        Z::alter_tuple_struct(self.0, name, len).map(AlteredSer::new)
332    }
333    fn serialize_tuple_variant(self, name: &'static str, variant_index: u32, variant: &'static str, len: usize) -> Result<Self::SerializeTupleVariant, Self::Error> {
334        Z::alter_tuple_variant(self.0, name, variant_index, variant, len).map(AlteredSer::new)
335    }
336    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
337        Z::alter_map(self.0, len).map(AlteredSer::new)
338    }
339    fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct, Self::Error> {
340        Z::alter_struct(self.0, name, len).map(AlteredSer::new)
341    }
342    fn serialize_struct_variant(self, name: &'static str, variant_index: u32, variant: &'static str, len: usize) -> Result<Self::SerializeStructVariant, Self::Error> {
343        Z::alter_struct_variant(self.0, name, variant_index, variant, len).map(AlteredSer::new)
344    }
345    fn collect_str<T: ?Sized + Display>(self, value: &T) -> Result<Self::Ok, Self::Error> {
346        Z::collect_str(self.0, value)
347    }
348    fn is_human_readable(&self) -> bool {
349        let i = self.1.get();
350        self.1.set((i + 1) % 3);
351        i == 2
352    }
353}
354
355impl<S: SerializeSeq, Z: ?Sized + Alter> SerializeSeq for AlteredSer<S, Z> {
356    type Ok = S::Ok;
357    type Error = S::Error;
358    fn serialize_element<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error> {
359        self.0.serialize_element(&Altered::<_, Z>::new(value))
360    }
361    fn end(self) -> Result<Self::Ok, Self::Error> {
362        self.0.end()
363    }
364}
365
366impl<S: SerializeTuple, Z: ?Sized + Alter> SerializeTuple for AlteredSer<S, Z> {
367    type Ok = S::Ok;
368    type Error = S::Error;
369    fn serialize_element<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error> {
370        self.0.serialize_element(&Altered::<_, Z>::new(value))
371    }
372    fn end(self) -> Result<Self::Ok, Self::Error> {
373        self.0.end()
374    }
375}
376
377impl<S: SerializeTupleStruct, Z: ?Sized + Alter> SerializeTupleStruct for AlteredSer<S, Z> {
378    type Ok = S::Ok;
379    type Error = S::Error;
380    fn serialize_field<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error> {
381        self.0.serialize_field(&Altered::<_, Z>::new(value))
382    }
383    fn end(self) -> Result<Self::Ok, Self::Error> {
384        self.0.end()
385    }
386}
387
388impl<S: SerializeTupleVariant, Z: ?Sized + Alter> SerializeTupleVariant for AlteredSer<S, Z> {
389    type Ok = S::Ok;
390    type Error = S::Error;
391    fn serialize_field<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error> {
392        self.0.serialize_field(&Altered::<_, Z>::new(value))
393    }
394    fn end(self) -> Result<Self::Ok, Self::Error> {
395        self.0.end()
396    }
397}
398
399impl<S: SerializeMap, Z: ?Sized + Alter> SerializeMap for AlteredSer<S, Z> {
400    type Ok = S::Ok;
401    type Error = S::Error;
402    fn serialize_key<T: ?Sized + Serialize>(&mut self, key: &T) -> Result<(), Self::Error> {
403        self.0.serialize_key(key)
404    }
405    fn serialize_value<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error> {
406        self.0.serialize_value(&Altered::<_, Z>::new(value))
407    }
408    fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<(), Self::Error>
409    where
410        K: ?Sized + Serialize,
411        V: ?Sized + Serialize,
412    {
413        self.0.serialize_entry(key, &Altered::<_, Z>::new(value))
414    }
415    fn end(self) -> Result<Self::Ok, Self::Error> {
416        self.0.end()
417    }
418}
419
420impl<S: SerializeStruct, Z: ?Sized + Alter> SerializeStruct for AlteredSer<S, Z> {
421    type Ok = S::Ok;
422    type Error = S::Error;
423    fn serialize_field<T: ?Sized + Serialize>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error> {
424        self.0.serialize_field(key, &Altered::<_, Z>::new(value))
425    }
426    fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error> {
427        self.0.skip_field(key)
428    }
429    fn end(self) -> Result<Self::Ok, Self::Error> {
430        self.0.end()
431    }
432}
433
434impl<S: SerializeStructVariant, Z: ?Sized + Alter> SerializeStructVariant for AlteredSer<S, Z> {
435    type Ok = S::Ok;
436    type Error = S::Error;
437    fn serialize_field<T: ?Sized + Serialize>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error> {
438        self.0.serialize_field(key, &Altered::<_, Z>::new(value))
439    }
440    fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error> {
441        self.0.skip_field(key)
442    }
443    fn end(self) -> Result<Self::Ok, Self::Error> {
444        self.0.end()
445    }
446}
447
448struct AltSer<S>(S, Cell<u8>);
449
450impl<S> AltSer<S> {
451    fn new(ser: S) -> Self {
452        AltSer(ser, Cell::new(0))
453    }
454}
455
456impl<S: Serializer> Serializer for AltSer<S> {
457    type Ok = S::Ok;
458    type Error = S::Error;
459    type SerializeSeq = AltSer<S::SerializeSeq>;
460    type SerializeTuple = AltSer<S::SerializeTuple>;
461    type SerializeTupleStruct = AltSer<S::SerializeTupleStruct>;
462    type SerializeTupleVariant = AltSer<S::SerializeTupleVariant>;
463    type SerializeMap = AltSer<S::SerializeMap>;
464    type SerializeStruct = AltSer<S::SerializeStruct>;
465    type SerializeStructVariant = AltSer<S::SerializeStructVariant>;
466
467    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
468        self.0.serialize_bool(v)
469    }
470    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
471        self.0.serialize_i8(v)
472    }
473    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
474        self.0.serialize_i16(v)
475    }
476    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
477        self.0.serialize_i32(v)
478    }
479    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
480        self.0.serialize_i64(v)
481    }
482    fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
483        self.0.serialize_i128(v)
484    }
485    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
486        self.0.serialize_u8(v)
487    }
488    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
489        self.0.serialize_u16(v)
490    }
491    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
492        self.0.serialize_u32(v)
493    }
494    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
495        self.0.serialize_u64(v)
496    }
497    fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
498        self.0.serialize_u128(v)
499    }
500    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
501        self.0.serialize_f32(v)
502    }
503    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
504        self.0.serialize_f64(v)
505    }
506    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
507        self.0.serialize_char(v)
508    }
509    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
510        self.0.serialize_str(v)
511    }
512    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
513        self.0.serialize_bytes(v)
514    }
515    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
516        self.0.serialize_none()
517    }
518    fn serialize_some<T: ?Sized + Serialize>(self, value: &T) -> Result<Self::Ok, Self::Error> {
519        self.0.serialize_some(&Alt::new(value))
520    }
521    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
522        self.0.serialize_unit()
523    }
524    fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, Self::Error> {
525        self.0.serialize_unit_struct(name)
526    }
527    fn serialize_unit_variant(self, name: &'static str, variant_index: u32, variant: &'static str) -> Result<Self::Ok, Self::Error> {
528        self.0.serialize_unit_variant(name, variant_index, variant)
529    }
530    fn serialize_newtype_struct<T: ?Sized + Serialize>(self, name: &'static str, value: &T) -> Result<Self::Ok, Self::Error> {
531        self.0.serialize_newtype_struct(name, &Alt::new(value))
532    }
533    fn serialize_newtype_variant<T: ?Sized + Serialize>(self, name: &'static str, variant_index: u32, variant: &'static str, value: &T) -> Result<Self::Ok, Self::Error> {
534        self.0.serialize_newtype_variant(name, variant_index, variant, &Alt::new(value))
535    }
536    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
537        self.0.serialize_seq(len).map(AltSer::new)
538    }
539    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
540        self.0.serialize_tuple(len).map(AltSer::new)
541    }
542    fn serialize_tuple_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeTupleStruct, Self::Error> {
543        self.0.serialize_tuple_struct(name, len).map(AltSer::new)
544    }
545    fn serialize_tuple_variant(self, name: &'static str, variant_index: u32, variant: &'static str, len: usize) -> Result<Self::SerializeTupleVariant, Self::Error> {
546        self.0.serialize_tuple_variant(name, variant_index, variant, len).map(AltSer::new)
547    }
548    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
549        self.0.serialize_map(len).map(AltSer::new)
550    }
551    fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct, Self::Error> {
552        self.0.serialize_struct(name, len).map(AltSer::new)
553    }
554    fn serialize_struct_variant(self, name: &'static str, variant_index: u32, variant: &'static str, len: usize) -> Result<Self::SerializeStructVariant, Self::Error> {
555        self.0.serialize_struct_variant(name, variant_index, variant, len).map(AltSer::new)
556    }
557    fn collect_str<T: ?Sized + Display>(self, value: &T) -> Result<Self::Ok, Self::Error> {
558        self.0.collect_str(value)
559    }
560    fn is_human_readable(&self) -> bool {
561        let i = self.1.get();
562        self.1.set((i + 1) % 3);
563        i != 2
564    }
565}
566
567impl<S: SerializeSeq> SerializeSeq for AltSer<S> {
568    type Ok = S::Ok;
569    type Error = S::Error;
570    fn serialize_element<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error> {
571        self.0.serialize_element(&Alt::new(value))
572    }
573    fn end(self) -> Result<Self::Ok, Self::Error> {
574        self.0.end()
575    }
576}
577
578impl<S: SerializeTuple> SerializeTuple for AltSer<S> {
579    type Ok = S::Ok;
580    type Error = S::Error;
581    fn serialize_element<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error> {
582        self.0.serialize_element(&Alt::new(value))
583    }
584    fn end(self) -> Result<Self::Ok, Self::Error> {
585        self.0.end()
586    }
587}
588
589impl<S: SerializeTupleStruct> SerializeTupleStruct for AltSer<S> {
590    type Ok = S::Ok;
591    type Error = S::Error;
592    fn serialize_field<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error> {
593        self.0.serialize_field(&Alt::new(value))
594    }
595    fn end(self) -> Result<Self::Ok, Self::Error> {
596        self.0.end()
597    }
598}
599
600impl<S: SerializeTupleVariant> SerializeTupleVariant for AltSer<S> {
601    type Ok = S::Ok;
602    type Error = S::Error;
603    fn serialize_field<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error> {
604        self.0.serialize_field(&Alt::new(value))
605    }
606    fn end(self) -> Result<Self::Ok, Self::Error> {
607        self.0.end()
608    }
609}
610
611impl<S: SerializeMap> SerializeMap for AltSer<S> {
612    type Ok = S::Ok;
613    type Error = S::Error;
614    fn serialize_key<T: ?Sized + Serialize>(&mut self, key: &T) -> Result<(), Self::Error> {
615        self.0.serialize_key(key)
616    }
617    fn serialize_value<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error> {
618        self.0.serialize_value(&Alt::new(value))
619    }
620    fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<(), Self::Error>
621    where
622        K: ?Sized + Serialize,
623        V: ?Sized + Serialize,
624    {
625        self.0.serialize_entry(key, &Alt::new(value))
626    }
627    fn end(self) -> Result<Self::Ok, Self::Error> {
628        self.0.end()
629    }
630}
631
632impl<S: SerializeStruct> SerializeStruct for AltSer<S> {
633    type Ok = S::Ok;
634    type Error = S::Error;
635    fn serialize_field<T: ?Sized + Serialize>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error> {
636        self.0.serialize_field(key, &Alt::new(value))
637    }
638    fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error> {
639        self.0.skip_field(key)
640    }
641    fn end(self) -> Result<Self::Ok, Self::Error> {
642        self.0.end()
643    }
644}
645
646impl<S: SerializeStructVariant> SerializeStructVariant for AltSer<S> {
647    type Ok = S::Ok;
648    type Error = S::Error;
649    fn serialize_field<T: ?Sized + Serialize>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error> {
650        self.0.serialize_field(key, &Alt::new(value))
651    }
652    fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error> {
653        self.0.skip_field(key)
654    }
655    fn end(self) -> Result<Self::Ok, Self::Error> {
656        self.0.end()
657    }
658}
659
660/// Wrapper to activate the [`Alternative`] serialization of any inner type.
661#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
662pub struct Alt<T>(pub T);
663
664impl<T> Alt<T> {
665    pub fn new(value: T) -> Self {
666        Self(value)
667    }
668}
669
670impl<T> Deref for Alt<T> {
671    type Target = T;
672    fn deref(&self) -> &Self::Target {
673        &self.0
674    }
675}
676
677impl<T> DerefMut for Alt<T> {
678    fn deref_mut(&mut self) -> &mut Self::Target {
679        &mut self.0
680    }
681}
682
683impl<T> From<T> for Alt<T> {
684    fn from(value: T) -> Self {
685        Self::new(value)
686    }
687}
688
689impl<'de, T: Deserialize<'de>> Deserialize<'de> for Alt<T> {
690    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
691        T::deserialize(deserializer).map(Self::new)
692    }
693}
694
695impl<T: Serialize> Serialize for Alt<T> {
696    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
697        self.0.serialize(AltSer::new(serializer))
698    }
699}
700
701/// Wrapper to set the `Altered` state for the inner type.
702/// 
703/// An `Altered` type will be serialized using the [`Z::Alter`](Alter) implementation.
704/// 
705/// This state is propagated to inner values but can be removed with the [`Unaltered`] wrapper.
706/// 
707/// See [`Alt`] and [`Alternative`] for an optional `Altered` state.
708#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
709pub struct Altered<T, Z: ?Sized>(pub T, pub PhantomData<Z>);
710
711impl<T, Z: ?Sized> Altered<T, Z> {
712    pub fn new(value: T) -> Self {
713        Self(value, PhantomData)
714    }
715}
716
717impl<T, Z: ?Sized> Deref for Altered<T, Z> {
718    type Target = T;
719    fn deref(&self) -> &Self::Target {
720        &self.0
721    }
722}
723
724impl<T, Z: ?Sized> DerefMut for Altered<T, Z> {
725    fn deref_mut(&mut self) -> &mut Self::Target {
726        &mut self.0
727    }
728}
729
730impl<T, Z> From<T> for Altered<T, Z> {
731    fn from(value: T) -> Self {
732        Self::new(value)
733    }
734}
735
736impl<'de, T: Deserialize<'de>, Z: ?Sized> Deserialize<'de> for Altered<T, Z> {
737    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
738        T::deserialize(deserializer).map(Self::new)
739    }
740}
741
742impl<T: Serialize, Z: ?Sized + Alter> Serialize for Altered<T, Z> {
743    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
744        self.0.serialize(AlteredSer::<_, Z>::new(serializer))
745    }
746}
747
748/// Wrapper to add an `Alternative` serialization to the inner type.
749/// 
750/// This will activate the [`Altered`] state when triggered by an outer [`Alt`] wrapper.
751#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
752pub struct Alternative<T, Z: ?Sized>(pub T, pub PhantomData<Z>);
753
754impl<T, Z: ?Sized> Alternative<T, Z> {
755    pub fn new(value: T) -> Self {
756        Self(value, PhantomData)
757    }
758}
759
760impl<T, Z: ?Sized> Deref for Alternative<T, Z> {
761    type Target = T;
762    fn deref(&self) -> &Self::Target {
763        &self.0
764    }
765}
766
767impl<T, Z: ?Sized> DerefMut for Alternative<T, Z> {
768    fn deref_mut(&mut self) -> &mut Self::Target {
769        &mut self.0
770    }
771}
772
773impl<T, Z> From<T> for Alternative<T, Z> {
774    fn from(value: T) -> Self {
775        Self::new(value)
776    }
777}
778
779impl<'de, T: Deserialize<'de>, Z: ?Sized> Deserialize<'de> for Alternative<T, Z> {
780    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
781        T::deserialize(deserializer).map(Self::new)
782    }
783}
784
785impl<T: Serialize, Z: ?Sized + Alter> Serialize for Alternative<T, Z> {
786    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
787        let a = serializer.is_human_readable();
788        let b = serializer.is_human_readable();
789        let c = serializer.is_human_readable();
790        if (c != b && a) || (a != b && c) {
791            self.0.serialize(AlteredSer::<_, Z>::new(serializer))
792        } else {
793            self.0.serialize(serializer)
794        }
795    }
796}
797
798/// Wrapper to remove the [`Altered`] state passed down from any outer type.
799#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
800pub struct Unaltered<T>(pub T);
801
802impl<T> Unaltered<T> {
803    pub fn new(value: T) -> Self {
804        Self(value)
805    }
806}
807
808impl<T> Deref for Unaltered<T> {
809    type Target = T;
810    fn deref(&self) -> &Self::Target {
811        &self.0
812    }
813}
814
815impl<T> DerefMut for Unaltered<T> {
816    fn deref_mut(&mut self) -> &mut Self::Target {
817        &mut self.0
818    }
819}
820
821impl<T> From<T> for Unaltered<T> {
822    fn from(value: T) -> Self {
823        Self::new(value)
824    }
825}
826
827impl<'de, T: Deserialize<'de>> Deserialize<'de> for Unaltered<T> {
828    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
829        T::deserialize(deserializer).map(Self::new)
830    }
831}
832
833impl<T: Serialize> Serialize for Unaltered<T> {
834    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
835        let a = serializer.is_human_readable();
836        let b = serializer.is_human_readable();
837        let c = serializer.is_human_readable();
838        if (c != b && !a) || (a != b && !c) {
839            serializer.serialize_newtype_struct(UNALTER, &self.0)
840        } else {
841            self.0.serialize(serializer)
842        }
843    }
844}
845
846/// Function to serialize as if wrapped with [`Alt`].
847/// ```
848/// #[serde(serialize_with = "serde_alter::alt")]
849/// ```
850/// See [serialize_with](https://serde.rs/field-attrs.html#serialize_with).
851pub fn alt<S: Serializer, T: ?Sized + Serialize>(val: &T, ser: S) -> Result<S::Ok, S::Error> {
852    Alt::new(val).serialize(ser)
853}
854
855/// Function to serialize as if wrapped with [`Unaltered`].
856/// ```
857/// #[serde(serialize_with = "serde_alter::unaltered")]
858/// ```
859/// See [serialize_with](https://serde.rs/field-attrs.html#serialize_with).
860pub fn unaltered<S: Serializer, T: ?Sized + Serialize>(val: &T, ser: S) -> Result<S::Ok, S::Error> {
861    Unaltered::new(val).serialize(ser)
862}
863
864const UNALTER: &str = "ƝcƇDˡËljЎґ*ٝêӆߒqЄ˸BɆ̓ =ؔa5͓ns͚e";
serde_alter/alter.rs

serde_alter/
alter.rs
