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    use crate::std::boxed::Box;
768
769    impl value_bag_serde1::lib::Serialize for crate::OwnedValueBag {
770        fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
771        where
772            S: value_bag_serde1::lib::Serializer,
773        {
774            value_bag_serde1::lib::Serialize::serialize(&self.by_ref(), s)
775        }
776    }
777
778    pub(crate) type OwnedSerialize = Box<value_bag_serde1::buf::Owned>;
779
780    pub(crate) fn buffer(
781        v: impl value_bag_serde1::lib::Serialize,
782    ) -> Result<OwnedSerialize, value_bag_serde1::buf::Error> {
783        value_bag_serde1::buf::Owned::buffer(v).map(Box::new)
784    }
785}
786
787#[cfg(test)]
788mod tests {
789    #[cfg(target_arch = "wasm32")]
790    use wasm_bindgen_test::*;
791
792    use super::*;
793    use crate::test::*;
794
795    #[test]
796    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
797    fn serde1_capture() {
798        assert_eq!(
799            ValueBag::capture_serde1(&42u64).to_test_token(),
800            TestToken::U64(42)
801        );
802    }
803
804    #[test]
805    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
806    fn serde1_fill() {
807        assert_eq!(
808            ValueBag::from_fill(&|slot: Slot| slot.fill_serde1(42u64)).to_test_token(),
809            TestToken::Serde { version: 1 },
810        );
811    }
812
813    #[test]
814    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
815    fn serde1_capture_cast() {
816        assert_eq!(
817            42u64,
818            ValueBag::capture_serde1(&42u64)
819                .to_u64()
820                .expect("invalid value")
821        );
822
823        assert_eq!(
824            "a string",
825            ValueBag::capture_serde1(&"a string")
826                .to_borrowed_str()
827                .expect("invalid value")
828        );
829
830        #[cfg(feature = "std")]
831        assert_eq!(
832            "a string",
833            ValueBag::capture_serde1(&"a string")
834                .to_str()
835                .expect("invalid value")
836        );
837    }
838
839    #[test]
840    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
841    fn serde1_from_cast() {
842        assert_eq!(
843            42u64,
844            ValueBag::from_serde1(&42u64)
845                .to_u64()
846                .expect("invalid value")
847        );
848
849        #[cfg(feature = "std")]
850        assert_eq!(
851            "a string",
852            ValueBag::from_serde1(&"a string")
853                .to_str()
854                .expect("invalid value")
855        );
856    }
857
858    #[test]
859    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
860    fn serde1_downcast() {
861        #[derive(Debug, PartialEq, Eq)]
862        struct Timestamp(usize);
863
864        impl value_bag_serde1::lib::Serialize for Timestamp {
865            fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
866            where
867                S: value_bag_serde1::lib::Serializer,
868            {
869                s.serialize_u64(self.0 as u64)
870            }
871        }
872
873        let ts = Timestamp(42);
874
875        assert_eq!(
876            &ts,
877            ValueBag::capture_serde1(&ts)
878                .downcast_ref::<Timestamp>()
879                .expect("invalid value")
880        );
881    }
882
883    #[test]
884    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
885    fn serde1_structured() {
886        use value_bag_serde1::test::{assert_ser_tokens, Token};
887
888        assert_ser_tokens(&ValueBag::from(42u64), &[Token::U64(42)]);
889    }
890
891    #[test]
892    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
893    fn serde1_debug() {
894        struct TestSerde;
895
896        impl value_bag_serde1::lib::Serialize for TestSerde {
897            fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
898            where
899                S: value_bag_serde1::lib::Serializer,
900            {
901                s.serialize_u64(42)
902            }
903        }
904
905        assert_eq!(
906            format!("{:04?}", 42u64),
907            format!("{:04?}", ValueBag::capture_serde1(&TestSerde)),
908        );
909    }
910
911    #[test]
912    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
913    fn serde1_visit() {
914        ValueBag::from_serde1(&42u64)
915            .visit(TestVisit::default())
916            .expect("failed to visit value");
917        ValueBag::from_serde1(&-42i64)
918            .visit(TestVisit::default())
919            .expect("failed to visit value");
920        ValueBag::from_serde1(&11f64)
921            .visit(TestVisit::default())
922            .expect("failed to visit value");
923        ValueBag::from_serde1(&true)
924            .visit(TestVisit::default())
925            .expect("failed to visit value");
926        ValueBag::from_serde1(&"some string")
927            .visit(TestVisit::default())
928            .expect("failed to visit value");
929        ValueBag::from_serde1(&'n')
930            .visit(TestVisit::default())
931            .expect("failed to visit value");
932    }
933
934    #[test]
935    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
936    #[cfg(feature = "sval2")]
937    fn serde1_sval2() {
938        use value_bag_sval2::test::Token;
939
940        struct TestSerde;
941
942        impl value_bag_serde1::lib::Serialize for TestSerde {
943            fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
944            where
945                S: value_bag_serde1::lib::Serializer,
946            {
947                s.serialize_u64(42)
948            }
949        }
950
951        let value = ValueBag::from_serde1(&TestSerde);
952
953        value_bag_sval2::test::assert_tokens(&value, &[Token::U64(42)]);
954    }
955
956    #[cfg(feature = "seq")]
957    mod seq_support {
958        use super::*;
959
960        use crate::std::vec::Vec;
961
962        #[test]
963        #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
964        fn serde1_stream_str_seq() {
965            use value_bag_serde1::test::{assert_ser_tokens, Token};
966
967            assert_ser_tokens(
968                &ValueBag::from_seq_slice(&["a", "b", "c"]),
969                &[
970                    Token::Seq { len: None },
971                    Token::Str("a"),
972                    Token::Str("b"),
973                    Token::Str("c"),
974                    Token::SeqEnd,
975                ],
976            );
977        }
978
979        #[test]
980        #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
981        fn serde1_to_seq() {
982            assert_eq!(
983                vec![Some(1.0), None, Some(2.0), Some(3.0), None],
984                ValueBag::capture_serde1(&[
985                    &1.0 as &dyn Serialize,
986                    &true as &dyn Serialize,
987                    &2.0 as &dyn Serialize,
988                    &3.0 as &dyn Serialize,
989                    &"a string" as &dyn Serialize,
990                ])
991                .to_f64_seq::<Vec<Option<f64>>>()
992                .expect("invalid value")
993            );
994        }
995
996        #[test]
997        #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
998        fn serde1_as_seq() {
999            assert_eq!(
1000                vec![1.0, 2.0, 3.0],
1001                ValueBag::capture_serde1(&[1.0, 2.0, 3.0,]).as_f64_seq::<Vec<f64>>()
1002            );
1003        }
1004    }
1005
1006    #[cfg(feature = "std")]
1007    mod std_support {
1008        use super::*;
1009
1010        use crate::std::borrow::ToOwned;
1011
1012        #[test]
1013        #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
1014        fn serde1_cast() {
1015            assert_eq!(
1016                "a string",
1017                ValueBag::capture_serde1(&"a string".to_owned())
1018                    .by_ref()
1019                    .to_str()
1020                    .expect("invalid value")
1021            );
1022        }
1023    }
1024
1025    #[cfg(feature = "owned")]
1026    mod owned_support {
1027        use super::*;
1028
1029        #[test]
1030        #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
1031        fn serde1_to_owned_poison() {
1032            struct Kaboom;
1033
1034            impl value_bag_serde1::lib::Serialize for Kaboom {
1035                fn serialize<S>(&self, _: S) -> Result<S::Ok, S::Error>
1036                where
1037                    S: value_bag_serde1::lib::Serializer,
1038                {
1039                    Err(S::Error::custom("kaboom"))
1040                }
1041            }
1042
1043            let value = ValueBag::capture_serde1(&Kaboom)
1044                .to_owned()
1045                .by_ref()
1046                .to_test_token();
1047
1048            assert_eq!(
1049                TestToken::Poisoned("failed to buffer the value".into()),
1050                value
1051            );
1052        }
1053    }
1054}
value_bag/internal/serde/v1.rs

value_bag/internal/serde/
v1.rs
