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    fn get<Q>(&self, k: &Q) -> Option<&Self::Target>
286    where
287        Self::Key: Borrow<Q>,
288        Q: ?Sized + Hash + Eq + Ord,
289    {
290        self.as_object().and_then(|a| a.get(k))
291    }
292
293    #[inline]
294    fn contains_key<Q>(&self, k: &Q) -> bool
295    where
296        Self::Key: Borrow<Q>,
297        Q: ?Sized + Hash + Eq + Ord,
298    {
299        self.as_object().and_then(|a| a.get(k)).is_some()
300    }
301}
302
303impl<T> ValueObjectTryAccess for T
304where
305    T: ValueTryAsObject,
306{
307    type Key = <T::Object as Object>::Key;
308    type Target = <T::Object as Object>::Element;
309
310    #[inline]
311    fn try_get<Q>(&self, k: &Q) -> Result<Option<&Self::Target>, TryTypeError>
312    where
313        Self::Key: Borrow<Q>,
314        Q: ?Sized + Hash + Eq + Ord,
315    {
316        Ok(self.try_as_object()?.get(k))
317    }
318}
319
320impl<I, T> ValueArrayAccess<I> for T
321where
322    T: ValueAsArray,
323    <T as ValueAsArray>::Array: Indexed<I>,
324{
325    type Target = <<T as ValueAsArray>::Array as Indexed<I>>::Element;
326    #[inline]
327    fn get_idx(&self, i: I) -> Option<&Self::Target> {
328        self.as_array().and_then(|a| a.get(i))
329    }
330}
331
332impl<T> ValueArrayTryAccess for T
333where
334    T: ValueTryAsArray,
335    <T as ValueTryAsArray>::Array: Indexed<usize>,
336{
337    type Target = <<T as ValueTryAsArray>::Array as Indexed<usize>>::Element;
338
339    /// Tries to get a value based on n index, returns a type error if the
340    /// current value isn't an Array, returns `None` if the index is out of bounds
341    /// # Errors
342    /// if the requested type doesn't match the actual type or the value is not an object
343    #[inline]
344    fn try_get_idx(&self, i: usize) -> Result<Option<&Self::Target>, TryTypeError> {
345        Ok(self.try_as_array()?.get(i))
346    }
347}
348
349impl<T> ValueObjectAccessAsScalar for T
350where
351    T: ValueObjectAccess,
352    <T as ValueObjectAccess>::Target: ValueAsScalar,
353{
354    type Key = T::Key;
355    #[inline]
356    fn get_bool<Q>(&self, k: &Q) -> Option<bool>
357    where
358        Self::Key: Borrow<Q>,
359        Q: ?Sized + Hash + Eq + Ord,
360    {
361        self.get(k).and_then(ValueAsScalar::as_bool)
362    }
363
364    #[inline]
365    fn get_i128<Q>(&self, k: &Q) -> Option<i128>
366    where
367        Self::Key: Borrow<Q>,
368        Q: ?Sized + Hash + Eq + Ord,
369    {
370        self.get(k).and_then(ValueAsScalar::as_i128)
371    }
372
373    #[inline]
374    fn get_i64<Q>(&self, k: &Q) -> Option<i64>
375    where
376        Self::Key: Borrow<Q>,
377        Q: ?Sized + Hash + Eq + Ord,
378    {
379        self.get(k).and_then(ValueAsScalar::as_i64)
380    }
381
382    #[inline]
383    fn get_i32<Q>(&self, k: &Q) -> Option<i32>
384    where
385        Self::Key: Borrow<Q>,
386        Q: ?Sized + Hash + Eq + Ord,
387    {
388        self.get(k).and_then(ValueAsScalar::as_i32)
389    }
390
391    #[inline]
392    fn get_i16<Q>(&self, k: &Q) -> Option<i16>
393    where
394        Self::Key: Borrow<Q>,
395        Q: ?Sized + Hash + Eq + Ord,
396    {
397        self.get(k).and_then(ValueAsScalar::as_i16)
398    }
399
400    #[inline]
401    fn get_i8<Q>(&self, k: &Q) -> Option<i8>
402    where
403        Self::Key: Borrow<Q>,
404        Q: ?Sized + Hash + Eq + Ord,
405    {
406        self.get(k).and_then(ValueAsScalar::as_i8)
407    }
408
409    #[inline]
410    fn get_u128<Q>(&self, k: &Q) -> Option<u128>
411    where
412        Self::Key: Borrow<Q>,
413        Q: ?Sized + Hash + Eq + Ord,
414    {
415        self.get(k).and_then(ValueAsScalar::as_u128)
416    }
417
418    #[inline]
419    fn get_u64<Q>(&self, k: &Q) -> Option<u64>
420    where
421        Self::Key: Borrow<Q>,
422        Q: ?Sized + Hash + Eq + Ord,
423    {
424        self.get(k).and_then(ValueAsScalar::as_u64)
425    }
426
427    #[inline]
428    fn get_usize<Q>(&self, k: &Q) -> Option<usize>
429    where
430        Self::Key: Borrow<Q>,
431        Q: ?Sized + Hash + Eq + Ord,
432    {
433        self.get(k).and_then(ValueAsScalar::as_usize)
434    }
435
436    #[inline]
437    fn get_u32<Q>(&self, k: &Q) -> Option<u32>
438    where
439        Self::Key: Borrow<Q>,
440        Q: ?Sized + Hash + Eq + Ord,
441    {
442        self.get(k).and_then(ValueAsScalar::as_u32)
443    }
444
445    #[inline]
446    fn get_u16<Q>(&self, k: &Q) -> Option<u16>
447    where
448        Self::Key: Borrow<Q>,
449        Q: ?Sized + Hash + Eq + Ord,
450    {
451        self.get(k).and_then(ValueAsScalar::as_u16)
452    }
453
454    #[inline]
455    fn get_u8<Q>(&self, k: &Q) -> Option<u8>
456    where
457        Self::Key: Borrow<Q>,
458        Q: ?Sized + Hash + Eq + Ord,
459    {
460        self.get(k).and_then(ValueAsScalar::as_u8)
461    }
462
463    #[inline]
464    fn get_f64<Q>(&self, k: &Q) -> Option<f64>
465    where
466        Self::Key: Borrow<Q>,
467        Q: ?Sized + Hash + Eq + Ord,
468    {
469        self.get(k).and_then(ValueAsScalar::as_f64)
470    }
471
472    #[inline]
473    fn get_f32<Q>(&self, k: &Q) -> Option<f32>
474    where
475        Self::Key: Borrow<Q>,
476        Q: ?Sized + Hash + Eq + Ord,
477    {
478        self.get(k).and_then(ValueAsScalar::as_f32)
479    }
480
481    #[inline]
482    fn get_str<Q>(&self, k: &Q) -> Option<&str>
483    where
484        Self::Key: Borrow<Q>,
485        Q: ?Sized + Hash + Eq + Ord,
486    {
487        self.get(k).and_then(ValueAsScalar::as_str)
488    }
489}
490
491impl<T> ValueObjectAccessAsArray for T
492where
493    T: ValueObjectAccess,
494    T::Target: ValueAsArray,
495{
496    type Key = T::Key;
497
498    type Array = <T::Target as ValueAsArray>::Array;
499
500    #[inline]
501    fn get_array<Q>(&self, k: &Q) -> Option<&Self::Array>
502    where
503        Self::Key: Borrow<Q>,
504        Q: ?Sized + Hash + Eq + Ord,
505    {
506        self.get(k).and_then(ValueAsArray::as_array)
507    }
508}
509
510impl<T> ValueObjectAccessAsObject for T
511where
512    T: ValueObjectAccess,
513    T::Target: ValueAsObject,
514{
515    type Key = T::Key;
516    type Object = <T::Target as ValueAsObject>::Object;
517
518    #[inline]
519    fn get_object<Q>(&self, k: &Q) -> Option<&Self::Object>
520    where
521        Self::Key: Borrow<Q>,
522        Q: ?Sized + Hash + Eq + Ord,
523    {
524        self.get(k).and_then(ValueAsObject::as_object)
525    }
526}
527
528impl<T> ValueObjectAccessTryAsArray for T
529where
530    T: ValueObjectTryAccess + TypedValue,
531    T::Target: ValueTryAsArray,
532{
533    type Key = T::Key;
534
535    type Array = <T::Target as ValueTryAsArray>::Array;
536
537    #[inline]
538    fn try_get_array<Q>(&self, k: &Q) -> Result<Option<&Self::Array>, TryTypeError>
539    where
540        Self::Key: Borrow<Q>,
541        Q: ?Sized + Hash + Eq + Ord,
542    {
543        self.try_get(k)
544            .and_then(|s| s.map(ValueTryAsArray::try_as_array).transpose())
545    }
546}
547impl<T> ValueObjectAccessTryAsObject for T
548where
549    T: ValueObjectTryAccess + TypedValue,
550    T::Target: ValueTryAsObject,
551{
552    type Key = T::Key;
553
554    type Object = <T::Target as ValueTryAsObject>::Object;
555
556    #[inline]
557    fn try_get_object<Q>(&self, k: &Q) -> Result<Option<&Self::Object>, TryTypeError>
558    where
559        Self::Key: Borrow<Q>,
560        Q: ?Sized + Hash + Eq + Ord,
561    {
562        self.try_get(k)
563            .and_then(|s| s.map(ValueTryAsObject::try_as_object).transpose())
564    }
565}
566
567impl<T> ValueObjectAccessTryAsScalar for T
568where
569    T: ValueObjectTryAccess + TypedValue,
570    T::Target: ValueTryAsScalar,
571{
572    type Key = T::Key;
573
574    fn try_get_bool<Q>(&self, k: &Q) -> Result<Option<bool>, TryTypeError>
575    where
576        Self::Key: Borrow<Q>,
577        Q: ?Sized + Hash + Eq + Ord,
578    {
579        self.try_get(k)?
580            .map(ValueTryAsScalar::try_as_bool)
581            .transpose()
582    }
583
584    fn try_get_i128<Q>(&self, k: &Q) -> Result<Option<i128>, TryTypeError>
585    where
586        Self::Key: Borrow<Q>,
587        Q: ?Sized + Hash + Eq + Ord,
588    {
589        self.try_get(k)?
590            .map(ValueTryAsScalar::try_as_i128)
591            .transpose()
592    }
593
594    fn try_get_i64<Q>(&self, k: &Q) -> Result<Option<i64>, 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_i64)
601            .transpose()
602    }
603
604    fn try_get_i32<Q>(&self, k: &Q) -> Result<Option<i32>, 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_i32)
611            .transpose()
612    }
613
614    fn try_get_i16<Q>(&self, k: &Q) -> Result<Option<i16>, 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_i16)
621            .transpose()
622    }
623
624    fn try_get_i8<Q>(&self, k: &Q) -> Result<Option<i8>, 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_i8)
631            .transpose()
632    }
633
634    fn try_get_u128<Q>(&self, k: &Q) -> Result<Option<u128>, 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_u128)
641            .transpose()
642    }
643
644    fn try_get_u64<Q>(&self, k: &Q) -> Result<Option<u64>, 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_u64)
651            .transpose()
652    }
653
654    fn try_get_usize<Q>(&self, k: &Q) -> Result<Option<usize>, 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_usize)
661            .transpose()
662    }
663
664    fn try_get_u32<Q>(&self, k: &Q) -> Result<Option<u32>, 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_u32)
671            .transpose()
672    }
673
674    fn try_get_u16<Q>(&self, k: &Q) -> Result<Option<u16>, 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_u16)
681            .transpose()
682    }
683
684    fn try_get_u8<Q>(&self, k: &Q) -> Result<Option<u8>, 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_u8)
691            .transpose()
692    }
693
694    fn try_get_f64<Q>(&self, k: &Q) -> Result<Option<f64>, 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_f64)
701            .transpose()
702    }
703
704    fn try_get_f32<Q>(&self, k: &Q) -> Result<Option<f32>, 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_f32)
711            .transpose()
712    }
713
714    fn try_get_str<Q>(&self, k: &Q) -> Result<Option<&str>, 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_str)
721            .transpose()
722    }
723}
724
725impl<T> TypedScalarValue for T
726where
727    T: ValueAsScalar,
728{
729    #[inline]
730    fn is_null(&self) -> bool {
731        self.as_null().is_some()
732    }
733
734    #[inline]
735    fn is_float(&self) -> bool {
736        self.is_f64()
737    }
738
739    #[inline]
740    fn is_integer(&self) -> bool {
741        self.is_i128() || self.is_u128()
742    }
743
744    #[inline]
745    fn is_number(&self) -> bool {
746        self.is_float() || self.is_integer()
747    }
748
749    #[inline]
750    fn is_bool(&self) -> bool {
751        self.as_bool().is_some()
752    }
753
754    #[inline]
755    fn is_i128(&self) -> bool {
756        self.as_i128().is_some()
757    }
758
759    #[inline]
760    fn is_i64(&self) -> bool {
761        self.as_i64().is_some()
762    }
763
764    #[inline]
765    fn is_i32(&self) -> bool {
766        self.as_i32().is_some()
767    }
768
769    #[inline]
770    fn is_i16(&self) -> bool {
771        self.as_i16().is_some()
772    }
773
774    #[inline]
775    fn is_i8(&self) -> bool {
776        self.as_i8().is_some()
777    }
778
779    #[inline]
780    fn is_u128(&self) -> bool {
781        self.as_u128().is_some()
782    }
783
784    #[inline]
785    fn is_u64(&self) -> bool {
786        self.as_u64().is_some()
787    }
788
789    #[inline]
790    fn is_usize(&self) -> bool {
791        self.as_usize().is_some()
792    }
793
794    #[inline]
795    fn is_u32(&self) -> bool {
796        self.as_u32().is_some()
797    }
798
799    #[inline]
800    fn is_u16(&self) -> bool {
801        self.as_u16().is_some()
802    }
803
804    #[inline]
805    fn is_u8(&self) -> bool {
806        self.as_u8().is_some()
807    }
808
809    #[inline]
810    fn is_f64(&self) -> bool {
811        self.as_f64().is_some()
812    }
813
814    #[inline]
815    fn is_f64_castable(&self) -> bool {
816        self.cast_f64().is_some()
817    }
818
819    #[inline]
820    fn is_f32(&self) -> bool {
821        self.as_f32().is_some()
822    }
823
824    #[inline]
825    fn is_str(&self) -> bool {
826        self.as_str().is_some()
827    }
828
829    #[inline]
830    fn is_char(&self) -> bool {
831        self.as_char().is_some()
832    }
833}
834
835impl<T> TypedArrayValue for T
836where
837    T: ValueAsArray,
838{
839    #[inline]
840    fn is_array(&self) -> bool {
841        self.as_array().is_some()
842    }
843}
844impl<T> TypedObjectValue for T
845where
846    T: ValueAsObject,
847{
848    #[inline]
849    fn is_object(&self) -> bool {
850        self.as_object().is_some()
851    }
852}
853impl<T> MutableObject for T
854where
855    T: ValueAsMutObject,
856    T::Object: ObjectMut,
857{
858    type Key = <T::Object as ObjectMut>::Key;
859    type Target = <T::Object as ObjectMut>::Element;
860    type Object = T::Object;
861
862    #[inline]
863    fn insert<K, V>(&mut self, k: K, v: V) -> std::result::Result<Option<Self::Target>, AccessError>
864    where
865        Self::Key: From<K> + Hash + Eq,
866        V: Into<Self::Target>,
867    {
868        self.as_object_mut()
869            .ok_or(AccessError::NotAnObject)
870            .map(|o| o.insert(k, v))
871    }
872
873    #[inline]
874    fn remove<Q>(&mut self, k: &Q) -> std::result::Result<Option<Self::Target>, AccessError>
875    where
876        Self::Key: Borrow<Q>,
877        Q: ?Sized + Hash + Eq + Ord,
878    {
879        self.as_object_mut()
880            .ok_or(AccessError::NotAnObject)
881            .map(|o| o.remove(k))
882    }
883    #[inline]
884    fn get_mut<Q>(&mut self, k: &Q) -> Option<&mut Self::Target>
885    where
886        Self::Key: Borrow<Q>,
887        Q: ?Sized + Hash + Eq + Ord,
888    {
889        self.as_object_mut().and_then(|m| m.get_mut(k))
890    }
891}
892
893impl<T> MutableArray for T
894where
895    T: ValueAsMutArray,
896    T::Array: ArrayMut,
897{
898    type Target = <T::Array as ArrayMut>::Element;
899
900    #[inline]
901    fn push<V>(&mut self, v: V) -> std::result::Result<(), AccessError>
902    where
903        V: Into<Self::Target>,
904    {
905        self.as_array_mut()
906            .ok_or(AccessError::NotAnArray)
907            .map(|o| o.push(v.into()))
908    }
909
910    /// Pops from this `Value` as an `Array`.
911    /// Will return an `AccessError::NotAnArray` if called
912    /// on a `Value` that isn't an `Array` - otherwise will
913    /// behave the same as `Vec::pop`
914    /// # Errors
915    ///
916    /// Will return `Err` if `self` is not an array.
917    #[inline]
918    fn pop(&mut self) -> std::result::Result<Option<Self::Target>, AccessError> {
919        self.as_array_mut()
920            .ok_or(AccessError::NotAnArray)
921            .map(ArrayMut::pop)
922    }
923}
924
925impl<T, I> MutableValueArrayAccess<I> for T
926where
927    T: ValueAsMutArray,
928    T::Array: IndexedMut<I>,
929{
930    type Target = <T::Array as IndexedMut<I>>::Element;
931
932    /// Same as `get_idx` but returns a mutable ref instead
933    #[inline]
934    fn get_idx_mut(&mut self, i: I) -> Option<&mut Self::Target> {
935        self.as_array_mut().and_then(|a| a.get_mut(i))
936    }
937}
value_trait/impls.rs

value_trait/
impls.rs
