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(
235                &mut self,
236                v: &(dyn crate::internal::error::Error + 'static),
237            ) -> Result<(), Error> {
238                self.result = Some(self.serializer()?.collect_str(v));
239                self.result()
240            }
241
242            #[cfg(feature = "sval2")]
243            fn sval2(&mut self, v: &dyn crate::internal::sval::v2::Value) -> Result<(), Error> {
244                self.result = Some(crate::internal::sval::v2::serde1(self.serializer()?, v));
245                self.result()
246            }
247
248            fn serde1(&mut self, v: &dyn Serialize) -> Result<(), Error> {
249                self.result = Some(value_bag_serde1::erased::serialize(v, self.serializer()?));
250                self.result()
251            }
252
253            #[cfg(feature = "seq")]
254            fn seq(&mut self, v: &dyn crate::internal::seq::Seq) -> Result<(), Error> {
255                self.result = Some(serialize_seq(self.serializer()?, v));
256                self.result()
257            }
258
259            fn poisoned(&mut self, msg: &'static str) -> Result<(), Error> {
260                self.result = Some(Err(S::Error::custom(msg)));
261                self.result()
262            }
263        }
264
265        let mut visitor = Serde1Visitor {
266            inner: Some(s),
267            result: None,
268        };
269
270        self.internal_visit(&mut visitor)
271            .map_err(S::Error::custom)?;
272
273        visitor.into_result()
274    }
275}
276
277pub use value_bag_serde1::erased::Serialize;
278
279pub(in crate::internal) fn fmt(f: &mut fmt::Formatter, v: &dyn Serialize) -> Result<(), Error> {
280    fmt::Debug::fmt(&value_bag_serde1::fmt::to_debug(v), f)?;
281    Ok(())
282}
283
284#[cfg(feature = "sval2")]
285pub(in crate::internal) fn sval2<'sval, S: value_bag_sval2::lib::Stream<'sval> + ?Sized>(
286    s: &mut S,
287    v: &dyn Serialize,
288) -> Result<(), Error> {
289    value_bag_sval2::serde1::stream(s, v).map_err(Error::from_sval2)
290}
291
292#[cfg(feature = "seq")]
293fn serialize_seq<S: value_bag_serde1::lib::Serializer>(
294    s: S,
295    seq: &dyn crate::internal::seq::Seq,
296) -> Result<S::Ok, S::Error> {
297    use crate::std::ops::ControlFlow;
298
299    use value_bag_serde1::lib::ser::SerializeSeq;
300
301    struct SerializeVisitor<S: SerializeSeq> {
302        serializer: S,
303        err: Option<S::Error>,
304    }
305
306    impl<'v, S: SerializeSeq> crate::internal::seq::Visitor<'v> for SerializeVisitor<S> {
307        fn element(&mut self, v: ValueBag) -> ControlFlow<()> {
308            match self.serializer.serialize_element(&v) {
309                Ok(()) => ControlFlow::Continue(()),
310                Err(e) => {
311                    self.err = Some(e);
312                    ControlFlow::Break(())
313                }
314            }
315        }
316    }
317
318    let mut s = SerializeVisitor {
319        serializer: s.serialize_seq(None)?,
320        err: None,
321    };
322    seq.visit(&mut s);
323    if let Some(e) = s.err {
324        return Err(e);
325    }
326
327    s.serializer.end()
328}
329
330pub(crate) fn internal_visit(v: &dyn Serialize, visitor: &mut dyn InternalVisitor<'_>) -> bool {
331    struct VisitorSerializer<'a, 'v>(&'a mut dyn InternalVisitor<'v>);
332
333    impl<'a, 'v> value_bag_serde1::lib::Serializer for VisitorSerializer<'a, 'v> {
334        type Ok = ();
335        type Error = Unsupported;
336
337        type SerializeSeq = Impossible<Self::Ok, Self::Error>;
338        type SerializeTuple = Impossible<Self::Ok, Self::Error>;
339        type SerializeTupleStruct = Impossible<Self::Ok, Self::Error>;
340        type SerializeTupleVariant = Impossible<Self::Ok, Self::Error>;
341        type SerializeMap = Impossible<Self::Ok, Self::Error>;
342        type SerializeStruct = Impossible<Self::Ok, Self::Error>;
343        type SerializeStructVariant = Impossible<Self::Ok, Self::Error>;
344
345        fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
346            self.0.u64(v as u64).map_err(|_| Unsupported)
347        }
348
349        fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
350            self.0.u64(v as u64).map_err(|_| Unsupported)
351        }
352
353        fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
354            self.0.u64(v as u64).map_err(|_| Unsupported)
355        }
356
357        fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
358            self.0.u64(v).map_err(|_| Unsupported)
359        }
360
361        fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
362            self.0.u128(&v).map_err(|_| Unsupported)
363        }
364
365        fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
366            self.0.i64(v as i64).map_err(|_| Unsupported)
367        }
368
369        fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
370            self.0.i64(v as i64).map_err(|_| Unsupported)
371        }
372
373        fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
374            self.0.i64(v as i64).map_err(|_| Unsupported)
375        }
376
377        fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
378            self.0.i64(v).map_err(|_| Unsupported)
379        }
380
381        fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
382            self.0.i128(&v).map_err(|_| Unsupported)
383        }
384
385        fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
386            self.0.f64(v as f64).map_err(|_| Unsupported)
387        }
388
389        fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
390            self.0.f64(v).map_err(|_| Unsupported)
391        }
392
393        fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
394            self.0.char(v).map_err(|_| Unsupported)
395        }
396
397        fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
398            self.0.bool(v).map_err(|_| Unsupported)
399        }
400
401        fn serialize_some<T>(self, v: &T) -> Result<Self::Ok, Self::Error>
402        where
403            T: value_bag_serde1::lib::Serialize + ?Sized,
404        {
405            v.serialize(self)
406        }
407
408        fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
409            self.0.none().map_err(|_| Unsupported)
410        }
411
412        fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
413            self.0.none().map_err(|_| Unsupported)
414        }
415
416        fn serialize_bytes(self, _: &[u8]) -> Result<Self::Ok, Self::Error> {
417            Err(Unsupported)
418        }
419
420        fn serialize_str(self, s: &str) -> Result<Self::Ok, Self::Error> {
421            self.0.str(s).map_err(|_| Unsupported)
422        }
423
424        fn serialize_unit_struct(self, _: &'static str) -> Result<Self::Ok, Self::Error> {
425            Err(Unsupported)
426        }
427
428        fn serialize_unit_variant(
429            self,
430            _: &'static str,
431            _: u32,
432            _: &'static str,
433        ) -> Result<Self::Ok, Self::Error> {
434            Err(Unsupported)
435        }
436
437        fn serialize_newtype_struct<T>(
438            self,
439            _: &'static str,
440            _: &T,
441        ) -> Result<Self::Ok, Self::Error>
442        where
443            T: value_bag_serde1::lib::Serialize + ?Sized,
444        {
445            Err(Unsupported)
446        }
447
448        fn serialize_newtype_variant<T>(
449            self,
450            _: &'static str,
451            _: u32,
452            _: &'static str,
453            _: &T,
454        ) -> Result<Self::Ok, Self::Error>
455        where
456            T: value_bag_serde1::lib::Serialize + ?Sized,
457        {
458            Err(Unsupported)
459        }
460
461        fn serialize_seq(
462            self,
463            _: core::option::Option<usize>,
464        ) -> Result<Self::SerializeSeq, Self::Error> {
465            Err(Unsupported)
466        }
467
468        fn serialize_tuple(self, _: usize) -> Result<Self::SerializeTuple, Self::Error> {
469            Err(Unsupported)
470        }
471
472        fn serialize_tuple_struct(
473            self,
474            _: &'static str,
475            _: usize,
476        ) -> Result<Self::SerializeTupleStruct, Self::Error> {
477            Err(Unsupported)
478        }
479
480        fn serialize_tuple_variant(
481            self,
482            _: &'static str,
483            _: u32,
484            _: &'static str,
485            _: usize,
486        ) -> Result<Self::SerializeTupleVariant, Self::Error> {
487            Err(Unsupported)
488        }
489
490        fn serialize_map(
491            self,
492            _: core::option::Option<usize>,
493        ) -> Result<Self::SerializeMap, Self::Error> {
494            Err(Unsupported)
495        }
496
497        fn serialize_struct(
498            self,
499            _: &'static str,
500            _: usize,
501        ) -> Result<Self::SerializeStruct, Self::Error> {
502            Err(Unsupported)
503        }
504
505        fn serialize_struct_variant(
506            self,
507            _: &'static str,
508            _: u32,
509            _: &'static str,
510            _: usize,
511        ) -> Result<Self::SerializeStructVariant, Self::Error> {
512            Err(Unsupported)
513        }
514    }
515
516    value_bag_serde1::erased::serialize(v, VisitorSerializer(visitor)).is_ok()
517}
518
519impl Error {
520    fn serde(e: impl fmt::Display) -> Self {
521        Error::try_boxed("`serde` serialization failed", e)
522    }
523}
524
525#[derive(Debug)]
526struct Unsupported;
527
528impl fmt::Display for Unsupported {
529    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
530        write!(f, "invalid cast")
531    }
532}
533
534impl value_bag_serde1::lib::ser::Error for Unsupported {
535    fn custom<T>(_: T) -> Self
536    where
537        T: fmt::Display,
538    {
539        Unsupported
540    }
541}
542
543impl value_bag_serde1::lib::ser::StdError for Unsupported {}
544
545#[cfg(feature = "seq")]
546pub(crate) mod seq {
547    use super::*;
548
549    use crate::internal::seq::ExtendValue;
550
551    #[inline]
552    pub(crate) fn extend<'a, S: Default + ExtendValue<'a>>(v: &dyn Serialize) -> Option<S> {
553        use crate::std::marker::PhantomData;
554
555        struct Root<S>(PhantomData<S>);
556
557        struct Seq<S>(S);
558
559        impl<'a, S: Default + ExtendValue<'a>> value_bag_serde1::lib::Serializer for Root<S> {
560            type Ok = S;
561
562            type Error = Unsupported;
563
564            type SerializeSeq = Seq<S>;
565
566            type SerializeTuple = Seq<S>;
567
568            type SerializeTupleStruct = value_bag_serde1::lib::ser::Impossible<S, Unsupported>;
569
570            type SerializeTupleVariant = value_bag_serde1::lib::ser::Impossible<S, Unsupported>;
571
572            type SerializeMap = value_bag_serde1::lib::ser::Impossible<S, Unsupported>;
573
574            type SerializeStruct = value_bag_serde1::lib::ser::Impossible<S, Unsupported>;
575
576            type SerializeStructVariant = value_bag_serde1::lib::ser::Impossible<S, Unsupported>;
577
578            fn serialize_bool(self, _: bool) -> Result<Self::Ok, Self::Error> {
579                Err(Unsupported)
580            }
581
582            fn serialize_i8(self, _: i8) -> Result<Self::Ok, Self::Error> {
583                Err(Unsupported)
584            }
585
586            fn serialize_i16(self, _: i16) -> Result<Self::Ok, Self::Error> {
587                Err(Unsupported)
588            }
589
590            fn serialize_i32(self, _: i32) -> Result<Self::Ok, Self::Error> {
591                Err(Unsupported)
592            }
593
594            fn serialize_i64(self, _: i64) -> Result<Self::Ok, Self::Error> {
595                Err(Unsupported)
596            }
597
598            fn serialize_u8(self, _: u8) -> Result<Self::Ok, Self::Error> {
599                Err(Unsupported)
600            }
601
602            fn serialize_u16(self, _: u16) -> Result<Self::Ok, Self::Error> {
603                Err(Unsupported)
604            }
605
606            fn serialize_u32(self, _: u32) -> Result<Self::Ok, Self::Error> {
607                Err(Unsupported)
608            }
609
610            fn serialize_u64(self, _: u64) -> Result<Self::Ok, Self::Error> {
611                Err(Unsupported)
612            }
613
614            fn serialize_f32(self, _: f32) -> Result<Self::Ok, Self::Error> {
615                Err(Unsupported)
616            }
617
618            fn serialize_f64(self, _: f64) -> Result<Self::Ok, Self::Error> {
619                Err(Unsupported)
620            }
621
622            fn serialize_char(self, _: char) -> Result<Self::Ok, Self::Error> {
623                Err(Unsupported)
624            }
625
626            fn serialize_str(self, _: &str) -> Result<Self::Ok, Self::Error> {
627                Err(Unsupported)
628            }
629
630            fn serialize_bytes(self, _: &[u8]) -> Result<Self::Ok, Self::Error> {
631                Err(Unsupported)
632            }
633
634            fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
635                Err(Unsupported)
636            }
637
638            fn serialize_some<T: value_bag_serde1::lib::Serialize + ?Sized>(
639                self,
640                value: &T,
641            ) -> Result<Self::Ok, Self::Error> {
642                value.serialize(self)
643            }
644
645            fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
646                Err(Unsupported)
647            }
648
649            fn serialize_unit_struct(self, _: &'static str) -> Result<Self::Ok, Self::Error> {
650                Err(Unsupported)
651            }
652
653            fn serialize_unit_variant(
654                self,
655                _: &'static str,
656                _: u32,
657                _: &'static str,
658            ) -> Result<Self::Ok, Self::Error> {
659                Err(Unsupported)
660            }
661
662            fn serialize_newtype_struct<T: value_bag_serde1::lib::Serialize + ?Sized>(
663                self,
664                _: &'static str,
665                _: &T,
666            ) -> Result<Self::Ok, Self::Error> {
667                Err(Unsupported)
668            }
669
670            fn serialize_newtype_variant<T: value_bag_serde1::lib::Serialize + ?Sized>(
671                self,
672                _: &'static str,
673                _: u32,
674                _: &'static str,
675                _: &T,
676            ) -> Result<Self::Ok, Self::Error> {
677                Err(Unsupported)
678            }
679
680            fn serialize_seq(self, _: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
681                Ok(Seq(S::default()))
682            }
683
684            fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
685                self.serialize_seq(Some(len))
686            }
687
688            fn serialize_tuple_struct(
689                self,
690                _: &'static str,
691                _: usize,
692            ) -> Result<Self::SerializeTupleStruct, Self::Error> {
693                Err(Unsupported)
694            }
695
696            fn serialize_tuple_variant(
697                self,
698                _: &'static str,
699                _: u32,
700                _: &'static str,
701                _: usize,
702            ) -> Result<Self::SerializeTupleVariant, Self::Error> {
703                Err(Unsupported)
704            }
705
706            fn serialize_map(self, _: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
707                Err(Unsupported)
708            }
709
710            fn serialize_struct(
711                self,
712                _: &'static str,
713                _: usize,
714            ) -> Result<Self::SerializeStruct, Self::Error> {
715                Err(Unsupported)
716            }
717
718            fn serialize_struct_variant(
719                self,
720                _: &'static str,
721                _: u32,
722                _: &'static str,
723                _: usize,
724            ) -> Result<Self::SerializeStructVariant, Self::Error> {
725                Err(Unsupported)
726            }
727        }
728
729        impl<'a, S: ExtendValue<'a>> value_bag_serde1::lib::ser::SerializeSeq for Seq<S> {
730            type Ok = S;
731
732            type Error = Unsupported;
733
734            fn serialize_element<T: value_bag_serde1::lib::Serialize + ?Sized>(
735                &mut self,
736                value: &T,
737            ) -> Result<(), Self::Error> {
738                self.0.extend(Internal::AnonSerde1(&value));
739                Ok(())
740            }
741
742            fn end(self) -> Result<Self::Ok, Self::Error> {
743                Ok(self.0)
744            }
745        }
746
747        impl<'a, S: ExtendValue<'a>> value_bag_serde1::lib::ser::SerializeTuple for Seq<S> {
748            type Ok = S;
749
750            type Error = Unsupported;
751
752            fn serialize_element<T: value_bag_serde1::lib::Serialize + ?Sized>(
753                &mut self,
754                value: &T,
755            ) -> Result<(), Self::Error> {
756                value_bag_serde1::lib::ser::SerializeSeq::serialize_element(self, value)
757            }
758
759            fn end(self) -> Result<Self::Ok, Self::Error> {
760                value_bag_serde1::lib::ser::SerializeSeq::end(self)
761            }
762        }
763
764        value_bag_serde1::lib::Serialize::serialize(v, Root::<S>(Default::default())).ok()
765    }
766}
767
768#[cfg(feature = "owned")]
769pub(crate) mod owned {
770    impl value_bag_serde1::lib::Serialize for crate::OwnedValueBag {
771        fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
772        where
773            S: value_bag_serde1::lib::Serializer,
774        {
775            value_bag_serde1::lib::Serialize::serialize(&self.by_ref(), s)
776        }
777    }
778
779    pub(crate) type OwnedSerialize = value_bag_serde1::buf::Owned;
780
781    pub(crate) fn buffer(
782        v: impl value_bag_serde1::lib::Serialize,
783    ) -> Result<OwnedSerialize, value_bag_serde1::buf::Error> {
784        value_bag_serde1::buf::Owned::buffer(v)
785    }
786}
787
788#[cfg(test)]
789mod tests {
790    #[cfg(target_arch = "wasm32")]
791    use wasm_bindgen_test::*;
792
793    use super::*;
794    use crate::test::*;
795
796    #[test]
797    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
798    fn serde1_capture() {
799        assert_eq!(
800            ValueBag::capture_serde1(&42u64).to_test_token(),
801            TestToken::U64(42)
802        );
803    }
804
805    #[test]
806    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
807    fn serde1_fill() {
808        assert_eq!(
809            ValueBag::from_fill(&|slot: Slot| slot.fill_serde1(42u64)).to_test_token(),
810            TestToken::Serde { version: 1 },
811        );
812    }
813
814    #[test]
815    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
816    fn serde1_capture_cast() {
817        assert_eq!(
818            42u64,
819            ValueBag::capture_serde1(&42u64)
820                .to_u64()
821                .expect("invalid value")
822        );
823
824        assert_eq!(
825            "a string",
826            ValueBag::capture_serde1(&"a string")
827                .to_borrowed_str()
828                .expect("invalid value")
829        );
830
831        #[cfg(feature = "std")]
832        assert_eq!(
833            "a string",
834            ValueBag::capture_serde1(&"a string")
835                .to_str()
836                .expect("invalid value")
837        );
838    }
839
840    #[test]
841    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
842    fn serde1_from_cast() {
843        assert_eq!(
844            42u64,
845            ValueBag::from_serde1(&42u64)
846                .to_u64()
847                .expect("invalid value")
848        );
849
850        #[cfg(feature = "std")]
851        assert_eq!(
852            "a string",
853            ValueBag::from_serde1(&"a string")
854                .to_str()
855                .expect("invalid value")
856        );
857    }
858
859    #[test]
860    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
861    fn serde1_downcast() {
862        #[derive(Debug, PartialEq, Eq)]
863        struct Timestamp(usize);
864
865        impl value_bag_serde1::lib::Serialize for Timestamp {
866            fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
867            where
868                S: value_bag_serde1::lib::Serializer,
869            {
870                s.serialize_u64(self.0 as u64)
871            }
872        }
873
874        let ts = Timestamp(42);
875
876        assert_eq!(
877            &ts,
878            ValueBag::capture_serde1(&ts)
879                .downcast_ref::<Timestamp>()
880                .expect("invalid value")
881        );
882    }
883
884    #[test]
885    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
886    fn serde1_structured() {
887        use value_bag_serde1::test::{assert_ser_tokens, Token};
888
889        assert_ser_tokens(&ValueBag::from(42u64), &[Token::U64(42)]);
890    }
891
892    #[test]
893    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
894    fn serde1_debug() {
895        struct TestSerde;
896
897        impl value_bag_serde1::lib::Serialize for TestSerde {
898            fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
899            where
900                S: value_bag_serde1::lib::Serializer,
901            {
902                s.serialize_u64(42)
903            }
904        }
905
906        assert_eq!(
907            format!("{:04?}", 42u64),
908            format!("{:04?}", ValueBag::capture_serde1(&TestSerde)),
909        );
910    }
911
912    #[test]
913    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
914    fn serde1_visit() {
915        ValueBag::from_serde1(&42u64)
916            .visit(TestVisit::default())
917            .expect("failed to visit value");
918        ValueBag::from_serde1(&-42i64)
919            .visit(TestVisit::default())
920            .expect("failed to visit value");
921        ValueBag::from_serde1(&11f64)
922            .visit(TestVisit::default())
923            .expect("failed to visit value");
924        ValueBag::from_serde1(&true)
925            .visit(TestVisit::default())
926            .expect("failed to visit value");
927        ValueBag::from_serde1(&"some string")
928            .visit(TestVisit::default())
929            .expect("failed to visit value");
930        ValueBag::from_serde1(&'n')
931            .visit(TestVisit::default())
932            .expect("failed to visit value");
933    }
934
935    #[test]
936    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
937    #[cfg(feature = "sval2")]
938    fn serde1_sval2() {
939        use value_bag_sval2::test::Token;
940
941        struct TestSerde;
942
943        impl value_bag_serde1::lib::Serialize for TestSerde {
944            fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
945            where
946                S: value_bag_serde1::lib::Serializer,
947            {
948                s.serialize_u64(42)
949            }
950        }
951
952        let value = ValueBag::from_serde1(&TestSerde);
953
954        value_bag_sval2::test::assert_tokens(&value, &[Token::U64(42)]);
955    }
956
957    #[cfg(feature = "seq")]
958    mod seq_support {
959        use super::*;
960
961        use crate::std::vec::Vec;
962
963        #[test]
964        #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
965        fn serde1_stream_str_seq() {
966            use value_bag_serde1::test::{assert_ser_tokens, Token};
967
968            assert_ser_tokens(
969                &ValueBag::from_seq_slice(&["a", "b", "c"]),
970                &[
971                    Token::Seq { len: None },
972                    Token::Str("a"),
973                    Token::Str("b"),
974                    Token::Str("c"),
975                    Token::SeqEnd,
976                ],
977            );
978        }
979
980        #[test]
981        #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
982        fn serde1_to_seq() {
983            assert_eq!(
984                vec![Some(1.0), None, Some(2.0), Some(3.0), None],
985                ValueBag::capture_serde1(&[
986                    &1.0 as &dyn Serialize,
987                    &true as &dyn Serialize,
988                    &2.0 as &dyn Serialize,
989                    &3.0 as &dyn Serialize,
990                    &"a string" as &dyn Serialize,
991                ])
992                .to_f64_seq::<Vec<Option<f64>>>()
993                .expect("invalid value")
994            );
995        }
996
997        #[test]
998        #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
999        fn serde1_as_seq() {
1000            assert_eq!(
1001                vec![1.0, 2.0, 3.0],
1002                ValueBag::capture_serde1(&[1.0, 2.0, 3.0,]).as_f64_seq::<Vec<f64>>()
1003            );
1004        }
1005    }
1006
1007    #[cfg(feature = "std")]
1008    mod std_support {
1009        use super::*;
1010
1011        use crate::std::borrow::ToOwned;
1012
1013        #[test]
1014        #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
1015        fn serde1_cast() {
1016            assert_eq!(
1017                "a string",
1018                ValueBag::capture_serde1(&"a string".to_owned())
1019                    .by_ref()
1020                    .to_str()
1021                    .expect("invalid value")
1022            );
1023        }
1024    }
1025
1026    #[cfg(feature = "owned")]
1027    mod owned_support {
1028        use super::*;
1029
1030        #[test]
1031        #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
1032        fn serde1_to_owned_poison() {
1033            struct Kaboom;
1034
1035            impl value_bag_serde1::lib::Serialize for Kaboom {
1036                fn serialize<S>(&self, _: S) -> Result<S::Ok, S::Error>
1037                where
1038                    S: value_bag_serde1::lib::Serializer,
1039                {
1040                    Err(S::Error::custom("kaboom"))
1041                }
1042            }
1043
1044            let value = ValueBag::capture_serde1(&Kaboom)
1045                .to_owned()
1046                .by_ref()
1047                .to_test_token();
1048
1049            assert_eq!(
1050                TestToken::Poisoned("failed to buffer the value".into()),
1051                value
1052            );
1053        }
1054    }
1055}
value_bag/internal/serde/v1.rs

value_bag/internal/serde/
v1.rs
