palette/serde/
alpha_serializer.rs

Help
1use serde::{
2    ser::{
3        SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant, SerializeTuple,
4        SerializeTupleStruct, SerializeTupleVariant,
5    },
6    Serialize, Serializer,
7};
8
9/// Serializes a color with an attached alpha value. The alpha value is added
10/// alongside the other values in a flattened structure.
11pub(crate) struct AlphaSerializer<'a, S, A> {
12    pub inner: S,
13    pub alpha: &'a A,
14}
15
16impl<'a, S, A> Serializer for AlphaSerializer<'a, S, A>
17where
18    S: Serializer,
19    A: Serialize,
20{
21    type Ok = S::Ok;
22
23    type Error = S::Error;
24
25    type SerializeSeq = AlphaSerializer<'a, S::SerializeSeq, A>;
26
27    type SerializeTuple = AlphaSerializer<'a, S::SerializeTuple, A>;
28
29    type SerializeTupleStruct = AlphaSerializer<'a, S::SerializeTupleStruct, A>;
30
31    type SerializeTupleVariant = AlphaSerializer<'a, S::SerializeTupleVariant, A>;
32
33    type SerializeMap = AlphaSerializer<'a, S::SerializeMap, A>;
34
35    type SerializeStruct = AlphaSerializer<'a, S::SerializeStruct, A>;
36
37    type SerializeStructVariant = AlphaSerializer<'a, S::SerializeStructVariant, A>;
38
39    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
40        Ok(AlphaSerializer {
41            inner: self.inner.serialize_seq(len.map(|len| len + 1))?,
42            alpha: self.alpha,
43        })
44    }
45
46    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
47        Ok(AlphaSerializer {
48            inner: self.inner.serialize_tuple(len + 1)?,
49            alpha: self.alpha,
50        })
51    }
52
53    fn serialize_tuple_struct(
54        self,
55        name: &'static str,
56        len: usize,
57    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
58        Ok(AlphaSerializer {
59            inner: self.inner.serialize_tuple_struct(name, len + 1)?,
60            alpha: self.alpha,
61        })
62    }
63
64    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
65        Ok(AlphaSerializer {
66            inner: self.inner.serialize_map(len.map(|len| len + 1))?,
67            alpha: self.alpha,
68        })
69    }
70
71    fn serialize_struct(
72        self,
73        name: &'static str,
74        len: usize,
75    ) -> Result<Self::SerializeStruct, Self::Error> {
76        Ok(AlphaSerializer {
77            inner: self.inner.serialize_struct(name, len + 1)?,
78            alpha: self.alpha,
79        })
80    }
81
82    fn serialize_newtype_struct<T>(
83        self,
84        name: &'static str,
85        value: &T,
86    ) -> Result<Self::Ok, Self::Error>
87    where
88        T: serde::Serialize + ?Sized,
89    {
90        let mut serializer = self.serialize_tuple_struct(name, 1)?;
91        serializer.serialize_field(value)?;
92        serializer.end()
93    }
94
95    fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, Self::Error> {
96        self.inner.serialize_newtype_struct(name, self.alpha)
97    }
98
99    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
100        self.serialize_tuple(0)?.end()
101    }
102
103    // Unsupported methods:
104
105    fn serialize_bool(self, _v: bool) -> Result<Self::Ok, Self::Error> {
106        alpha_serializer_error()
107    }
108
109    fn serialize_i8(self, _v: i8) -> Result<Self::Ok, Self::Error> {
110        alpha_serializer_error()
111    }
112
113    fn serialize_i16(self, _v: i16) -> Result<Self::Ok, Self::Error> {
114        alpha_serializer_error()
115    }
116
117    fn serialize_i32(self, _v: i32) -> Result<Self::Ok, Self::Error> {
118        alpha_serializer_error()
119    }
120
121    fn serialize_i64(self, _v: i64) -> Result<Self::Ok, Self::Error> {
122        alpha_serializer_error()
123    }
124
125    fn serialize_u8(self, _v: u8) -> Result<Self::Ok, Self::Error> {
126        alpha_serializer_error()
127    }
128
129    fn serialize_u16(self, _v: u16) -> Result<Self::Ok, Self::Error> {
130        alpha_serializer_error()
131    }
132
133    fn serialize_u32(self, _v: u32) -> Result<Self::Ok, Self::Error> {
134        alpha_serializer_error()
135    }
136
137    fn serialize_u64(self, _v: u64) -> Result<Self::Ok, Self::Error> {
138        alpha_serializer_error()
139    }
140
141    fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> {
142        alpha_serializer_error()
143    }
144
145    fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Self::Error> {
146        alpha_serializer_error()
147    }
148
149    fn serialize_char(self, _v: char) -> Result<Self::Ok, Self::Error> {
150        alpha_serializer_error()
151    }
152
153    fn serialize_str(self, _v: &str) -> Result<Self::Ok, Self::Error> {
154        alpha_serializer_error()
155    }
156
157    fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> {
158        alpha_serializer_error()
159    }
160
161    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
162        alpha_serializer_error()
163    }
164
165    fn serialize_some<T>(self, _value: &T) -> Result<Self::Ok, Self::Error>
166    where
167        T: serde::Serialize + ?Sized,
168    {
169        alpha_serializer_error()
170    }
171
172    fn serialize_tuple_variant(
173        self,
174        _name: &'static str,
175        _variant_index: u32,
176        _variant: &'static str,
177        _len: usize,
178    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
179        alpha_serializer_error()
180    }
181
182    fn serialize_struct_variant(
183        self,
184        _name: &'static str,
185        _variant_index: u32,
186        _variant: &'static str,
187        _len: usize,
188    ) -> Result<Self::SerializeStructVariant, Self::Error> {
189        alpha_serializer_error()
190    }
191
192    fn serialize_unit_variant(
193        self,
194        _name: &'static str,
195        _variant_index: u32,
196        _variant: &'static str,
197    ) -> Result<Self::Ok, Self::Error> {
198        alpha_serializer_error()
199    }
200
201    fn serialize_newtype_variant<T>(
202        self,
203        _name: &'static str,
204        _variant_index: u32,
205        _variant: &'static str,
206        _value: &T,
207    ) -> Result<Self::Ok, Self::Error>
208    where
209        T: serde::Serialize + ?Sized,
210    {
211        alpha_serializer_error()
212    }
213
214    fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
215        let _ = v;
216        alpha_serializer_error()
217    }
218
219    fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
220        let _ = v;
221        alpha_serializer_error()
222    }
223
224    fn is_human_readable(&self) -> bool {
225        self.inner.is_human_readable()
226    }
227}
228
229fn alpha_serializer_error() -> ! {
230    unimplemented!("AlphaSerializer can only serialize structs, maps and sequences")
231}
232
233impl<'a, S, A> SerializeSeq for AlphaSerializer<'a, S, A>
234where
235    S: SerializeSeq,
236    A: Serialize,
237{
238    type Ok = S::Ok;
239
240    type Error = S::Error;
241
242    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
243    where
244        T: Serialize + ?Sized,
245    {
246        self.inner.serialize_element(value)
247    }
248
249    fn end(mut self) -> Result<Self::Ok, Self::Error> {
250        self.inner.serialize_element(self.alpha)?;
251        self.inner.end()
252    }
253}
254
255impl<'a, S, A> SerializeTuple for AlphaSerializer<'a, S, A>
256where
257    S: SerializeTuple,
258    A: Serialize,
259{
260    type Ok = S::Ok;
261
262    type Error = S::Error;
263
264    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
265    where
266        T: Serialize + ?Sized,
267    {
268        self.inner.serialize_element(value)
269    }
270
271    fn end(mut self) -> Result<Self::Ok, Self::Error> {
272        self.inner.serialize_element(self.alpha)?;
273        self.inner.end()
274    }
275}
276
277impl<'a, S, A> SerializeTupleStruct for AlphaSerializer<'a, S, A>
278where
279    S: SerializeTupleStruct,
280    A: Serialize,
281{
282    type Ok = S::Ok;
283
284    type Error = S::Error;
285
286    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
287    where
288        T: Serialize + ?Sized,
289    {
290        self.inner.serialize_field(value)
291    }
292
293    fn end(mut self) -> Result<Self::Ok, Self::Error> {
294        self.inner.serialize_field(self.alpha)?;
295        self.inner.end()
296    }
297}
298
299impl<'a, S, A> SerializeTupleVariant for AlphaSerializer<'a, S, A>
300where
301    S: SerializeTupleVariant,
302    A: Serialize,
303{
304    type Ok = S::Ok;
305
306    type Error = S::Error;
307
308    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
309    where
310        T: Serialize + ?Sized,
311    {
312        self.inner.serialize_field(value)
313    }
314
315    fn end(mut self) -> Result<Self::Ok, Self::Error> {
316        self.inner.serialize_field(self.alpha)?;
317        self.inner.end()
318    }
319}
320
321impl<'a, S, A> SerializeMap for AlphaSerializer<'a, S, A>
322where
323    S: SerializeMap,
324    A: Serialize,
325{
326    type Ok = S::Ok;
327
328    type Error = S::Error;
329
330    fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
331    where
332        T: Serialize + ?Sized,
333    {
334        self.inner.serialize_key(key)
335    }
336
337    fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
338    where
339        T: Serialize + ?Sized,
340    {
341        self.inner.serialize_value(value)
342    }
343
344    fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<(), Self::Error>
345    where
346        K: Serialize + ?Sized,
347        V: Serialize + ?Sized,
348    {
349        self.inner.serialize_entry(key, value)
350    }
351
352    fn end(mut self) -> Result<Self::Ok, Self::Error> {
353        self.inner.serialize_entry("alpha", self.alpha)?;
354        self.inner.end()
355    }
356}
357
358impl<'a, S, A> SerializeStruct for AlphaSerializer<'a, S, A>
359where
360    S: SerializeStruct,
361    A: Serialize,
362{
363    type Ok = S::Ok;
364
365    type Error = S::Error;
366
367    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
368    where
369        T: Serialize + ?Sized,
370    {
371        self.inner.serialize_field(key, value)
372    }
373
374    fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error> {
375        self.inner.skip_field(key)
376    }
377
378    fn end(mut self) -> Result<Self::Ok, Self::Error> {
379        self.inner.serialize_field("alpha", self.alpha)?;
380        self.inner.end()
381    }
382}
383
384impl<'a, S, A> SerializeStructVariant for AlphaSerializer<'a, S, A>
385where
386    S: SerializeStructVariant,
387    A: Serialize,
388{
389    type Ok = S::Ok;
390
391    type Error = S::Error;
392
393    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
394    where
395        T: Serialize + ?Sized,
396    {
397        self.inner.serialize_field(key, value)
398    }
399
400    fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error> {
401        self.inner.skip_field(key)
402    }
403
404    fn end(mut self) -> Result<Self::Ok, Self::Error> {
405        self.inner.serialize_field("alpha", self.alpha)?;
406        self.inner.end()
407    }
408}
palette/serde/alpha_serializer.rs

palette/serde/
alpha_serializer.rs
