qubit_value/value/value_accessors.rs
1use std::collections::HashMap;
2use std::time::Duration;
3
4use bigdecimal::BigDecimal;
5use chrono::{DateTime, NaiveDate, NaiveDateTime, NaiveTime, Utc};
6use num_bigint::BigInt;
7use serde::Serialize;
8use serde::de::DeserializeOwned;
9use url::Url;
10
11use qubit_common::lang::DataType;
12
13use super::value_core::Value;
14use crate::error::{ValueError, ValueResult};
15
16macro_rules! impl_get_value {
17 // Copy type: directly dereference and return
18 ($(#[$attr:meta])* copy: $method:ident, $variant:ident, $type:ty, $data_type:expr) => {
19 $(#[$attr])*
20 #[inline]
21 pub fn $method(&self) -> ValueResult<$type> {
22 match self {
23 Value::$variant(v) => Ok(*v),
24 Value::Empty(_) => Err(ValueError::NoValue),
25 _ => Err(ValueError::TypeMismatch {
26 expected: $data_type,
27 actual: self.data_type(),
28 }),
29 }
30 }
31 };
32
33 // Reference type: use conversion function to return reference,
34 // fixing lifetime issues
35 ($(#[$attr:meta])* ref: $method:ident, $variant:ident, $ret_type:ty, $data_type:expr, $conversion:expr) => {
36 $(#[$attr])*
37 #[inline]
38 pub fn $method(&self) -> ValueResult<$ret_type> {
39 match self {
40 Value::$variant(v) => {
41 let conv_fn: fn(&_) -> $ret_type = $conversion;
42 Ok(conv_fn(v))
43 },
44 Value::Empty(_) => Err(ValueError::NoValue),
45 _ => Err(ValueError::TypeMismatch {
46 expected: $data_type,
47 actual: self.data_type(),
48 }),
49 }
50 }
51 };
52}
53
54/// Unified setter generation macro
55///
56/// Supports two modes:
57/// 1. `copy:` - For types implementing the Copy trait, directly sets the value
58/// 2. `owned:` - For non-Copy types, requires owning the value
59///
60/// # Documentation Comment Support
61///
62/// The macro automatically extracts preceding documentation comments, so
63/// you can add `///` comments before macro invocations.
64///
65/// # Author
66///
67/// Haixing Hu
68///
69macro_rules! impl_set_value {
70 // Copy type: directly set the value
71 ($(#[$attr:meta])* copy: $method:ident, $variant:ident, $type:ty, $data_type:expr) => {
72 $(#[$attr])*
73 #[inline]
74 pub fn $method(&mut self, value: $type) -> ValueResult<()> {
75 *self = Value::$variant(value);
76 Ok(())
77 }
78 };
79
80 // Owned type: set the owned value
81 ($(#[$attr:meta])* owned: $method:ident, $variant:ident, $type:ty, $data_type:expr) => {
82 $(#[$attr])*
83 #[inline]
84 pub fn $method(&mut self, value: $type) -> ValueResult<()> {
85 *self = Value::$variant(value);
86 Ok(())
87 }
88 };
89}
90
91impl Value {
92 // ========================================================================
93 // Type-checking getters (strict type matching)
94 // ========================================================================
95
96 impl_get_value! {
97 /// Get boolean value
98 ///
99 /// # Returns
100 ///
101 /// If types match, returns the boolean value; otherwise returns an
102 /// error.
103 ///
104 /// # Example
105 ///
106 /// ```rust
107 /// use qubit_value::Value;
108 ///
109 /// let value = Value::Bool(true);
110 /// assert_eq!(value.get_bool().unwrap(), true);
111 /// ```
112 copy: get_bool, Bool, bool, DataType::Bool
113 }
114
115 impl_get_value! {
116 /// Get character value
117 ///
118 /// # Returns
119 ///
120 /// If types match, returns the character value; otherwise returns an
121 /// error.
122 ///
123 /// # Example
124 ///
125 /// ```rust
126 /// use qubit_value::Value;
127 ///
128 /// let value = Value::Char('A');
129 /// assert_eq!(value.get_char().unwrap(), 'A');
130 /// ```
131 copy: get_char, Char, char, DataType::Char
132 }
133
134 impl_get_value! {
135 /// Get int8 value
136 ///
137 /// # Returns
138 ///
139 /// If types match, returns the int8 value; otherwise returns an error.
140 copy: get_int8, Int8, i8, DataType::Int8
141 }
142
143 impl_get_value! {
144 /// Get int16 value
145 ///
146 /// # Returns
147 ///
148 /// If types match, returns the int16 value; otherwise returns an error
149 copy: get_int16, Int16, i16, DataType::Int16
150 }
151
152 impl_get_value! {
153 /// Get int32 value
154 ///
155 /// # Returns
156 ///
157 /// If types match, returns the int32 value; otherwise returns an error.
158 copy: get_int32, Int32, i32, DataType::Int32
159 }
160
161 impl_get_value! {
162 /// Get int64 value
163 ///
164 /// # Returns
165 ///
166 /// If types match, returns the int64 value; otherwise returns an error
167 copy: get_int64, Int64, i64, DataType::Int64
168 }
169
170 impl_get_value! {
171 /// Get int128 value
172 ///
173 /// # Returns
174 ///
175 /// If types match, returns the int128 value; otherwise returns an error.
176 copy: get_int128, Int128, i128, DataType::Int128
177 }
178
179 impl_get_value! {
180 /// Get uint8 value
181 ///
182 /// # Returns
183 ///
184 /// If types match, returns the uint8 value; otherwise returns an error
185 copy: get_uint8, UInt8, u8, DataType::UInt8
186 }
187
188 impl_get_value! {
189 /// Get uint16 value
190 ///
191 /// # Returns
192 ///
193 /// If types match, returns the uint16 value; otherwise returns an error.
194 copy: get_uint16, UInt16, u16, DataType::UInt16
195 }
196
197 impl_get_value! {
198 /// Get uint32 value
199 ///
200 /// # Returns
201 ///
202 /// If types match, returns the uint32 value; otherwise returns an error.
203 copy: get_uint32, UInt32, u32, DataType::UInt32
204 }
205
206 impl_get_value! {
207 /// Get uint64 value
208 ///
209 /// # Returns
210 ///
211 /// If types match, returns the uint64 value; otherwise returns an error.
212 copy: get_uint64, UInt64, u64, DataType::UInt64
213 }
214
215 impl_get_value! {
216 /// Get uint128 value
217 ///
218 /// # Returns
219 ///
220 /// If types match, returns the uint128 value; otherwise returns an error
221 copy: get_uint128, UInt128, u128, DataType::UInt128
222 }
223
224 impl_get_value! {
225 /// Get float32 value
226 ///
227 /// # Returns
228 ///
229 /// If types match, returns the float32 value; otherwise returns an error.
230 copy: get_float32, Float32, f32, DataType::Float32
231 }
232
233 impl_get_value! {
234 /// Get float64 value
235 ///
236 /// # Returns
237 ///
238 /// If types match, returns the float64 value; otherwise returns an error
239 copy: get_float64, Float64, f64, DataType::Float64
240 }
241
242 impl_get_value! {
243 /// Get string reference
244 ///
245 /// # Returns
246 ///
247 /// If types match, returns a reference to the string; otherwise returns
248 /// an error.
249 ///
250 /// # Example
251 ///
252 /// ```rust
253 /// use qubit_value::Value;
254 ///
255 /// let value = Value::String("hello".to_string());
256 /// assert_eq!(value.get_string().unwrap(), "hello");
257 /// ```
258 ref: get_string, String, &str, DataType::String, |s: &String| s.as_str()
259 }
260
261 impl_get_value! {
262 /// Get date value
263 ///
264 /// # Returns
265 ///
266 /// If types match, returns the date value; otherwise returns an error.
267 copy: get_date, Date, NaiveDate, DataType::Date
268 }
269
270 impl_get_value! {
271 /// Get time value
272 ///
273 /// # Returns
274 ///
275 /// If types match, returns the time value; otherwise returns an error.
276 copy: get_time, Time, NaiveTime, DataType::Time
277 }
278
279 impl_get_value! {
280 /// Get datetime value
281 ///
282 /// # Returns
283 ///
284 /// If types match, returns the datetime value; otherwise returns an error.
285 copy: get_datetime, DateTime, NaiveDateTime, DataType::DateTime
286 }
287
288 impl_get_value! {
289 /// Get UTC instant value
290 ///
291 /// # Returns
292 ///
293 /// If types match, returns the UTC instant value; otherwise returns an error.
294 copy: get_instant, Instant, DateTime<Utc>, DataType::Instant
295 }
296
297 impl_get_value! {
298 /// Get big integer value
299 ///
300 /// # Returns
301 ///
302 /// If types match, returns the big integer value; otherwise returns an error.
303 ///
304 /// # Example
305 ///
306 /// ```rust
307 /// use qubit_value::Value;
308 /// use num_bigint::BigInt;
309 ///
310 /// let value = Value::BigInteger(BigInt::from(123456789));
311 /// assert_eq!(value.get_biginteger().unwrap(), BigInt::from(123456789));
312 /// ```
313 ref: get_biginteger, BigInteger, BigInt, DataType::BigInteger, |v: &BigInt| v.clone()
314 }
315
316 impl_get_value! {
317 /// Get big decimal value
318 ///
319 /// # Returns
320 ///
321 /// If types match, returns the big decimal value; otherwise returns an
322 /// error.
323 ///
324 /// # Example
325 ///
326 /// ```rust
327 /// use std::str::FromStr;
328 ///
329 /// use bigdecimal::BigDecimal;
330 /// use qubit_value::Value;
331 ///
332 /// let bd = BigDecimal::from_str("123.456").unwrap();
333 /// let value = Value::BigDecimal(bd.clone());
334 /// assert_eq!(value.get_bigdecimal().unwrap(), bd);
335 /// ```
336 ref: get_bigdecimal, BigDecimal, BigDecimal, DataType::BigDecimal, |v: &BigDecimal| v.clone()
337 }
338
339 // ========================================================================
340 // Type-setting setters (strict type matching)
341 // ========================================================================
342
343 impl_set_value! {
344 /// Set boolean value
345 ///
346 /// # Parameters
347 ///
348 /// * `value` - The boolean value to set
349 ///
350 /// # Returns
351 ///
352 /// If setting succeeds, returns `Ok(())`; otherwise returns an error.
353 ///
354 /// # Example
355 ///
356 /// ```rust
357 /// use qubit_common::lang::DataType;
358 /// use qubit_value::Value;
359 ///
360 /// let mut value = Value::Empty(DataType::Bool);
361 /// value.set_bool(true).unwrap();
362 /// assert_eq!(value.get_bool().unwrap(), true);
363 /// ```
364 copy: set_bool, Bool, bool, DataType::Bool
365 }
366
367 impl_set_value! {
368 /// Set character value
369 ///
370 /// # Parameters
371 ///
372 /// * `value` - The character value to set
373 ///
374 /// # Returns
375 ///
376 /// If setting succeeds, returns `Ok(())`; otherwise returns an error.
377 copy: set_char, Char, char, DataType::Char
378 }
379
380 impl_set_value! {
381 /// Set int8 value
382 ///
383 /// # Parameters
384 ///
385 /// * `value` - The int8 value to set
386 ///
387 /// # Returns
388 ///
389 /// If setting succeeds, returns `Ok(())`; otherwise returns an error.
390 copy: set_int8, Int8, i8, DataType::Int8
391 }
392
393 impl_set_value! {
394 /// Set int16 value
395 ///
396 /// # Parameters
397 ///
398 /// * `value` - The int16 value to set
399 ///
400 /// # Returns
401 ///
402 /// If setting succeeds, returns `Ok(())`; otherwise returns an error.
403 copy: set_int16, Int16, i16, DataType::Int16
404 }
405
406 impl_set_value! {
407 /// Set int32 value
408 ///
409 /// # Parameters
410 ///
411 /// * `value` - The int32 value to set
412 ///
413 /// # Returns
414 ///
415 /// If setting succeeds, returns `Ok(())`; otherwise returns an error.
416 copy: set_int32, Int32, i32, DataType::Int32
417 }
418
419 impl_set_value! {
420 /// Set int64 value
421 ///
422 /// # Parameters
423 ///
424 /// * `value` - The int64 value to set
425 ///
426 /// # Returns
427 ///
428 /// If setting succeeds, returns `Ok(())`; otherwise returns an error.
429 copy: set_int64, Int64, i64, DataType::Int64
430 }
431
432 impl_set_value! {
433 /// Set int128 value
434 ///
435 /// # Parameters
436 ///
437 /// * `value` - The int128 value to set
438 ///
439 /// # Returns
440 ///
441 /// If setting succeeds, returns `Ok(())`; otherwise returns an error.
442 copy: set_int128, Int128, i128, DataType::Int128
443 }
444
445 impl_set_value! {
446 /// Set uint8 value
447 ///
448 /// # Parameters
449 ///
450 /// * `value` - The uint8 value to set
451 ///
452 /// # Returns
453 ///
454 /// If setting succeeds, returns `Ok(())`; otherwise returns an error.
455 copy: set_uint8, UInt8, u8, DataType::UInt8
456 }
457
458 impl_set_value! {
459 /// Set uint16 value
460 ///
461 /// # Parameters
462 ///
463 /// * `value` - The uint16 value to set
464 ///
465 /// # Returns
466 ///
467 /// If setting succeeds, returns `Ok(())`; otherwise returns an error.
468 copy: set_uint16, UInt16, u16, DataType::UInt16
469 }
470
471 impl_set_value! {
472 /// Set uint32 value
473 ///
474 /// # Parameters
475 ///
476 /// * `value` - The uint32 value to set
477 ///
478 /// # Returns
479 ///
480 /// If setting succeeds, returns `Ok(())`; otherwise returns an error.
481 copy: set_uint32, UInt32, u32, DataType::UInt32
482 }
483
484 impl_set_value! {
485 /// Set uint64 value
486 ///
487 /// # Parameters
488 ///
489 /// * `value` - The uint64 value to set
490 ///
491 /// # Returns
492 ///
493 /// If setting succeeds, returns `Ok(())`; otherwise returns an error.
494 copy: set_uint64, UInt64, u64, DataType::UInt64
495 }
496
497 impl_set_value! {
498 /// Set uint128 value
499 ///
500 /// # Parameters
501 ///
502 /// * `value` - The uint128 value to set
503 ///
504 /// # Returns
505 ///
506 /// If setting succeeds, returns `Ok(())`; otherwise returns an error.
507 copy: set_uint128, UInt128, u128, DataType::UInt128
508 }
509
510 impl_set_value! {
511 /// Set float32 value
512 ///
513 /// # Parameters
514 ///
515 /// * `value` - The float32 value to set
516 ///
517 /// # Returns
518 ///
519 /// If setting succeeds, returns `Ok(())`; otherwise returns an error.
520 copy: set_float32, Float32, f32, DataType::Float32
521 }
522
523 impl_set_value! {
524 /// Set float64 value
525 ///
526 /// # Parameters
527 ///
528 /// * `value` - The float64 value to set
529 ///
530 /// # Returns
531 ///
532 /// If setting succeeds, returns `Ok(())`; otherwise returns an error.
533 copy: set_float64, Float64, f64, DataType::Float64
534 }
535
536 impl_set_value! {
537 /// Set string value
538 ///
539 /// # Parameters
540 ///
541 /// * `value` - The string value to set
542 ///
543 /// # Returns
544 ///
545 /// If setting succeeds, returns `Ok(())`; otherwise returns an error.
546 ///
547 /// # Example
548 ///
549 /// ```rust
550 /// use qubit_common::lang::DataType;
551 /// use qubit_value::Value;
552 ///
553 /// let mut value = Value::Empty(DataType::String);
554 /// value.set_string("hello".to_string()).unwrap();
555 /// assert_eq!(value.get_string().unwrap(), "hello");
556 /// ```
557 owned: set_string, String, String, DataType::String
558 }
559
560 impl_set_value! {
561 /// Set date value
562 ///
563 /// # Parameters
564 ///
565 /// * `value` - The date value to set
566 ///
567 /// # Returns
568 ///
569 /// If setting succeeds, returns `Ok(())`; otherwise returns an error.
570 copy: set_date, Date, NaiveDate, DataType::Date
571 }
572
573 impl_set_value! {
574 /// Set time value
575 ///
576 /// # Parameters
577 ///
578 /// * `value` - The time value to set
579 ///
580 /// # Returns
581 ///
582 /// If setting succeeds, returns `Ok(())`; otherwise returns an error.
583 copy: set_time, Time, NaiveTime, DataType::Time
584 }
585
586 impl_set_value! {
587 /// Set datetime value
588 ///
589 /// # Parameters
590 ///
591 /// * `value` - The datetime value to set
592 ///
593 /// # Returns
594 ///
595 /// If setting succeeds, returns `Ok(())`; otherwise returns an error.
596 copy: set_datetime, DateTime, NaiveDateTime, DataType::DateTime
597 }
598
599 impl_set_value! {
600 /// Set UTC instant value
601 ///
602 /// # Parameters
603 ///
604 /// * `value` - The UTC instant value to set
605 ///
606 /// # Returns
607 ///
608 /// If setting succeeds, returns `Ok(())`; otherwise returns an error.
609 copy: set_instant, Instant, DateTime<Utc>, DataType::Instant
610 }
611
612 impl_set_value! {
613 /// Set big integer value
614 ///
615 /// # Parameters
616 ///
617 /// * `value` - The big integer value to set
618 ///
619 /// # Returns
620 ///
621 /// If setting succeeds, returns `Ok(())`; otherwise returns an error.
622 ///
623 /// # Example
624 ///
625 /// ```rust
626 /// use num_bigint::BigInt;
627 /// use qubit_common::lang::DataType;
628 /// use qubit_value::Value;
629 ///
630 /// let mut value = Value::Empty(DataType::BigInteger);
631 /// value.set_biginteger(BigInt::from(123456789)).unwrap();
632 /// assert_eq!(value.get_biginteger().unwrap(), BigInt::from(123456789));
633 /// ```
634 owned: set_biginteger, BigInteger, BigInt, DataType::BigInteger
635 }
636
637 impl_set_value! {
638 /// Set big decimal value
639 ///
640 /// # Parameters
641 ///
642 /// * `value` - The big decimal value to set
643 ///
644 /// # Returns
645 ///
646 /// If setting succeeds, returns `Ok(())`; otherwise returns an error.
647 ///
648 /// # Example
649 ///
650 /// ```rust
651 /// use std::str::FromStr;
652 ///
653 /// use bigdecimal::BigDecimal;
654 /// use qubit_common::lang::DataType;
655 /// use qubit_value::Value;
656 ///
657 /// let mut value = Value::Empty(DataType::BigDecimal);
658 /// let bd = BigDecimal::from_str("123.456").unwrap();
659 /// value.set_bigdecimal(bd.clone()).unwrap();
660 /// assert_eq!(value.get_bigdecimal().unwrap(), bd);
661 /// ```
662 owned: set_bigdecimal, BigDecimal, BigDecimal, DataType::BigDecimal
663 }
664
665 impl_get_value! {
666 /// Get isize value
667 ///
668 /// # Returns
669 ///
670 /// If types match, returns the isize value; otherwise returns an error.
671 copy: get_intsize, IntSize, isize, DataType::IntSize
672 }
673
674 impl_get_value! {
675 /// Get usize value
676 ///
677 /// # Returns
678 ///
679 /// If types match, returns the usize value; otherwise returns an error.
680 copy: get_uintsize, UIntSize, usize, DataType::UIntSize
681 }
682
683 impl_get_value! {
684 /// Get Duration value
685 ///
686 /// # Returns
687 ///
688 /// If types match, returns the Duration value; otherwise returns an
689 /// error.
690 copy: get_duration, Duration, Duration, DataType::Duration
691 }
692
693 impl_get_value! {
694 /// Get Url reference
695 ///
696 /// # Returns
697 ///
698 /// If types match, returns a reference to the Url; otherwise returns an
699 /// error.
700 ref: get_url, Url, Url, DataType::Url, |v: &Url| v.clone()
701 }
702
703 impl_get_value! {
704 /// Get StringMap reference
705 ///
706 /// # Returns
707 ///
708 /// If types match, returns a reference to the `HashMap<String, String>`;
709 /// otherwise returns an error.
710 ref: get_string_map, StringMap, HashMap<String, String>, DataType::StringMap,
711 |v: &HashMap<String, String>| v.clone()
712 }
713
714 impl_get_value! {
715 /// Get Json value reference
716 ///
717 /// # Returns
718 ///
719 /// If types match, returns a reference to the `serde_json::Value`;
720 /// otherwise returns an error.
721 ref: get_json, Json, serde_json::Value, DataType::Json,
722 |v: &serde_json::Value| v.clone()
723 }
724
725 /// Borrow the inner `BigInt` without cloning.
726 pub fn get_biginteger_ref(&self) -> ValueResult<&BigInt> {
727 match self {
728 Value::BigInteger(v) => Ok(v),
729 Value::Empty(_) => Err(ValueError::NoValue),
730 _ => Err(ValueError::TypeMismatch {
731 expected: DataType::BigInteger,
732 actual: self.data_type(),
733 }),
734 }
735 }
736
737 /// Borrow the inner `BigDecimal` without cloning.
738 pub fn get_bigdecimal_ref(&self) -> ValueResult<&BigDecimal> {
739 match self {
740 Value::BigDecimal(v) => Ok(v),
741 Value::Empty(_) => Err(ValueError::NoValue),
742 _ => Err(ValueError::TypeMismatch {
743 expected: DataType::BigDecimal,
744 actual: self.data_type(),
745 }),
746 }
747 }
748
749 /// Borrow the inner `Url` without cloning.
750 pub fn get_url_ref(&self) -> ValueResult<&Url> {
751 match self {
752 Value::Url(v) => Ok(v),
753 Value::Empty(_) => Err(ValueError::NoValue),
754 _ => Err(ValueError::TypeMismatch {
755 expected: DataType::Url,
756 actual: self.data_type(),
757 }),
758 }
759 }
760
761 /// Borrow the inner `HashMap<String, String>` without cloning.
762 pub fn get_string_map_ref(&self) -> ValueResult<&HashMap<String, String>> {
763 match self {
764 Value::StringMap(v) => Ok(v),
765 Value::Empty(_) => Err(ValueError::NoValue),
766 _ => Err(ValueError::TypeMismatch {
767 expected: DataType::StringMap,
768 actual: self.data_type(),
769 }),
770 }
771 }
772
773 /// Borrow the inner JSON value without cloning.
774 pub fn get_json_ref(&self) -> ValueResult<&serde_json::Value> {
775 match self {
776 Value::Json(v) => Ok(v),
777 Value::Empty(_) => Err(ValueError::NoValue),
778 _ => Err(ValueError::TypeMismatch {
779 expected: DataType::Json,
780 actual: self.data_type(),
781 }),
782 }
783 }
784
785 impl_set_value! {
786 /// Set isize value
787 copy: set_intsize, IntSize, isize, DataType::IntSize
788 }
789
790 impl_set_value! {
791 /// Set usize value
792 copy: set_uintsize, UIntSize, usize, DataType::UIntSize
793 }
794
795 impl_set_value! {
796 /// Set Duration value
797 copy: set_duration, Duration, Duration, DataType::Duration
798 }
799
800 impl_set_value! {
801 /// Set Url value
802 owned: set_url, Url, Url, DataType::Url
803 }
804
805 impl_set_value! {
806 /// Set StringMap value
807 owned: set_string_map, StringMap, HashMap<String, String>, DataType::StringMap
808 }
809
810 impl_set_value! {
811 /// Set Json value
812 owned: set_json, Json, serde_json::Value, DataType::Json
813 }
814
815 /// Create a `Value` from a `serde_json::Value`.
816 ///
817 /// # Parameters
818 ///
819 /// * `json` - The JSON value to wrap.
820 ///
821 /// # Returns
822 ///
823 /// Returns a `Value::Json` wrapping the given JSON value.
824 #[inline]
825 pub fn from_json_value(json: serde_json::Value) -> Self {
826 Value::Json(json)
827 }
828
829 /// Create a `Value` from any serializable value by converting it to JSON.
830 ///
831 /// # Type Parameters
832 ///
833 /// * `T` - Any type implementing `Serialize`.
834 ///
835 /// # Parameters
836 ///
837 /// * `value` - The value to serialize into JSON.
838 ///
839 /// # Returns
840 ///
841 /// Returns `Ok(Value::Json(...))` on success, or an error if
842 /// serialization fails.
843 pub fn from_serializable<T: Serialize>(value: &T) -> ValueResult<Self> {
844 let json = serde_json::to_value(value)
845 .map_err(|e| ValueError::JsonSerializationError(e.to_string()))?;
846 Ok(Value::Json(json))
847 }
848
849 /// Deserialize the inner JSON value into a target type.
850 ///
851 /// Only works when `self` is `Value::Json(...)`.
852 ///
853 /// # Type Parameters
854 ///
855 /// * `T` - The target type implementing `DeserializeOwned`.
856 ///
857 /// # Returns
858 ///
859 /// Returns `Ok(T)` on success, or an error if the value is not JSON
860 /// or deserialization fails.
861 pub fn deserialize_json<T: DeserializeOwned>(&self) -> ValueResult<T> {
862 match self {
863 Value::Json(v) => serde_json::from_value(v.clone())
864 .map_err(|e| ValueError::JsonDeserializationError(e.to_string())),
865 Value::Empty(_) => Err(ValueError::NoValue),
866 _ => Err(ValueError::ConversionFailed {
867 from: self.data_type(),
868 to: DataType::Json,
869 }),
870 }
871 }
872}