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