qubit-value 0.7.7

Type-safe value container framework with unified abstractions for single values, multi-values, and named values with complete serde support
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

/*******************************************************************************
 *
 *    Copyright (c) 2025 - 2026 Haixing Hu.
 *
 *    SPDX-License-Identifier: Apache-2.0
 *
 *    Licensed under the Apache License, Version 2.0.
 *
 ******************************************************************************/
//! # Value Processing Error Types
//!
//! Defines various errors that may occur during value processing.
//!

use qubit_datatype::{
    DataConversionError,
    DataType,
};
use thiserror::Error;

/// Value processing error type
///
/// Defines various error conditions that may occur during value operations.
///
/// # Features
///
/// - Type mismatch error
/// - No value error
/// - Type conversion failure error
/// - Conversion error
///
/// # Example
///
/// ```rust
/// use qubit_value::ValueError;
///
/// let error = ValueError::NoValue;
/// assert_eq!(error.to_string(), "No value");
/// ```
///
///
#[derive(Debug, Error, PartialEq, Eq)]
pub enum ValueError {
    /// No value
    #[error("No value")]
    NoValue,

    /// Type mismatch
    #[error("Type mismatch: expected {expected}, actual {actual}")]
    TypeMismatch {
        /// Expected data type
        expected: DataType,
        /// Actual data type
        actual: DataType,
    },

    /// Type conversion failed
    #[error("Type conversion failed: from {from} to {to}")]
    ConversionFailed {
        /// Source data type
        from: DataType,
        /// Target data type
        to: DataType,
    },

    /// Conversion error (with detailed information)
    #[error("Conversion error: {0}")]
    ConversionError(String),

    /// Index out of bounds
    #[error("Index out of bounds: index {index}, length {len}")]
    IndexOutOfBounds {
        /// Accessed index
        index: usize,
        /// Actual length
        len: usize,
    },

    /// JSON serialization error
    #[error("JSON serialization error: {0}")]
    JsonSerializationError(String),

    /// JSON deserialization error
    #[error("JSON deserialization error: {0}")]
    JsonDeserializationError(String),
}

/// Value processing result type
pub type ValueResult<T> = Result<T, ValueError>;

/// Maps a shared `qubit_datatype` conversion error into this crate's error type.
///
/// # Parameters
///
/// * `error` - The error returned by the shared data conversion layer.
///
/// # Returns
///
/// Returns the corresponding [`ValueError`] variant.
pub(crate) fn map_data_conversion_error(error: DataConversionError) -> ValueError {
    match error {
        DataConversionError::NoValue => ValueError::NoValue,
        DataConversionError::ConversionFailed { from, to } => {
            ValueError::ConversionFailed { from, to }
        }
        DataConversionError::ConversionError(message) => ValueError::ConversionError(message),
        DataConversionError::JsonSerializationError(message) => {
            ValueError::JsonSerializationError(message)
        }
        DataConversionError::JsonDeserializationError(message) => {
            ValueError::JsonDeserializationError(message)
        }
    }
}