value_trait/
impls.rs

1use std::{borrow::Borrow, hash::Hash};
2
3use crate::{
4    AccessError, ExtendedValueType, TryTypeError, ValueType,
5    array::{self, ArrayMut, Indexed, IndexedMut},
6    base::{TypedValue, ValueAsScalar, ValueIntoString, ValueTryAsArrayMut, ValueTryAsMutObject},
7    derived::{
8        MutableArray, MutableObject, MutableValueArrayAccess, TypedArrayValue, TypedObjectValue,
9        TypedScalarValue, ValueArrayAccess, ValueArrayTryAccess, ValueObjectAccess,
10        ValueObjectAccessAsArray, ValueObjectAccessAsObject, ValueObjectAccessAsScalar,
11        ValueObjectAccessTryAsArray, ValueObjectAccessTryAsObject, ValueObjectAccessTryAsScalar,
12        ValueObjectTryAccess, ValueTryAsArray, ValueTryAsObject, ValueTryAsScalar,
13        ValueTryIntoArray, ValueTryIntoObject, ValueTryIntoString,
14    },
15    object::{Object, ObjectMut},
16    prelude::{
17        ValueAsArray, ValueAsMutArray, ValueAsMutObject, ValueAsObject, ValueIntoArray,
18        ValueIntoObject,
19    },
20};
21
22impl<T> ValueTryIntoString for T
23where
24    T: ValueIntoString + TypedValue,
25{
26    type String = T::String;
27
28    #[inline]
29    fn try_into_string(self) -> Result<Self::String, TryTypeError> {
30        let vt = self.value_type();
31        self.into_string().ok_or(TryTypeError {
32            expected: ValueType::String,
33            got: vt,
34        })
35    }
36}
37
38impl<T> ValueTryIntoArray for T
39where
40    T: ValueIntoArray + TypedValue,
41{
42    type Array = T::Array;
43    /// Tries to turn the value into it's array representation
44    /// # Errors
45    /// if the requested type doesn't match the actual type
46    #[inline]
47    fn try_into_array(self) -> Result<Self::Array, TryTypeError> {
48        let vt = self.value_type();
49        self.into_array().ok_or(TryTypeError {
50            expected: ValueType::Array,
51            got: vt,
52        })
53    }
54}
55impl<T> ValueTryIntoObject for T
56where
57    T: ValueIntoObject + TypedValue,
58{
59    type Object = T::Object;
60
61    /// Tries to turn the value into it's object representation
62    /// # Errors
63    /// if the requested type doesn't match the actual type
64    #[inline]
65    fn try_into_object(self) -> Result<Self::Object, TryTypeError> {
66        let vt = self.value_type();
67        self.into_object().ok_or(TryTypeError {
68            expected: ValueType::Object,
69            got: vt,
70        })
71    }
72}
73
74impl<T> ValueTryAsScalar for T
75where
76    T: ValueAsScalar + TypedValue,
77{
78    #[inline]
79    fn try_as_bool(&self) -> Result<bool, TryTypeError> {
80        self.as_bool().ok_or(TryTypeError {
81            expected: ValueType::Bool,
82            got: self.value_type(),
83        })
84    }
85
86    #[inline]
87    fn try_as_i128(&self) -> Result<i128, TryTypeError> {
88        self.as_i128().ok_or(TryTypeError {
89            expected: ValueType::I128,
90            got: self.value_type(),
91        })
92    }
93
94    #[inline]
95    fn try_as_i64(&self) -> Result<i64, TryTypeError> {
96        self.as_i64().ok_or(TryTypeError {
97            expected: ValueType::I64,
98            got: self.value_type(),
99        })
100    }
101
102    #[inline]
103    fn try_as_i32(&self) -> Result<i32, TryTypeError> {
104        self.as_i32().ok_or(TryTypeError {
105            expected: ValueType::Extended(ExtendedValueType::I32),
106            got: self.value_type(),
107        })
108    }
109
110    #[inline]
111    fn try_as_i16(&self) -> Result<i16, TryTypeError> {
112        self.as_i16().ok_or(TryTypeError {
113            expected: ValueType::Extended(ExtendedValueType::I16),
114            got: self.value_type(),
115        })
116    }
117
118    #[inline]
119    fn try_as_i8(&self) -> Result<i8, TryTypeError> {
120        self.as_i8().ok_or(TryTypeError {
121            expected: ValueType::Extended(ExtendedValueType::I8),
122            got: self.value_type(),
123        })
124    }
125
126    #[inline]
127    fn try_as_u128(&self) -> Result<u128, TryTypeError> {
128        self.as_u128().ok_or(TryTypeError {
129            expected: ValueType::U128,
130            got: self.value_type(),
131        })
132    }
133
134    #[inline]
135    fn try_as_u64(&self) -> Result<u64, TryTypeError> {
136        self.as_u64().ok_or(TryTypeError {
137            expected: ValueType::U64,
138            got: self.value_type(),
139        })
140    }
141
142    #[inline]
143    fn try_as_usize(&self) -> Result<usize, TryTypeError> {
144        self.as_usize().ok_or(TryTypeError {
145            expected: ValueType::Extended(ExtendedValueType::Usize),
146            got: self.value_type(),
147        })
148    }
149
150    #[inline]
151    fn try_as_u32(&self) -> Result<u32, TryTypeError> {
152        self.as_u32().ok_or(TryTypeError {
153            expected: ValueType::Extended(ExtendedValueType::U32),
154            got: self.value_type(),
155        })
156    }
157
158    #[inline]
159    fn try_as_u16(&self) -> Result<u16, TryTypeError> {
160        self.as_u16().ok_or(TryTypeError {
161            expected: ValueType::Extended(ExtendedValueType::U16),
162            got: self.value_type(),
163        })
164    }
165
166    #[inline]
167    fn try_as_u8(&self) -> Result<u8, TryTypeError> {
168        self.as_u8().ok_or(TryTypeError {
169            expected: ValueType::Extended(ExtendedValueType::U8),
170            got: self.value_type(),
171        })
172    }
173
174    #[inline]
175    fn try_as_f64(&self) -> Result<f64, TryTypeError> {
176        self.as_f64().ok_or(TryTypeError {
177            expected: ValueType::F64,
178            got: self.value_type(),
179        })
180    }
181
182    #[inline]
183    #[allow(clippy::cast_precision_loss, clippy::option_if_let_else)]
184    fn try_cast_f64(&self) -> Result<f64, TryTypeError> {
185        if let Some(f) = self.as_f64() {
186            Ok(f)
187        } else if let Some(u) = self.as_u128() {
188            Ok(u as f64)
189        } else {
190            self.try_as_i128().map(|i| i as f64)
191        }
192    }
193
194    #[inline]
195    fn try_as_f32(&self) -> Result<f32, TryTypeError> {
196        self.as_f32().ok_or(TryTypeError {
197            expected: ValueType::Extended(ExtendedValueType::F32),
198            got: self.value_type(),
199        })
200    }
201
202    #[inline]
203    fn try_as_str(&self) -> Result<&str, TryTypeError> {
204        self.as_str().ok_or(TryTypeError {
205            expected: ValueType::String,
206            got: self.value_type(),
207        })
208    }
209
210    #[inline]
211    fn try_as_char(&self) -> Result<char, TryTypeError> {
212        self.as_char().ok_or(TryTypeError {
213            expected: ValueType::Extended(ExtendedValueType::Char),
214            got: self.value_type(),
215        })
216    }
217}
218
219impl<T> ValueTryAsArray for T
220where
221    T: ValueAsArray + TypedValue,
222{
223    type Array = T::Array;
224    #[inline]
225    fn try_as_array(&self) -> Result<&Self::Array, TryTypeError> {
226        self.as_array().ok_or(TryTypeError {
227            expected: ValueType::Array,
228            got: self.value_type(),
229        })
230    }
231}
232impl<T> ValueTryAsArrayMut for T
233where
234    T: ValueAsMutArray + TypedValue,
235    <T as ValueAsMutArray>::Array: array::Array,
236{
237    type Array = T::Array;
238    #[inline]
239    fn try_as_array_mut(&mut self) -> Result<&mut Self::Array, TryTypeError> {
240        let got = self.value_type();
241        self.as_array_mut().ok_or(TryTypeError {
242            expected: ValueType::Array,
243            got,
244        })
245    }
246}
247
248impl<T> ValueTryAsObject for T
249where
250    T: ValueAsObject + TypedValue,
251{
252    type Object = T::Object;
253
254    #[inline]
255    fn try_as_object(&self) -> Result<&Self::Object, TryTypeError> {
256        self.as_object().ok_or(TryTypeError {
257            expected: ValueType::Object,
258            got: self.value_type(),
259        })
260    }
261}
262impl<T> ValueTryAsMutObject for T
263where
264    T: ValueAsMutObject + TypedValue,
265{
266    type Object = T::Object;
267
268    #[inline]
269    fn try_as_object_mut(&mut self) -> Result<&mut Self::Object, TryTypeError> {
270        let got = self.value_type();
271        self.as_object_mut().ok_or(TryTypeError {
272            expected: ValueType::Object,
273            got,
274        })
275    }
276}
277
278impl<T> ValueObjectAccess for T
279where
280    T: ValueAsObject,
281{
282    type Key = <T::Object as Object>::Key;
283    type Target = <T::Object as Object>::Element;
284    #[inline]
285    #[must_use]
286    fn get<Q>(&self, k: &Q) -> Option<&Self::Target>
287    where
288        Self::Key: Borrow<Q>,
289        Q: ?Sized + Hash + Eq + Ord,
290    {
291        self.as_object().and_then(|a| a.get(k))
292    }
293
294    #[inline]
295    #[must_use]
296    fn contains_key<Q>(&self, k: &Q) -> bool
297    where
298        Self::Key: Borrow<Q>,
299        Q: ?Sized + Hash + Eq + Ord,
300    {
301        self.as_object().and_then(|a| a.get(k)).is_some()
302    }
303}
304
305impl<T> ValueObjectTryAccess for T
306where
307    T: ValueTryAsObject,
308{
309    type Key = <T::Object as Object>::Key;
310    type Target = <T::Object as Object>::Element;
311
312    #[inline]
313    fn try_get<Q>(&self, k: &Q) -> Result<Option<&Self::Target>, TryTypeError>
314    where
315        Self::Key: Borrow<Q>,
316        Q: ?Sized + Hash + Eq + Ord,
317    {
318        Ok(self.try_as_object()?.get(k))
319    }
320}
321
322impl<I, T> ValueArrayAccess<I> for T
323where
324    T: ValueAsArray,
325    <T as ValueAsArray>::Array: Indexed<I>,
326{
327    type Target = <<T as ValueAsArray>::Array as Indexed<I>>::Element;
328    #[inline]
329    #[must_use]
330    fn get_idx(&self, i: I) -> Option<&Self::Target> {
331        self.as_array().and_then(|a| a.get(i))
332    }
333}
334
335impl<T> ValueArrayTryAccess for T
336where
337    T: ValueTryAsArray,
338    <T as ValueTryAsArray>::Array: Indexed<usize>,
339{
340    type Target = <<T as ValueTryAsArray>::Array as Indexed<usize>>::Element;
341
342    /// Tries to get a value based on n index, returns a type error if the
343    /// current value isn't an Array, returns `None` if the index is out of bounds
344    /// # Errors
345    /// if the requested type doesn't match the actual type or the value is not an object
346    #[inline]
347    fn try_get_idx(&self, i: usize) -> Result<Option<&Self::Target>, TryTypeError> {
348        Ok(self.try_as_array()?.get(i))
349    }
350}
351
352impl<T> ValueObjectAccessAsScalar for T
353where
354    T: ValueObjectAccess,
355    <T as ValueObjectAccess>::Target: ValueAsScalar,
356{
357    type Key = T::Key;
358    #[inline]
359    #[must_use]
360    fn get_bool<Q>(&self, k: &Q) -> Option<bool>
361    where
362        Self::Key: Borrow<Q>,
363        Q: ?Sized + Hash + Eq + Ord,
364    {
365        self.get(k).and_then(ValueAsScalar::as_bool)
366    }
367
368    #[inline]
369    #[must_use]
370    fn get_i128<Q>(&self, k: &Q) -> Option<i128>
371    where
372        Self::Key: Borrow<Q>,
373        Q: ?Sized + Hash + Eq + Ord,
374    {
375        self.get(k).and_then(ValueAsScalar::as_i128)
376    }
377
378    #[inline]
379    #[must_use]
380    fn get_i64<Q>(&self, k: &Q) -> Option<i64>
381    where
382        Self::Key: Borrow<Q>,
383        Q: ?Sized + Hash + Eq + Ord,
384    {
385        self.get(k).and_then(ValueAsScalar::as_i64)
386    }
387
388    #[inline]
389    #[must_use]
390    fn get_i32<Q>(&self, k: &Q) -> Option<i32>
391    where
392        Self::Key: Borrow<Q>,
393        Q: ?Sized + Hash + Eq + Ord,
394    {
395        self.get(k).and_then(ValueAsScalar::as_i32)
396    }
397
398    #[inline]
399    #[must_use]
400    fn get_i16<Q>(&self, k: &Q) -> Option<i16>
401    where
402        Self::Key: Borrow<Q>,
403        Q: ?Sized + Hash + Eq + Ord,
404    {
405        self.get(k).and_then(ValueAsScalar::as_i16)
406    }
407
408    #[inline]
409    #[must_use]
410    fn get_i8<Q>(&self, k: &Q) -> Option<i8>
411    where
412        Self::Key: Borrow<Q>,
413        Q: ?Sized + Hash + Eq + Ord,
414    {
415        self.get(k).and_then(ValueAsScalar::as_i8)
416    }
417
418    #[inline]
419    #[must_use]
420    fn get_u128<Q>(&self, k: &Q) -> Option<u128>
421    where
422        Self::Key: Borrow<Q>,
423        Q: ?Sized + Hash + Eq + Ord,
424    {
425        self.get(k).and_then(ValueAsScalar::as_u128)
426    }
427
428    #[inline]
429    #[must_use]
430    fn get_u64<Q>(&self, k: &Q) -> Option<u64>
431    where
432        Self::Key: Borrow<Q>,
433        Q: ?Sized + Hash + Eq + Ord,
434    {
435        self.get(k).and_then(ValueAsScalar::as_u64)
436    }
437
438    #[inline]
439    #[must_use]
440    fn get_usize<Q>(&self, k: &Q) -> Option<usize>
441    where
442        Self::Key: Borrow<Q>,
443        Q: ?Sized + Hash + Eq + Ord,
444    {
445        self.get(k).and_then(ValueAsScalar::as_usize)
446    }
447
448    #[inline]
449    #[must_use]
450    fn get_u32<Q>(&self, k: &Q) -> Option<u32>
451    where
452        Self::Key: Borrow<Q>,
453        Q: ?Sized + Hash + Eq + Ord,
454    {
455        self.get(k).and_then(ValueAsScalar::as_u32)
456    }
457
458    #[inline]
459    #[must_use]
460    fn get_u16<Q>(&self, k: &Q) -> Option<u16>
461    where
462        Self::Key: Borrow<Q>,
463        Q: ?Sized + Hash + Eq + Ord,
464    {
465        self.get(k).and_then(ValueAsScalar::as_u16)
466    }
467
468    #[inline]
469    #[must_use]
470    fn get_u8<Q>(&self, k: &Q) -> Option<u8>
471    where
472        Self::Key: Borrow<Q>,
473        Q: ?Sized + Hash + Eq + Ord,
474    {
475        self.get(k).and_then(ValueAsScalar::as_u8)
476    }
477
478    #[inline]
479    #[must_use]
480    fn get_f64<Q>(&self, k: &Q) -> Option<f64>
481    where
482        Self::Key: Borrow<Q>,
483        Q: ?Sized + Hash + Eq + Ord,
484    {
485        self.get(k).and_then(ValueAsScalar::as_f64)
486    }
487
488    #[inline]
489    #[must_use]
490    fn get_f32<Q>(&self, k: &Q) -> Option<f32>
491    where
492        Self::Key: Borrow<Q>,
493        Q: ?Sized + Hash + Eq + Ord,
494    {
495        self.get(k).and_then(ValueAsScalar::as_f32)
496    }
497
498    #[inline]
499    #[must_use]
500    fn get_str<Q>(&self, k: &Q) -> Option<&str>
501    where
502        Self::Key: Borrow<Q>,
503        Q: ?Sized + Hash + Eq + Ord,
504    {
505        self.get(k).and_then(ValueAsScalar::as_str)
506    }
507}
508
509impl<T> ValueObjectAccessAsArray for T
510where
511    T: ValueObjectAccess,
512    T::Target: ValueAsArray,
513{
514    type Key = T::Key;
515
516    type Array = <T::Target as ValueAsArray>::Array;
517
518    #[inline]
519    #[must_use]
520    fn get_array<Q>(&self, k: &Q) -> Option<&Self::Array>
521    where
522        Self::Key: Borrow<Q>,
523        Q: ?Sized + Hash + Eq + Ord,
524    {
525        self.get(k).and_then(ValueAsArray::as_array)
526    }
527}
528
529impl<T> ValueObjectAccessAsObject for T
530where
531    T: ValueObjectAccess,
532    T::Target: ValueAsObject,
533{
534    type Key = T::Key;
535    type Object = <T::Target as ValueAsObject>::Object;
536
537    #[inline]
538    #[must_use]
539    fn get_object<Q>(&self, k: &Q) -> Option<&Self::Object>
540    where
541        Self::Key: Borrow<Q>,
542        Q: ?Sized + Hash + Eq + Ord,
543    {
544        self.get(k).and_then(ValueAsObject::as_object)
545    }
546}
547
548impl<T> ValueObjectAccessTryAsArray for T
549where
550    T: ValueObjectTryAccess + TypedValue,
551    T::Target: ValueTryAsArray,
552{
553    type Key = T::Key;
554
555    type Array = <T::Target as ValueTryAsArray>::Array;
556
557    #[inline]
558    fn try_get_array<Q>(&self, k: &Q) -> Result<Option<&Self::Array>, TryTypeError>
559    where
560        Self::Key: Borrow<Q>,
561        Q: ?Sized + Hash + Eq + Ord,
562    {
563        self.try_get(k)
564            .and_then(|s| s.map(ValueTryAsArray::try_as_array).transpose())
565    }
566}
567impl<T> ValueObjectAccessTryAsObject for T
568where
569    T: ValueObjectTryAccess + TypedValue,
570    T::Target: ValueTryAsObject,
571{
572    type Key = T::Key;
573
574    type Object = <T::Target as ValueTryAsObject>::Object;
575
576    #[inline]
577    fn try_get_object<Q>(&self, k: &Q) -> Result<Option<&Self::Object>, TryTypeError>
578    where
579        Self::Key: Borrow<Q>,
580        Q: ?Sized + Hash + Eq + Ord,
581    {
582        self.try_get(k)
583            .and_then(|s| s.map(ValueTryAsObject::try_as_object).transpose())
584    }
585}
586
587impl<T> ValueObjectAccessTryAsScalar for T
588where
589    T: ValueObjectTryAccess + TypedValue,
590    T::Target: ValueTryAsScalar,
591{
592    type Key = T::Key;
593
594    fn try_get_bool<Q>(&self, k: &Q) -> Result<Option<bool>, TryTypeError>
595    where
596        Self::Key: Borrow<Q>,
597        Q: ?Sized + Hash + Eq + Ord,
598    {
599        self.try_get(k)?
600            .map(ValueTryAsScalar::try_as_bool)
601            .transpose()
602    }
603
604    fn try_get_i128<Q>(&self, k: &Q) -> Result<Option<i128>, TryTypeError>
605    where
606        Self::Key: Borrow<Q>,
607        Q: ?Sized + Hash + Eq + Ord,
608    {
609        self.try_get(k)?
610            .map(ValueTryAsScalar::try_as_i128)
611            .transpose()
612    }
613
614    fn try_get_i64<Q>(&self, k: &Q) -> Result<Option<i64>, TryTypeError>
615    where
616        Self::Key: Borrow<Q>,
617        Q: ?Sized + Hash + Eq + Ord,
618    {
619        self.try_get(k)?
620            .map(ValueTryAsScalar::try_as_i64)
621            .transpose()
622    }
623
624    fn try_get_i32<Q>(&self, k: &Q) -> Result<Option<i32>, TryTypeError>
625    where
626        Self::Key: Borrow<Q>,
627        Q: ?Sized + Hash + Eq + Ord,
628    {
629        self.try_get(k)?
630            .map(ValueTryAsScalar::try_as_i32)
631            .transpose()
632    }
633
634    fn try_get_i16<Q>(&self, k: &Q) -> Result<Option<i16>, TryTypeError>
635    where
636        Self::Key: Borrow<Q>,
637        Q: ?Sized + Hash + Eq + Ord,
638    {
639        self.try_get(k)?
640            .map(ValueTryAsScalar::try_as_i16)
641            .transpose()
642    }
643
644    fn try_get_i8<Q>(&self, k: &Q) -> Result<Option<i8>, TryTypeError>
645    where
646        Self::Key: Borrow<Q>,
647        Q: ?Sized + Hash + Eq + Ord,
648    {
649        self.try_get(k)?
650            .map(ValueTryAsScalar::try_as_i8)
651            .transpose()
652    }
653
654    fn try_get_u128<Q>(&self, k: &Q) -> Result<Option<u128>, TryTypeError>
655    where
656        Self::Key: Borrow<Q>,
657        Q: ?Sized + Hash + Eq + Ord,
658    {
659        self.try_get(k)?
660            .map(ValueTryAsScalar::try_as_u128)
661            .transpose()
662    }
663
664    fn try_get_u64<Q>(&self, k: &Q) -> Result<Option<u64>, TryTypeError>
665    where
666        Self::Key: Borrow<Q>,
667        Q: ?Sized + Hash + Eq + Ord,
668    {
669        self.try_get(k)?
670            .map(ValueTryAsScalar::try_as_u64)
671            .transpose()
672    }
673
674    fn try_get_usize<Q>(&self, k: &Q) -> Result<Option<usize>, TryTypeError>
675    where
676        Self::Key: Borrow<Q>,
677        Q: ?Sized + Hash + Eq + Ord,
678    {
679        self.try_get(k)?
680            .map(ValueTryAsScalar::try_as_usize)
681            .transpose()
682    }
683
684    fn try_get_u32<Q>(&self, k: &Q) -> Result<Option<u32>, TryTypeError>
685    where
686        Self::Key: Borrow<Q>,
687        Q: ?Sized + Hash + Eq + Ord,
688    {
689        self.try_get(k)?
690            .map(ValueTryAsScalar::try_as_u32)
691            .transpose()
692    }
693
694    fn try_get_u16<Q>(&self, k: &Q) -> Result<Option<u16>, TryTypeError>
695    where
696        Self::Key: Borrow<Q>,
697        Q: ?Sized + Hash + Eq + Ord,
698    {
699        self.try_get(k)?
700            .map(ValueTryAsScalar::try_as_u16)
701            .transpose()
702    }
703
704    fn try_get_u8<Q>(&self, k: &Q) -> Result<Option<u8>, TryTypeError>
705    where
706        Self::Key: Borrow<Q>,
707        Q: ?Sized + Hash + Eq + Ord,
708    {
709        self.try_get(k)?
710            .map(ValueTryAsScalar::try_as_u8)
711            .transpose()
712    }
713
714    fn try_get_f64<Q>(&self, k: &Q) -> Result<Option<f64>, TryTypeError>
715    where
716        Self::Key: Borrow<Q>,
717        Q: ?Sized + Hash + Eq + Ord,
718    {
719        self.try_get(k)?
720            .map(ValueTryAsScalar::try_as_f64)
721            .transpose()
722    }
723
724    fn try_get_f32<Q>(&self, k: &Q) -> Result<Option<f32>, TryTypeError>
725    where
726        Self::Key: Borrow<Q>,
727        Q: ?Sized + Hash + Eq + Ord,
728    {
729        self.try_get(k)?
730            .map(ValueTryAsScalar::try_as_f32)
731            .transpose()
732    }
733
734    fn try_get_str<Q>(&self, k: &Q) -> Result<Option<&str>, TryTypeError>
735    where
736        Self::Key: Borrow<Q>,
737        Q: ?Sized + Hash + Eq + Ord,
738    {
739        self.try_get(k)?
740            .map(ValueTryAsScalar::try_as_str)
741            .transpose()
742    }
743}
744
745impl<T> TypedScalarValue for T
746where
747    T: ValueAsScalar,
748{
749    #[inline]
750    #[must_use]
751    fn is_null(&self) -> bool {
752        self.as_null().is_some()
753    }
754
755    #[inline]
756    #[must_use]
757    fn is_float(&self) -> bool {
758        self.is_f64()
759    }
760
761    #[inline]
762    #[must_use]
763    fn is_integer(&self) -> bool {
764        self.is_i128() || self.is_u128()
765    }
766
767    #[inline]
768    #[must_use]
769    fn is_number(&self) -> bool {
770        self.is_float() || self.is_integer()
771    }
772
773    #[inline]
774    #[must_use]
775    fn is_bool(&self) -> bool {
776        self.as_bool().is_some()
777    }
778
779    #[inline]
780    #[must_use]
781    fn is_i128(&self) -> bool {
782        self.as_i128().is_some()
783    }
784
785    #[inline]
786    #[must_use]
787    fn is_i64(&self) -> bool {
788        self.as_i64().is_some()
789    }
790
791    #[inline]
792    #[must_use]
793    fn is_i32(&self) -> bool {
794        self.as_i32().is_some()
795    }
796
797    #[inline]
798    #[must_use]
799    fn is_i16(&self) -> bool {
800        self.as_i16().is_some()
801    }
802
803    #[inline]
804    #[must_use]
805    fn is_i8(&self) -> bool {
806        self.as_i8().is_some()
807    }
808
809    #[inline]
810    #[must_use]
811    fn is_u128(&self) -> bool {
812        self.as_u128().is_some()
813    }
814
815    #[inline]
816    #[must_use]
817    fn is_u64(&self) -> bool {
818        self.as_u64().is_some()
819    }
820
821    #[inline]
822    #[must_use]
823    fn is_usize(&self) -> bool {
824        self.as_usize().is_some()
825    }
826
827    #[inline]
828    #[must_use]
829    fn is_u32(&self) -> bool {
830        self.as_u32().is_some()
831    }
832
833    #[inline]
834    #[must_use]
835    fn is_u16(&self) -> bool {
836        self.as_u16().is_some()
837    }
838
839    #[inline]
840    #[must_use]
841    fn is_u8(&self) -> bool {
842        self.as_u8().is_some()
843    }
844
845    #[inline]
846    #[must_use]
847    fn is_f64(&self) -> bool {
848        self.as_f64().is_some()
849    }
850
851    #[inline]
852    #[must_use]
853    fn is_f64_castable(&self) -> bool {
854        self.cast_f64().is_some()
855    }
856
857    #[inline]
858    #[must_use]
859    fn is_f32(&self) -> bool {
860        self.as_f32().is_some()
861    }
862
863    #[inline]
864    #[must_use]
865    fn is_str(&self) -> bool {
866        self.as_str().is_some()
867    }
868
869    #[inline]
870    #[must_use]
871    fn is_char(&self) -> bool {
872        self.as_char().is_some()
873    }
874}
875
876impl<T> TypedArrayValue for T
877where
878    T: ValueAsArray,
879{
880    #[inline]
881    #[must_use]
882    fn is_array(&self) -> bool {
883        self.as_array().is_some()
884    }
885}
886impl<T> TypedObjectValue for T
887where
888    T: ValueAsObject,
889{
890    #[inline]
891    #[must_use]
892    fn is_object(&self) -> bool {
893        self.as_object().is_some()
894    }
895}
896impl<T> MutableObject for T
897where
898    T: ValueAsMutObject,
899    T::Object: ObjectMut,
900{
901    type Key = <T::Object as ObjectMut>::Key;
902    type Target = <T::Object as ObjectMut>::Element;
903    type Object = T::Object;
904
905    #[inline]
906    fn insert<K, V>(&mut self, k: K, v: V) -> std::result::Result<Option<Self::Target>, AccessError>
907    where
908        Self::Key: From<K> + Hash + Eq,
909        V: Into<Self::Target>,
910    {
911        self.as_object_mut()
912            .ok_or(AccessError::NotAnObject)
913            .map(|o| o.insert(k, v))
914    }
915
916    #[inline]
917    fn remove<Q>(&mut self, k: &Q) -> std::result::Result<Option<Self::Target>, AccessError>
918    where
919        Self::Key: Borrow<Q>,
920        Q: ?Sized + Hash + Eq + Ord,
921    {
922        self.as_object_mut()
923            .ok_or(AccessError::NotAnObject)
924            .map(|o| o.remove(k))
925    }
926    #[inline]
927    fn get_mut<Q>(&mut self, k: &Q) -> Option<&mut Self::Target>
928    where
929        Self::Key: Borrow<Q>,
930        Q: ?Sized + Hash + Eq + Ord,
931    {
932        self.as_object_mut().and_then(|m| m.get_mut(k))
933    }
934}
935
936impl<T> MutableArray for T
937where
938    T: ValueAsMutArray,
939    T::Array: ArrayMut,
940{
941    type Target = <T::Array as ArrayMut>::Element;
942
943    #[inline]
944    fn push<V>(&mut self, v: V) -> std::result::Result<(), AccessError>
945    where
946        V: Into<Self::Target>,
947    {
948        self.as_array_mut()
949            .ok_or(AccessError::NotAnArray)
950            .map(|o| o.push(v.into()))
951    }
952
953    /// Pops from this `Value` as an `Array`.
954    /// Will return an `AccessError::NotAnArray` if called
955    /// on a `Value` that isn't an `Array` - otherwise will
956    /// behave the same as `Vec::pop`
957    /// # Errors
958    ///
959    /// Will return `Err` if `self` is not an array.
960    #[inline]
961    fn pop(&mut self) -> std::result::Result<Option<Self::Target>, AccessError> {
962        self.as_array_mut()
963            .ok_or(AccessError::NotAnArray)
964            .map(ArrayMut::pop)
965    }
966}
967
968impl<T, I> MutableValueArrayAccess<I> for T
969where
970    T: ValueAsMutArray,
971    T::Array: IndexedMut<I>,
972{
973    type Target = <T::Array as IndexedMut<I>>::Element;
974
975    /// Same as `get_idx` but returns a mutable ref instead
976    #[inline]
977    fn get_idx_mut(&mut self, i: I) -> Option<&mut Self::Target> {
978        self.as_array_mut().and_then(|a| a.get_mut(i))
979    }
980}
value_trait/impls.rs

value_trait/
impls.rs
