value_bag/internal/serde/
v1.rs

1//! Integration between `Value` and `serde`.
2//!
3//! This module allows any `Value` to implement the `Serialize` trait,
4//! and for any `Serialize` to be captured as a `Value`.
5
6use crate::{
7    fill::Slot,
8    internal::{Internal, InternalVisitor},
9    std::{any::Any, fmt},
10    Error, ValueBag,
11};
12
13use value_bag_serde1::lib::ser::{Error as SerdeError, Impossible};
14
15impl<'v> ValueBag<'v> {
16    /// Get a value from a structured type.
17    ///
18    /// This method will attempt to capture the given value as a well-known primitive
19    /// before resorting to using its `Value` implementation.
20    pub fn capture_serde1<T>(value: &'v T) -> Self
21    where
22        T: value_bag_serde1::lib::Serialize + 'static,
23    {
24        Self::try_capture(value).unwrap_or(ValueBag {
25            inner: Internal::Serde1(value),
26        })
27    }
28
29    /// Get a value from a structured type without capturing support.
30    pub const fn from_serde1<T>(value: &'v T) -> Self
31    where
32        T: value_bag_serde1::lib::Serialize,
33    {
34        ValueBag {
35            inner: Internal::SizedSerde1(value),
36        }
37    }
38
39    // NOTE: no `from_dyn_serde1` until `erased-serde` stabilizes
40    pub(crate) const fn from_dyn_serde1(value: &'v dyn Serialize) -> Self {
41        ValueBag {
42            inner: Internal::AnonSerde1(value),
43        }
44    }
45}
46
47/**
48A value that can be downcast and buffered.
49*/
50pub(crate) trait DowncastSerialize {
51    fn as_any(&self) -> &dyn Any;
52    fn as_super(&self) -> &dyn Serialize;
53    #[cfg(feature = "owned")]
54    fn as_buffer(&self) -> &dyn BufferSerialize;
55}
56
57impl<T: value_bag_serde1::lib::Serialize + 'static> DowncastSerialize for T {
58    fn as_any(&self) -> &dyn Any {
59        self
60    }
61
62    fn as_super(&self) -> &dyn Serialize {
63        self
64    }
65
66    #[cfg(feature = "owned")]
67    fn as_buffer(&self) -> &dyn BufferSerialize {
68        self
69    }
70}
71
72/**
73A value that can be buffered.
74*/
75pub(crate) trait SizedSerialize {
76    fn as_super(&self) -> &dyn Serialize;
77    #[cfg(feature = "owned")]
78    fn as_buffer(&self) -> &dyn BufferSerialize;
79}
80
81impl<T: value_bag_serde1::lib::Serialize> SizedSerialize for T {
82    fn as_super(&self) -> &dyn Serialize {
83        self
84    }
85
86    #[cfg(feature = "owned")]
87    fn as_buffer(&self) -> &dyn BufferSerialize {
88        self
89    }
90}
91
92/**
93A specialization of `Serialize` that is object safe, but buffers generically to avoid more dynamic dispatch.
94*/
95#[cfg(feature = "owned")]
96pub(crate) trait BufferSerialize {
97    fn buffer(&self) -> Result<value_bag_serde1::buf::Owned, value_bag_serde1::buf::Error>;
98}
99
100#[cfg(feature = "owned")]
101impl<V: value_bag_serde1::lib::Serialize + ?Sized> BufferSerialize for V {
102    fn buffer(&self) -> Result<value_bag_serde1::buf::Owned, value_bag_serde1::buf::Error> {
103        value_bag_serde1::buf::Owned::buffer(self)
104    }
105}
106
107impl<'s, 'f> Slot<'s, 'f> {
108    /// Fill the slot with a structured value.
109    ///
110    /// The given value doesn't need to satisfy any particular lifetime constraints.
111    pub fn fill_serde1<T>(self, value: T) -> Result<(), Error>
112    where
113        T: value_bag_serde1::lib::Serialize,
114    {
115        self.fill(|visitor| visitor.serde1(&value))
116    }
117}
118
119impl<'v> value_bag_serde1::lib::Serialize for ValueBag<'v> {
120    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
121    where
122        S: value_bag_serde1::lib::Serializer,
123    {
124        struct Serde1Visitor<S>
125        where
126            S: value_bag_serde1::lib::Serializer,
127        {
128            inner: Option<S>,
129            result: Option<Result<S::Ok, S::Error>>,
130        }
131
132        impl<S> Serde1Visitor<S>
133        where
134            S: value_bag_serde1::lib::Serializer,
135        {
136            fn result(&self) -> Result<(), Error> {
137                match self.result {
138                    Some(Ok(_)) => Ok(()),
139                    Some(Err(ref e)) => Err(Error::serde(e)),
140                    None => Err(Error::msg("`serde` serialization didn't produce a result")),
141                }
142            }
143
144            fn serializer(&mut self) -> Result<S, Error> {
145                self.inner
146                    .take()
147                    .ok_or_else(|| Error::msg("`serde` serializer is in an invalid state"))
148            }
149
150            fn into_result(self) -> Result<S::Ok, S::Error> {
151                self.result.unwrap_or_else(|| {
152                    Err(S::Error::custom(
153                        "`serde` serialization didn't produce a result",
154                    ))
155                })
156            }
157        }
158
159        impl<'v, S> InternalVisitor<'v> for Serde1Visitor<S>
160        where
161            S: value_bag_serde1::lib::Serializer,
162        {
163            fn fill(&mut self, v: &dyn crate::fill::Fill) -> Result<(), Error> {
164                v.fill(Slot::new(self))
165            }
166
167            fn debug(&mut self, v: &dyn fmt::Debug) -> Result<(), Error> {
168                struct DebugToDisplay<T>(T);
169
170                impl<T> fmt::Display for DebugToDisplay<T>
171                where
172                    T: fmt::Debug,
173                {
174                    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
175                        fmt::Debug::fmt(&self.0, f)
176                    }
177                }
178
179                self.result = Some(self.serializer()?.collect_str(&DebugToDisplay(v)));
180                self.result()
181            }
182
183            fn display(&mut self, v: &dyn fmt::Display) -> Result<(), Error> {
184                self.result = Some(self.serializer()?.collect_str(v));
185                self.result()
186            }
187
188            fn u64(&mut self, v: u64) -> Result<(), Error> {
189                self.result = Some(self.serializer()?.serialize_u64(v));
190                self.result()
191            }
192
193            fn i64(&mut self, v: i64) -> Result<(), Error> {
194                self.result = Some(self.serializer()?.serialize_i64(v));
195                self.result()
196            }
197
198            fn u128(&mut self, v: &u128) -> Result<(), Error> {
199                self.result = Some(self.serializer()?.serialize_u128(*v));
200                self.result()
201            }
202
203            fn i128(&mut self, v: &i128) -> Result<(), Error> {
204                self.result = Some(self.serializer()?.serialize_i128(*v));
205                self.result()
206            }
207
208            fn f64(&mut self, v: f64) -> Result<(), Error> {
209                self.result = Some(self.serializer()?.serialize_f64(v));
210                self.result()
211            }
212
213            fn bool(&mut self, v: bool) -> Result<(), Error> {
214                self.result = Some(self.serializer()?.serialize_bool(v));
215                self.result()
216            }
217
218            fn char(&mut self, v: char) -> Result<(), Error> {
219                self.result = Some(self.serializer()?.serialize_char(v));
220                self.result()
221            }
222
223            fn str(&mut self, v: &str) -> Result<(), Error> {
224                self.result = Some(self.serializer()?.serialize_str(v));
225                self.result()
226            }
227
228            fn none(&mut self) -> Result<(), Error> {
229                self.result = Some(self.serializer()?.serialize_none());
230                self.result()
231            }
232
233            #[cfg(feature = "error")]
234            fn error(&mut self, v: &(dyn std::error::Error + 'static)) -> Result<(), Error> {
235                self.result = Some(self.serializer()?.collect_str(v));
236                self.result()
237            }
238
239            #[cfg(feature = "sval2")]
240            fn sval2(&mut self, v: &dyn crate::internal::sval::v2::Value) -> Result<(), Error> {
241                self.result = Some(crate::internal::sval::v2::serde1(self.serializer()?, v));
242                self.result()
243            }
244
245            fn serde1(&mut self, v: &dyn Serialize) -> Result<(), Error> {
246                self.result = Some(value_bag_serde1::erased::serialize(v, self.serializer()?));
247                self.result()
248            }
249
250            #[cfg(feature = "seq")]
251            fn seq(&mut self, v: &dyn crate::internal::seq::Seq) -> Result<(), Error> {
252                self.result = Some(serialize_seq(self.serializer()?, v));
253                self.result()
254            }
255
256            fn poisoned(&mut self, msg: &'static str) -> Result<(), Error> {
257                self.result = Some(Err(S::Error::custom(msg)));
258                self.result()
259            }
260        }
261
262        let mut visitor = Serde1Visitor {
263            inner: Some(s),
264            result: None,
265        };
266
267        self.internal_visit(&mut visitor)
268            .map_err(S::Error::custom)?;
269
270        visitor.into_result()
271    }
272}
273
274pub use value_bag_serde1::erased::Serialize;
275
276pub(in crate::internal) fn fmt(f: &mut fmt::Formatter, v: &dyn Serialize) -> Result<(), Error> {
277    fmt::Debug::fmt(&value_bag_serde1::fmt::to_debug(v), f)?;
278    Ok(())
279}
280
281#[cfg(feature = "sval2")]
282pub(in crate::internal) fn sval2<'sval, S: value_bag_sval2::lib::Stream<'sval> + ?Sized>(
283    s: &mut S,
284    v: &dyn Serialize,
285) -> Result<(), Error> {
286    value_bag_sval2::serde1::stream(s, v).map_err(Error::from_sval2)
287}
288
289#[cfg(feature = "seq")]
290fn serialize_seq<S: value_bag_serde1::lib::Serializer>(
291    s: S,
292    seq: &dyn crate::internal::seq::Seq,
293) -> Result<S::Ok, S::Error> {
294    use crate::std::ops::ControlFlow;
295
296    use value_bag_serde1::lib::ser::SerializeSeq;
297
298    struct SerializeVisitor<S: SerializeSeq> {
299        serializer: S,
300        err: Option<S::Error>,
301    }
302
303    impl<'v, S: SerializeSeq> crate::internal::seq::Visitor<'v> for SerializeVisitor<S> {
304        fn element(&mut self, v: ValueBag) -> ControlFlow<()> {
305            match self.serializer.serialize_element(&v) {
306                Ok(()) => ControlFlow::Continue(()),
307                Err(e) => {
308                    self.err = Some(e);
309                    ControlFlow::Break(())
310                }
311            }
312        }
313    }
314
315    let mut s = SerializeVisitor {
316        serializer: s.serialize_seq(None)?,
317        err: None,
318    };
319    seq.visit(&mut s);
320    if let Some(e) = s.err {
321        return Err(e);
322    }
323
324    s.serializer.end()
325}
326
327pub(crate) fn internal_visit(v: &dyn Serialize, visitor: &mut dyn InternalVisitor<'_>) -> bool {
328    struct VisitorSerializer<'a, 'v>(&'a mut dyn InternalVisitor<'v>);
329
330    impl<'a, 'v> value_bag_serde1::lib::Serializer for VisitorSerializer<'a, 'v> {
331        type Ok = ();
332        type Error = Unsupported;
333
334        type SerializeSeq = Impossible<Self::Ok, Self::Error>;
335        type SerializeTuple = Impossible<Self::Ok, Self::Error>;
336        type SerializeTupleStruct = Impossible<Self::Ok, Self::Error>;
337        type SerializeTupleVariant = Impossible<Self::Ok, Self::Error>;
338        type SerializeMap = Impossible<Self::Ok, Self::Error>;
339        type SerializeStruct = Impossible<Self::Ok, Self::Error>;
340        type SerializeStructVariant = Impossible<Self::Ok, Self::Error>;
341
342        fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
343            self.0.u64(v as u64).map_err(|_| Unsupported)
344        }
345
346        fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
347            self.0.u64(v as u64).map_err(|_| Unsupported)
348        }
349
350        fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
351            self.0.u64(v as u64).map_err(|_| Unsupported)
352        }
353
354        fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
355            self.0.u64(v).map_err(|_| Unsupported)
356        }
357
358        fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
359            self.0.u128(&v).map_err(|_| Unsupported)
360        }
361
362        fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
363            self.0.i64(v as i64).map_err(|_| Unsupported)
364        }
365
366        fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
367            self.0.i64(v as i64).map_err(|_| Unsupported)
368        }
369
370        fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
371            self.0.i64(v as i64).map_err(|_| Unsupported)
372        }
373
374        fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
375            self.0.i64(v).map_err(|_| Unsupported)
376        }
377
378        fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
379            self.0.i128(&v).map_err(|_| Unsupported)
380        }
381
382        fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
383            self.0.f64(v as f64).map_err(|_| Unsupported)
384        }
385
386        fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
387            self.0.f64(v).map_err(|_| Unsupported)
388        }
389
390        fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
391            self.0.char(v).map_err(|_| Unsupported)
392        }
393
394        fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
395            self.0.bool(v).map_err(|_| Unsupported)
396        }
397
398        fn serialize_some<T>(self, v: &T) -> Result<Self::Ok, Self::Error>
399        where
400            T: value_bag_serde1::lib::Serialize + ?Sized,
401        {
402            v.serialize(self)
403        }
404
405        fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
406            self.0.none().map_err(|_| Unsupported)
407        }
408
409        fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
410            self.0.none().map_err(|_| Unsupported)
411        }
412
413        fn serialize_bytes(self, _: &[u8]) -> Result<Self::Ok, Self::Error> {
414            Err(Unsupported)
415        }
416
417        fn serialize_str(self, s: &str) -> Result<Self::Ok, Self::Error> {
418            self.0.str(s).map_err(|_| Unsupported)
419        }
420
421        fn serialize_unit_struct(self, _: &'static str) -> Result<Self::Ok, Self::Error> {
422            Err(Unsupported)
423        }
424
425        fn serialize_unit_variant(
426            self,
427            _: &'static str,
428            _: u32,
429            _: &'static str,
430        ) -> Result<Self::Ok, Self::Error> {
431            Err(Unsupported)
432        }
433
434        fn serialize_newtype_struct<T>(
435            self,
436            _: &'static str,
437            _: &T,
438        ) -> Result<Self::Ok, Self::Error>
439        where
440            T: value_bag_serde1::lib::Serialize + ?Sized,
441        {
442            Err(Unsupported)
443        }
444
445        fn serialize_newtype_variant<T>(
446            self,
447            _: &'static str,
448            _: u32,
449            _: &'static str,
450            _: &T,
451        ) -> Result<Self::Ok, Self::Error>
452        where
453            T: value_bag_serde1::lib::Serialize + ?Sized,
454        {
455            Err(Unsupported)
456        }
457
458        fn serialize_seq(
459            self,
460            _: core::option::Option<usize>,
461        ) -> Result<Self::SerializeSeq, Self::Error> {
462            Err(Unsupported)
463        }
464
465        fn serialize_tuple(self, _: usize) -> Result<Self::SerializeTuple, Self::Error> {
466            Err(Unsupported)
467        }
468
469        fn serialize_tuple_struct(
470            self,
471            _: &'static str,
472            _: usize,
473        ) -> Result<Self::SerializeTupleStruct, Self::Error> {
474            Err(Unsupported)
475        }
476
477        fn serialize_tuple_variant(
478            self,
479            _: &'static str,
480            _: u32,
481            _: &'static str,
482            _: usize,
483        ) -> Result<Self::SerializeTupleVariant, Self::Error> {
484            Err(Unsupported)
485        }
486
487        fn serialize_map(
488            self,
489            _: core::option::Option<usize>,
490        ) -> Result<Self::SerializeMap, Self::Error> {
491            Err(Unsupported)
492        }
493
494        fn serialize_struct(
495            self,
496            _: &'static str,
497            _: usize,
498        ) -> Result<Self::SerializeStruct, Self::Error> {
499            Err(Unsupported)
500        }
501
502        fn serialize_struct_variant(
503            self,
504            _: &'static str,
505            _: u32,
506            _: &'static str,
507            _: usize,
508        ) -> Result<Self::SerializeStructVariant, Self::Error> {
509            Err(Unsupported)
510        }
511    }
512
513    value_bag_serde1::erased::serialize(v, VisitorSerializer(visitor)).is_ok()
514}
515
516impl Error {
517    fn serde(e: impl fmt::Display) -> Self {
518        Error::try_boxed("`serde` serialization failed", e)
519    }
520}
521
522#[derive(Debug)]
523struct Unsupported;
524
525impl fmt::Display for Unsupported {
526    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
527        write!(f, "invalid cast")
528    }
529}
530
531impl value_bag_serde1::lib::ser::Error for Unsupported {
532    fn custom<T>(_: T) -> Self
533    where
534        T: fmt::Display,
535    {
536        Unsupported
537    }
538}
539
540impl value_bag_serde1::lib::ser::StdError for Unsupported {}
541
542#[cfg(feature = "seq")]
543pub(crate) mod seq {
544    use super::*;
545
546    use crate::internal::seq::ExtendValue;
547
548    #[inline]
549    pub(crate) fn extend<'a, S: Default + ExtendValue<'a>>(v: &dyn Serialize) -> Option<S> {
550        use crate::std::marker::PhantomData;
551
552        struct Root<S>(PhantomData<S>);
553
554        struct Seq<S>(S);
555
556        impl<'a, S: Default + ExtendValue<'a>> value_bag_serde1::lib::Serializer for Root<S> {
557            type Ok = S;
558
559            type Error = Unsupported;
560
561            type SerializeSeq = Seq<S>;
562
563            type SerializeTuple = Seq<S>;
564
565            type SerializeTupleStruct = value_bag_serde1::lib::ser::Impossible<S, Unsupported>;
566
567            type SerializeTupleVariant = value_bag_serde1::lib::ser::Impossible<S, Unsupported>;
568
569            type SerializeMap = value_bag_serde1::lib::ser::Impossible<S, Unsupported>;
570
571            type SerializeStruct = value_bag_serde1::lib::ser::Impossible<S, Unsupported>;
572
573            type SerializeStructVariant = value_bag_serde1::lib::ser::Impossible<S, Unsupported>;
574
575            fn serialize_bool(self, _: bool) -> Result<Self::Ok, Self::Error> {
576                Err(Unsupported)
577            }
578
579            fn serialize_i8(self, _: i8) -> Result<Self::Ok, Self::Error> {
580                Err(Unsupported)
581            }
582
583            fn serialize_i16(self, _: i16) -> Result<Self::Ok, Self::Error> {
584                Err(Unsupported)
585            }
586
587            fn serialize_i32(self, _: i32) -> Result<Self::Ok, Self::Error> {
588                Err(Unsupported)
589            }
590
591            fn serialize_i64(self, _: i64) -> Result<Self::Ok, Self::Error> {
592                Err(Unsupported)
593            }
594
595            fn serialize_u8(self, _: u8) -> Result<Self::Ok, Self::Error> {
596                Err(Unsupported)
597            }
598
599            fn serialize_u16(self, _: u16) -> Result<Self::Ok, Self::Error> {
600                Err(Unsupported)
601            }
602
603            fn serialize_u32(self, _: u32) -> Result<Self::Ok, Self::Error> {
604                Err(Unsupported)
605            }
606
607            fn serialize_u64(self, _: u64) -> Result<Self::Ok, Self::Error> {
608                Err(Unsupported)
609            }
610
611            fn serialize_f32(self, _: f32) -> Result<Self::Ok, Self::Error> {
612                Err(Unsupported)
613            }
614
615            fn serialize_f64(self, _: f64) -> Result<Self::Ok, Self::Error> {
616                Err(Unsupported)
617            }
618
619            fn serialize_char(self, _: char) -> Result<Self::Ok, Self::Error> {
620                Err(Unsupported)
621            }
622
623            fn serialize_str(self, _: &str) -> Result<Self::Ok, Self::Error> {
624                Err(Unsupported)
625            }
626
627            fn serialize_bytes(self, _: &[u8]) -> Result<Self::Ok, Self::Error> {
628                Err(Unsupported)
629            }
630
631            fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
632                Err(Unsupported)
633            }
634
635            fn serialize_some<T: value_bag_serde1::lib::Serialize + ?Sized>(
636                self,
637                value: &T,
638            ) -> Result<Self::Ok, Self::Error> {
639                value.serialize(self)
640            }
641
642            fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
643                Err(Unsupported)
644            }
645
646            fn serialize_unit_struct(self, _: &'static str) -> Result<Self::Ok, Self::Error> {
647                Err(Unsupported)
648            }
649
650            fn serialize_unit_variant(
651                self,
652                _: &'static str,
653                _: u32,
654                _: &'static str,
655            ) -> Result<Self::Ok, Self::Error> {
656                Err(Unsupported)
657            }
658
659            fn serialize_newtype_struct<T: value_bag_serde1::lib::Serialize + ?Sized>(
660                self,
661                _: &'static str,
662                _: &T,
663            ) -> Result<Self::Ok, Self::Error> {
664                Err(Unsupported)
665            }
666
667            fn serialize_newtype_variant<T: value_bag_serde1::lib::Serialize + ?Sized>(
668                self,
669                _: &'static str,
670                _: u32,
671                _: &'static str,
672                _: &T,
673            ) -> Result<Self::Ok, Self::Error> {
674                Err(Unsupported)
675            }
676
677            fn serialize_seq(self, _: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
678                Ok(Seq(S::default()))
679            }
680
681            fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
682                self.serialize_seq(Some(len))
683            }
684
685            fn serialize_tuple_struct(
686                self,
687                _: &'static str,
688                _: usize,
689            ) -> Result<Self::SerializeTupleStruct, Self::Error> {
690                Err(Unsupported)
691            }
692
693            fn serialize_tuple_variant(
694                self,
695                _: &'static str,
696                _: u32,
697                _: &'static str,
698                _: usize,
699            ) -> Result<Self::SerializeTupleVariant, Self::Error> {
700                Err(Unsupported)
701            }
702
703            fn serialize_map(self, _: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
704                Err(Unsupported)
705            }
706
707            fn serialize_struct(
708                self,
709                _: &'static str,
710                _: usize,
711            ) -> Result<Self::SerializeStruct, Self::Error> {
712                Err(Unsupported)
713            }
714
715            fn serialize_struct_variant(
716                self,
717                _: &'static str,
718                _: u32,
719                _: &'static str,
720                _: usize,
721            ) -> Result<Self::SerializeStructVariant, Self::Error> {
722                Err(Unsupported)
723            }
724        }
725
726        impl<'a, S: ExtendValue<'a>> value_bag_serde1::lib::ser::SerializeSeq for Seq<S> {
727            type Ok = S;
728
729            type Error = Unsupported;
730
731            fn serialize_element<T: value_bag_serde1::lib::Serialize + ?Sized>(
732                &mut self,
733                value: &T,
734            ) -> Result<(), Self::Error> {
735                self.0.extend(Internal::AnonSerde1(&value));
736                Ok(())
737            }
738
739            fn end(self) -> Result<Self::Ok, Self::Error> {
740                Ok(self.0)
741            }
742        }
743
744        impl<'a, S: ExtendValue<'a>> value_bag_serde1::lib::ser::SerializeTuple for Seq<S> {
745            type Ok = S;
746
747            type Error = Unsupported;
748
749            fn serialize_element<T: value_bag_serde1::lib::Serialize + ?Sized>(
750                &mut self,
751                value: &T,
752            ) -> Result<(), Self::Error> {
753                value_bag_serde1::lib::ser::SerializeSeq::serialize_element(self, value)
754            }
755
756            fn end(self) -> Result<Self::Ok, Self::Error> {
757                value_bag_serde1::lib::ser::SerializeSeq::end(self)
758            }
759        }
760
761        value_bag_serde1::lib::Serialize::serialize(v, Root::<S>(Default::default())).ok()
762    }
763}
764
765#[cfg(feature = "owned")]
766pub(crate) mod owned {
767    impl value_bag_serde1::lib::Serialize for crate::OwnedValueBag {
768        fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
769        where
770            S: value_bag_serde1::lib::Serializer,
771        {
772            value_bag_serde1::lib::Serialize::serialize(&self.by_ref(), s)
773        }
774    }
775
776    pub(crate) type OwnedSerialize = value_bag_serde1::buf::Owned;
777
778    pub(crate) fn buffer(
779        v: impl value_bag_serde1::lib::Serialize,
780    ) -> Result<OwnedSerialize, value_bag_serde1::buf::Error> {
781        value_bag_serde1::buf::Owned::buffer(v)
782    }
783}
784
785#[cfg(test)]
786mod tests {
787    #[cfg(target_arch = "wasm32")]
788    use wasm_bindgen_test::*;
789
790    use super::*;
791    use crate::test::*;
792
793    #[test]
794    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
795    fn serde1_capture() {
796        assert_eq!(
797            ValueBag::capture_serde1(&42u64).to_test_token(),
798            TestToken::U64(42)
799        );
800    }
801
802    #[test]
803    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
804    fn serde1_fill() {
805        assert_eq!(
806            ValueBag::from_fill(&|slot: Slot| slot.fill_serde1(42u64)).to_test_token(),
807            TestToken::Serde { version: 1 },
808        );
809    }
810
811    #[test]
812    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
813    fn serde1_capture_cast() {
814        assert_eq!(
815            42u64,
816            ValueBag::capture_serde1(&42u64)
817                .to_u64()
818                .expect("invalid value")
819        );
820
821        assert_eq!(
822            "a string",
823            ValueBag::capture_serde1(&"a string")
824                .to_borrowed_str()
825                .expect("invalid value")
826        );
827
828        #[cfg(feature = "std")]
829        assert_eq!(
830            "a string",
831            ValueBag::capture_serde1(&"a string")
832                .to_str()
833                .expect("invalid value")
834        );
835    }
836
837    #[test]
838    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
839    fn serde1_from_cast() {
840        assert_eq!(
841            42u64,
842            ValueBag::from_serde1(&42u64)
843                .to_u64()
844                .expect("invalid value")
845        );
846
847        #[cfg(feature = "std")]
848        assert_eq!(
849            "a string",
850            ValueBag::from_serde1(&"a string")
851                .to_str()
852                .expect("invalid value")
853        );
854    }
855
856    #[test]
857    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
858    fn serde1_downcast() {
859        #[derive(Debug, PartialEq, Eq)]
860        struct Timestamp(usize);
861
862        impl value_bag_serde1::lib::Serialize for Timestamp {
863            fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
864            where
865                S: value_bag_serde1::lib::Serializer,
866            {
867                s.serialize_u64(self.0 as u64)
868            }
869        }
870
871        let ts = Timestamp(42);
872
873        assert_eq!(
874            &ts,
875            ValueBag::capture_serde1(&ts)
876                .downcast_ref::<Timestamp>()
877                .expect("invalid value")
878        );
879    }
880
881    #[test]
882    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
883    fn serde1_structured() {
884        use value_bag_serde1::test::{assert_ser_tokens, Token};
885
886        assert_ser_tokens(&ValueBag::from(42u64), &[Token::U64(42)]);
887    }
888
889    #[test]
890    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
891    fn serde1_debug() {
892        struct TestSerde;
893
894        impl value_bag_serde1::lib::Serialize for TestSerde {
895            fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
896            where
897                S: value_bag_serde1::lib::Serializer,
898            {
899                s.serialize_u64(42)
900            }
901        }
902
903        assert_eq!(
904            format!("{:04?}", 42u64),
905            format!("{:04?}", ValueBag::capture_serde1(&TestSerde)),
906        );
907    }
908
909    #[test]
910    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
911    fn serde1_visit() {
912        ValueBag::from_serde1(&42u64)
913            .visit(TestVisit::default())
914            .expect("failed to visit value");
915        ValueBag::from_serde1(&-42i64)
916            .visit(TestVisit::default())
917            .expect("failed to visit value");
918        ValueBag::from_serde1(&11f64)
919            .visit(TestVisit::default())
920            .expect("failed to visit value");
921        ValueBag::from_serde1(&true)
922            .visit(TestVisit::default())
923            .expect("failed to visit value");
924        ValueBag::from_serde1(&"some string")
925            .visit(TestVisit::default())
926            .expect("failed to visit value");
927        ValueBag::from_serde1(&'n')
928            .visit(TestVisit::default())
929            .expect("failed to visit value");
930    }
931
932    #[test]
933    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
934    #[cfg(feature = "sval2")]
935    fn serde1_sval2() {
936        use value_bag_sval2::test::Token;
937
938        struct TestSerde;
939
940        impl value_bag_serde1::lib::Serialize for TestSerde {
941            fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
942            where
943                S: value_bag_serde1::lib::Serializer,
944            {
945                s.serialize_u64(42)
946            }
947        }
948
949        let value = ValueBag::from_serde1(&TestSerde);
950
951        value_bag_sval2::test::assert_tokens(&value, &[Token::U64(42)]);
952    }
953
954    #[cfg(feature = "seq")]
955    mod seq_support {
956        use super::*;
957
958        use crate::std::vec::Vec;
959
960        #[test]
961        #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
962        fn serde1_stream_str_seq() {
963            use value_bag_serde1::test::{assert_ser_tokens, Token};
964
965            assert_ser_tokens(
966                &ValueBag::from_seq_slice(&["a", "b", "c"]),
967                &[
968                    Token::Seq { len: None },
969                    Token::Str("a"),
970                    Token::Str("b"),
971                    Token::Str("c"),
972                    Token::SeqEnd,
973                ],
974            );
975        }
976
977        #[test]
978        #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
979        fn serde1_to_seq() {
980            assert_eq!(
981                vec![Some(1.0), None, Some(2.0), Some(3.0), None],
982                ValueBag::capture_serde1(&[
983                    &1.0 as &dyn Serialize,
984                    &true as &dyn Serialize,
985                    &2.0 as &dyn Serialize,
986                    &3.0 as &dyn Serialize,
987                    &"a string" as &dyn Serialize,
988                ])
989                .to_f64_seq::<Vec<Option<f64>>>()
990                .expect("invalid value")
991            );
992        }
993
994        #[test]
995        #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
996        fn serde1_as_seq() {
997            assert_eq!(
998                vec![1.0, 2.0, 3.0],
999                ValueBag::capture_serde1(&[1.0, 2.0, 3.0,]).as_f64_seq::<Vec<f64>>()
1000            );
1001        }
1002    }
1003
1004    #[cfg(feature = "std")]
1005    mod std_support {
1006        use super::*;
1007
1008        use crate::std::borrow::ToOwned;
1009
1010        #[test]
1011        #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
1012        fn serde1_cast() {
1013            assert_eq!(
1014                "a string",
1015                ValueBag::capture_serde1(&"a string".to_owned())
1016                    .by_ref()
1017                    .to_str()
1018                    .expect("invalid value")
1019            );
1020        }
1021    }
1022
1023    #[cfg(feature = "owned")]
1024    mod owned_support {
1025        use super::*;
1026
1027        #[test]
1028        #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
1029        fn serde1_to_owned_poison() {
1030            struct Kaboom;
1031
1032            impl value_bag_serde1::lib::Serialize for Kaboom {
1033                fn serialize<S>(&self, _: S) -> Result<S::Ok, S::Error>
1034                where
1035                    S: value_bag_serde1::lib::Serializer,
1036                {
1037                    Err(S::Error::custom("kaboom"))
1038                }
1039            }
1040
1041            let value = ValueBag::capture_serde1(&Kaboom)
1042                .to_owned()
1043                .by_ref()
1044                .to_test_token();
1045
1046            assert_eq!(
1047                TestToken::Poisoned("failed to buffer the value".into()),
1048                value
1049            );
1050        }
1051    }
1052}
value_bag/internal/serde/v1.rs

value_bag/internal/serde/
v1.rs
