value_bag/internal/cast/
mod.rs

1//! Coerce a `Value` into some concrete types.
2//!
3//! These operations are cheap when the captured value is a simple primitive,
4//! but may end up executing arbitrary caller code if the value is complex.
5//! They will also attempt to downcast erased types into a primitive where possible.
6
7use crate::std::fmt;
8
9#[cfg(feature = "alloc")]
10use crate::std::{borrow::ToOwned, string::String};
11
12use super::{Internal, InternalVisitor};
13use crate::{Error, ValueBag};
14
15mod primitive;
16
17impl ValueBag<'static> {
18    /// Try capture an owned raw value.
19    ///
20    /// This method will return `Some` if the value is a simple primitive
21    /// that can be captured without losing its structure. In other cases
22    /// this method will return `None`.
23    #[cfg(feature = "owned")]
24    pub fn try_capture_owned<T>(value: &'_ T) -> Option<Self>
25    where
26        T: ?Sized + 'static,
27    {
28        primitive::from_owned_any(value)
29    }
30}
31
32impl<'v> ValueBag<'v> {
33    /// Try capture a raw value.
34    ///
35    /// This method will return `Some` if the value is a simple primitive
36    /// that can be captured without losing its structure. In other cases
37    /// this method will return `None`.
38    pub fn try_capture<T>(value: &'v T) -> Option<Self>
39    where
40        T: ?Sized + 'static,
41    {
42        primitive::from_any(value)
43    }
44
45    /// Try get a `u64` from this value.
46    ///
47    /// This method is cheap for primitive types, but may call arbitrary
48    /// serialization implementations for complex ones.
49    pub fn to_u64(&self) -> Option<u64> {
50        self.inner.cast().into_u64()
51    }
52
53    /// Try get a `i64` from this value.
54    ///
55    /// This method is cheap for primitive types, but may call arbitrary
56    /// serialization implementations for complex ones.
57    pub fn to_i64(&self) -> Option<i64> {
58        self.inner.cast().into_i64()
59    }
60
61    /// Try get a `u128` from this value.
62    ///
63    /// This method is cheap for primitive types, but may call arbitrary
64    /// serialization implementations for complex ones.
65    pub fn to_u128(&self) -> Option<u128> {
66        self.inner.cast().into_u128()
67    }
68
69    /// Try get a `i128` from this value.
70    ///
71    /// This method is cheap for primitive types, but may call arbitrary
72    /// serialization implementations for complex ones.
73    pub fn to_i128(&self) -> Option<i128> {
74        self.inner.cast().into_i128()
75    }
76
77    /// Try get a `f64` from this value.
78    ///
79    /// This method is cheap for primitive types, but may call arbitrary
80    /// serialization implementations for complex ones.
81    ///
82    /// This method is based on standard `TryInto` conversions, and will
83    /// only return `Some` if there's a guaranteed lossless conversion between
84    /// the source and destination types. For a more lenient alternative, see
85    /// [`ValueBag::as_f64`].
86    pub fn to_f64(&self) -> Option<f64> {
87        self.inner.cast().into_f64()
88    }
89
90    /// Get a `f64` from this value.
91    ///
92    /// This method is cheap for primitive types, but may call arbitrary
93    /// serialization implementations for complex ones.
94    ///
95    /// This method is like [`ValueBag::to_f64`] except will always return
96    /// a `f64`, regardless of the actual type of underlying value. For
97    /// numeric types, it will use a regular `as` conversion, which may be lossy.
98    /// For non-numeric types it will return `NaN`.
99    pub fn as_f64(&self) -> f64 {
100        self.inner.cast().as_f64()
101    }
102
103    /// Try get a `bool` from this value.
104    ///
105    /// This method is cheap for primitive types, but may call arbitrary
106    /// serialization implementations for complex ones.
107    pub fn to_bool(&self) -> Option<bool> {
108        self.inner.cast().into_bool()
109    }
110
111    /// Try get a `char` from this value.
112    ///
113    /// This method is cheap for primitive types, but may call arbitrary
114    /// serialization implementations for complex ones.
115    pub fn to_char(&self) -> Option<char> {
116        self.inner.cast().into_char()
117    }
118
119    /// Try get a `str` from this value.
120    ///
121    /// This method is cheap for primitive types. It won't allocate an owned
122    /// `String` if the value is a complex type.
123    pub fn to_borrowed_str(&self) -> Option<&'v str> {
124        self.inner.cast().into_borrowed_str()
125    }
126
127    /// Check whether this value is empty.
128    pub fn is_empty(&self) -> bool {
129        matches!(self.inner, Internal::None)
130    }
131
132    /// Check whether this value can be downcast to `T`.
133    pub fn is<T: 'static>(&self) -> bool {
134        self.downcast_ref::<T>().is_some()
135    }
136
137    /// Try downcast this value to `T`.
138    pub fn downcast_ref<T: 'static>(&self) -> Option<&T> {
139        match self.inner {
140            Internal::Debug(value) => value.as_any().downcast_ref(),
141            Internal::Display(value) => value.as_any().downcast_ref(),
142            #[cfg(feature = "error")]
143            Internal::Error(value) => value.as_any().downcast_ref(),
144            #[cfg(feature = "sval2")]
145            Internal::Sval2(value) => value.as_any().downcast_ref(),
146            #[cfg(feature = "serde1")]
147            Internal::Serde1(value) => value.as_any().downcast_ref(),
148
149            #[cfg(feature = "owned")]
150            Internal::SharedDebug(ref value) => value.as_any().downcast_ref(),
151            #[cfg(feature = "owned")]
152            Internal::SharedDisplay(ref value) => value.as_any().downcast_ref(),
153            #[cfg(all(feature = "error", feature = "owned"))]
154            Internal::SharedError(ref value) => value.as_any().downcast_ref(),
155            #[cfg(all(feature = "serde1", feature = "owned"))]
156            Internal::SharedSerde1(ref value) => value.as_any().downcast_ref(),
157            #[cfg(all(feature = "sval2", feature = "owned"))]
158            Internal::SharedSval2(ref value) => value.as_any().downcast_ref(),
159            #[cfg(all(feature = "seq", feature = "owned"))]
160            Internal::SharedSeq(ref value) => value.as_any().downcast_ref(),
161
162            #[cfg(feature = "owned")]
163            Internal::SharedRefDebug(value) => value.as_any().downcast_ref(),
164            #[cfg(feature = "owned")]
165            Internal::SharedRefDisplay(value) => value.as_any().downcast_ref(),
166            #[cfg(all(feature = "error", feature = "owned"))]
167            Internal::SharedRefError(value) => value.as_any().downcast_ref(),
168            #[cfg(all(feature = "serde1", feature = "owned"))]
169            Internal::SharedRefSerde1(value) => value.as_any().downcast_ref(),
170            #[cfg(all(feature = "sval2", feature = "owned"))]
171            Internal::SharedRefSval2(value) => value.as_any().downcast_ref(),
172            #[cfg(all(feature = "seq", feature = "owned"))]
173            Internal::SharedRefSeq(value) => value.as_any().downcast_ref(),
174
175            _ => None,
176        }
177    }
178}
179
180impl<'v> Internal<'v> {
181    /// Cast the inner value to another type.
182    #[inline]
183    fn cast(&self) -> Cast<'v> {
184        struct CastVisitor<'v>(Cast<'v>);
185
186        impl<'v> InternalVisitor<'v> for CastVisitor<'v> {
187            #[inline]
188            fn fill(&mut self, v: &dyn crate::fill::Fill) -> Result<(), Error> {
189                v.fill(crate::fill::Slot::new(self))
190            }
191
192            #[inline]
193            fn debug(&mut self, _: &dyn fmt::Debug) -> Result<(), Error> {
194                Ok(())
195            }
196
197            #[inline]
198            fn display(&mut self, _: &dyn fmt::Display) -> Result<(), Error> {
199                Ok(())
200            }
201
202            #[inline]
203            fn u64(&mut self, v: u64) -> Result<(), Error> {
204                self.0 = Cast::Unsigned(v);
205                Ok(())
206            }
207
208            #[inline]
209            fn i64(&mut self, v: i64) -> Result<(), Error> {
210                self.0 = Cast::Signed(v);
211                Ok(())
212            }
213
214            #[inline]
215            fn u128(&mut self, v: &u128) -> Result<(), Error> {
216                self.0 = Cast::BigUnsigned(*v);
217                Ok(())
218            }
219
220            #[inline]
221            fn i128(&mut self, v: &i128) -> Result<(), Error> {
222                self.0 = Cast::BigSigned(*v);
223                Ok(())
224            }
225
226            #[inline]
227            fn f64(&mut self, v: f64) -> Result<(), Error> {
228                self.0 = Cast::Float(v);
229                Ok(())
230            }
231
232            #[inline]
233            fn bool(&mut self, v: bool) -> Result<(), Error> {
234                self.0 = Cast::Bool(v);
235                Ok(())
236            }
237
238            #[inline]
239            fn char(&mut self, v: char) -> Result<(), Error> {
240                self.0 = Cast::Char(v);
241                Ok(())
242            }
243
244            #[cfg(feature = "alloc")]
245            #[inline]
246            fn str(&mut self, s: &str) -> Result<(), Error> {
247                self.0 = Cast::String(s.to_owned());
248                Ok(())
249            }
250
251            #[cfg(not(feature = "alloc"))]
252            #[inline]
253            fn str(&mut self, _: &str) -> Result<(), Error> {
254                Ok(())
255            }
256
257            #[inline]
258            fn borrowed_str(&mut self, v: &'v str) -> Result<(), Error> {
259                self.0 = Cast::Str(v);
260                Ok(())
261            }
262
263            #[inline]
264            fn none(&mut self) -> Result<(), Error> {
265                self.0 = Cast::None;
266                Ok(())
267            }
268
269            #[cfg(feature = "error")]
270            #[inline]
271            fn error(&mut self, _: &dyn super::error::Error) -> Result<(), Error> {
272                Ok(())
273            }
274
275            #[cfg(feature = "sval2")]
276            #[inline]
277            fn sval2(&mut self, v: &dyn super::sval::v2::Value) -> Result<(), Error> {
278                if super::sval::v2::internal_visit(v, self) {
279                    Ok(())
280                } else {
281                    Err(Error::msg("invalid cast"))
282                }
283            }
284
285            #[cfg(feature = "sval2")]
286            fn borrowed_sval2(&mut self, v: &'v dyn super::sval::v2::Value) -> Result<(), Error> {
287                if super::sval::v2::borrowed_internal_visit(v, self) {
288                    Ok(())
289                } else {
290                    Err(Error::msg("invalid cast"))
291                }
292            }
293
294            #[cfg(feature = "serde1")]
295            #[inline]
296            fn serde1(&mut self, v: &dyn super::serde::v1::Serialize) -> Result<(), Error> {
297                if super::serde::v1::internal_visit(v, self) {
298                    Ok(())
299                } else {
300                    Err(Error::msg("invalid cast"))
301                }
302            }
303
304            #[cfg(feature = "seq")]
305            fn seq(&mut self, _: &dyn super::seq::Seq) -> Result<(), Error> {
306                self.0 = Cast::None;
307                Ok(())
308            }
309
310            fn poisoned(&mut self, _: &'static str) -> Result<(), Error> {
311                self.0 = Cast::None;
312                Ok(())
313            }
314        }
315
316        match &self {
317            Internal::Signed(value) => Cast::Signed(*value),
318            Internal::Unsigned(value) => Cast::Unsigned(*value),
319            #[cfg(feature = "inline-i128")]
320            Internal::BigSigned(value) => Cast::BigSigned(*value),
321            #[cfg(not(feature = "inline-i128"))]
322            Internal::BigSigned(value) => Cast::BigSigned(**value),
323            #[cfg(feature = "inline-i128")]
324            Internal::BigUnsigned(value) => Cast::BigUnsigned(*value),
325            #[cfg(not(feature = "inline-i128"))]
326            Internal::BigUnsigned(value) => Cast::BigUnsigned(**value),
327            Internal::Float(value) => Cast::Float(*value),
328            Internal::Bool(value) => Cast::Bool(*value),
329            Internal::Char(value) => Cast::Char(*value),
330            Internal::Str(value) => Cast::Str(value),
331            Internal::None => Cast::None,
332            other => {
333                // If the erased value isn't a primitive then we visit it
334                let mut cast = CastVisitor(Cast::None);
335                let _ = other.internal_visit(&mut cast);
336                cast.0
337            }
338        }
339    }
340}
341
342pub(in crate::internal) enum Cast<'v> {
343    Signed(i64),
344    Unsigned(u64),
345    BigSigned(i128),
346    BigUnsigned(u128),
347    Float(f64),
348    Bool(bool),
349    Char(char),
350    Str(&'v str),
351    None,
352    #[cfg(feature = "alloc")]
353    String(String),
354}
355
356impl<'v> Cast<'v> {
357    #[inline]
358    fn into_borrowed_str(self) -> Option<&'v str> {
359        if let Cast::Str(value) = self {
360            Some(value)
361        } else {
362            None
363        }
364    }
365
366    #[inline]
367    fn into_u64(self) -> Option<u64> {
368        match self {
369            Cast::Unsigned(value) => Some(value),
370            Cast::BigUnsigned(value) => value.try_into().ok(),
371            Cast::Signed(value) => value.try_into().ok(),
372            Cast::BigSigned(value) => value.try_into().ok(),
373            _ => None,
374        }
375    }
376
377    #[inline]
378    fn into_i64(self) -> Option<i64> {
379        match self {
380            Cast::Signed(value) => Some(value),
381            Cast::BigSigned(value) => value.try_into().ok(),
382            Cast::Unsigned(value) => value.try_into().ok(),
383            Cast::BigUnsigned(value) => value.try_into().ok(),
384            _ => None,
385        }
386    }
387
388    #[inline]
389    fn into_u128(self) -> Option<u128> {
390        match self {
391            Cast::BigUnsigned(value) => Some(value),
392            Cast::Unsigned(value) => Some(value.into()),
393            Cast::Signed(value) => value.try_into().ok(),
394            Cast::BigSigned(value) => value.try_into().ok(),
395            _ => None,
396        }
397    }
398
399    #[inline]
400    fn into_i128(self) -> Option<i128> {
401        match self {
402            Cast::BigSigned(value) => Some(value),
403            Cast::Signed(value) => Some(value.into()),
404            Cast::Unsigned(value) => value.try_into().ok(),
405            Cast::BigUnsigned(value) => value.try_into().ok(),
406            _ => None,
407        }
408    }
409
410    #[inline]
411    fn into_f64(self) -> Option<f64> {
412        match self {
413            Cast::Float(value) => Some(value),
414            Cast::Unsigned(value) => u32::try_from(value)
415                .ok()
416                .and_then(|value| value.try_into().ok()),
417            Cast::Signed(value) => i32::try_from(value)
418                .ok()
419                .and_then(|value| value.try_into().ok()),
420            Cast::BigUnsigned(value) => u32::try_from(value)
421                .ok()
422                .and_then(|value| value.try_into().ok()),
423            Cast::BigSigned(value) => i32::try_from(value)
424                .ok()
425                .and_then(|value| value.try_into().ok()),
426            _ => None,
427        }
428    }
429
430    #[inline]
431    fn as_f64(self) -> f64 {
432        match self {
433            Cast::Float(value) => value,
434            Cast::Unsigned(value) => value as f64,
435            Cast::Signed(value) => value as f64,
436            Cast::BigUnsigned(value) => value as f64,
437            Cast::BigSigned(value) => value as f64,
438            _ => f64::NAN,
439        }
440    }
441
442    #[inline]
443    fn into_char(self) -> Option<char> {
444        if let Cast::Char(value) = self {
445            Some(value)
446        } else {
447            None
448        }
449    }
450
451    #[inline]
452    fn into_bool(self) -> Option<bool> {
453        if let Cast::Bool(value) = self {
454            Some(value)
455        } else {
456            None
457        }
458    }
459}
460
461#[cfg(feature = "alloc")]
462mod alloc_support {
463    use super::*;
464
465    use crate::std::borrow::Cow;
466
467    impl<'v> ValueBag<'v> {
468        /// Try get a `str` from this value.
469        ///
470        /// This method is cheap for primitive types, but may call arbitrary
471        /// serialization implementations for complex ones. If the serialization
472        /// implementation produces a short lived string it will be allocated.
473        #[inline]
474        pub fn to_str(&self) -> Option<Cow<'v, str>> {
475            self.inner.cast().into_str()
476        }
477    }
478
479    impl<'v> Cast<'v> {
480        #[inline]
481        pub(in crate::internal) fn into_str(self) -> Option<Cow<'v, str>> {
482            match self {
483                Cast::Str(value) => Some(value.into()),
484                Cast::String(value) => Some(value.into()),
485                _ => None,
486            }
487        }
488    }
489
490    #[cfg(test)]
491    mod tests {
492        #[cfg(target_arch = "wasm32")]
493        use wasm_bindgen_test::*;
494
495        use crate::{std::borrow::ToOwned, test::IntoValueBag, ValueBag};
496
497        #[test]
498        #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
499        fn primitive_cast() {
500            let short_lived = "a string".to_owned();
501            assert_eq!(
502                "a string",
503                (&*short_lived)
504                    .into_value_bag()
505                    .to_borrowed_str()
506                    .expect("invalid value")
507            );
508            assert_eq!(
509                "a string",
510                &*"a string".into_value_bag().to_str().expect("invalid value")
511            );
512            assert_eq!(
513                "a string",
514                (&*short_lived)
515                    .into_value_bag()
516                    .to_borrowed_str()
517                    .expect("invalid value")
518            );
519            assert_eq!(
520                "a string",
521                ValueBag::try_capture(&short_lived)
522                    .expect("invalid value")
523                    .to_borrowed_str()
524                    .expect("invalid value")
525            );
526        }
527    }
528}
529
530#[cfg(test)]
531mod tests {
532    #[cfg(target_arch = "wasm32")]
533    use wasm_bindgen_test::*;
534
535    use super::*;
536
537    use crate::test::IntoValueBag;
538
539    #[test]
540    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
541    fn is_empty() {
542        assert!(ValueBag::from(None::<i32>).is_empty(),);
543
544        assert!(ValueBag::try_capture(&None::<i32>).unwrap().is_empty(),);
545    }
546
547    #[test]
548    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
549    fn primitive_capture_str() {
550        let s: &str = "short lived";
551        assert_eq!(
552            "short lived",
553            ValueBag::try_capture(s)
554                .unwrap()
555                .to_borrowed_str()
556                .expect("invalid value")
557        );
558    }
559
560    #[test]
561    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
562    fn primitive_cast() {
563        assert_eq!(
564            "a string",
565            "a string"
566                .into_value_bag()
567                .by_ref()
568                .to_borrowed_str()
569                .expect("invalid value")
570        );
571
572        assert_eq!(
573            1u64,
574            1u8.into_value_bag()
575                .by_ref()
576                .to_u64()
577                .expect("invalid value")
578        );
579        assert_eq!(
580            1u64,
581            1u16.into_value_bag()
582                .by_ref()
583                .to_u64()
584                .expect("invalid value")
585        );
586        assert_eq!(
587            1u64,
588            1u32.into_value_bag()
589                .by_ref()
590                .to_u64()
591                .expect("invalid value")
592        );
593        assert_eq!(
594            1u64,
595            1u64.into_value_bag()
596                .by_ref()
597                .to_u64()
598                .expect("invalid value")
599        );
600        assert_eq!(
601            1u64,
602            1usize
603                .into_value_bag()
604                .by_ref()
605                .to_u64()
606                .expect("invalid value")
607        );
608        assert_eq!(
609            1u128,
610            1u128
611                .into_value_bag()
612                .by_ref()
613                .to_u128()
614                .expect("invalid value")
615        );
616
617        assert_eq!(
618            -1i64,
619            -(1i8
620                .into_value_bag()
621                .by_ref()
622                .to_i64()
623                .expect("invalid value"))
624        );
625        assert_eq!(
626            -1i64,
627            -(1i8
628                .into_value_bag()
629                .by_ref()
630                .to_i64()
631                .expect("invalid value"))
632        );
633        assert_eq!(
634            -1i64,
635            -(1i8
636                .into_value_bag()
637                .by_ref()
638                .to_i64()
639                .expect("invalid value"))
640        );
641        assert_eq!(
642            -1i64,
643            -(1i64
644                .into_value_bag()
645                .by_ref()
646                .to_i64()
647                .expect("invalid value"))
648        );
649        assert_eq!(
650            -1i64,
651            -(1isize
652                .into_value_bag()
653                .by_ref()
654                .to_i64()
655                .expect("invalid value"))
656        );
657        assert_eq!(
658            -1i128,
659            -(1i128
660                .into_value_bag()
661                .by_ref()
662                .to_i128()
663                .expect("invalid value"))
664        );
665
666        assert!(1f64.into_value_bag().by_ref().to_f64().is_some());
667        assert!(1u64.into_value_bag().by_ref().to_f64().is_some());
668        assert!((-1i64).into_value_bag().by_ref().to_f64().is_some());
669        assert!(1u128.into_value_bag().by_ref().to_f64().is_some());
670        assert!((-1i128).into_value_bag().by_ref().to_f64().is_some());
671
672        assert!(u64::MAX.into_value_bag().by_ref().to_u128().is_some());
673        assert!(i64::MIN.into_value_bag().by_ref().to_i128().is_some());
674        assert!(i64::MAX.into_value_bag().by_ref().to_u64().is_some());
675
676        assert!((-1i64).into_value_bag().by_ref().to_u64().is_none());
677        assert!(u64::MAX.into_value_bag().by_ref().to_i64().is_none());
678        assert!(u64::MAX.into_value_bag().by_ref().to_f64().is_none());
679
680        assert!(i128::MAX.into_value_bag().by_ref().to_i64().is_none());
681        assert!(u128::MAX.into_value_bag().by_ref().to_u64().is_none());
682
683        assert!(1f64.into_value_bag().by_ref().to_u64().is_none());
684
685        assert_eq!(
686            'a',
687            'a'.into_value_bag()
688                .by_ref()
689                .to_char()
690                .expect("invalid value")
691        );
692        assert!(true
693            .into_value_bag()
694            .by_ref()
695            .to_bool()
696            .expect("invalid value"));
697    }
698
699    #[test]
700    fn as_cast() {
701        assert_eq!(1.0, 1f64.into_value_bag().as_f64());
702        assert_eq!(1.0, 1u64.into_value_bag().as_f64());
703        assert_eq!(-1.0, -(1i64.into_value_bag().as_f64()));
704        assert!(true.into_value_bag().as_f64().is_nan());
705    }
706}
value_bag/internal/cast/mod.rs

value_bag/internal/cast/
mod.rs
