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

value_bag/internal/serde/
v1.rs
