avx_arrow/
error.rs

1//! Error types for avx-arrow
2
3use std::fmt;
4
5/// Result type alias for avx-arrow operations
6pub type Result<T> = std::result::Result<T, ArrowError>;
7
8/// Error types for Arrow operations
9#[derive(Debug)]
10pub enum ArrowError {
11    /// Invalid schema definition
12    InvalidSchema {
13        /// Error message
14        message: String
15    },
16
17    /// Schema mismatch
18    SchemaMismatch {
19        /// Expected schema
20        expected: String,
21        /// Actual schema
22        actual: String,
23    },
24
25    /// Invalid field access
26    InvalidField {
27        /// Field name
28        name: String,
29        /// Error message
30        message: String,
31    },
32
33    /// Invalid data type
34    InvalidDataType {
35        /// Type name
36        type_name: String,
37        /// Error message
38        message: String,
39    },
40
41    /// Array length mismatch
42    ArrayLengthMismatch {
43        /// Expected length
44        expected: usize,
45        /// Actual length
46        actual: usize,
47    },
48
49    /// Out of bounds access
50    OutOfBounds {
51        /// Index
52        index: usize,
53        /// Array length
54        length: usize,
55    },
56
57    /// Invalid quaternion
58    InvalidQuaternion {
59        /// Error message
60        message: String
61    },
62
63    /// Invalid tensor
64    InvalidTensor {
65        /// Error message
66        message: String
67    },
68
69    /// Computation error
70    ComputationError {
71        /// Error message
72        message: String
73    },
74
75    /// Invalid data error
76    InvalidData(String),
77
78    /// Internal error
79    Internal {
80        /// Error message
81        message: String
82    },
83}
84
85impl fmt::Display for ArrowError {
86    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
87        match self {
88            ArrowError::InvalidSchema { message } => {
89                write!(f, "Invalid schema: {}", message)
90            }
91            ArrowError::SchemaMismatch { expected, actual } => {
92                write!(f, "Schema mismatch: expected {}, got {}", expected, actual)
93            }
94            ArrowError::InvalidField { name, message } => {
95                write!(f, "Invalid field '{}': {}", name, message)
96            }
97            ArrowError::InvalidDataType { type_name, message } => {
98                write!(f, "Invalid data type '{}': {}", type_name, message)
99            }
100            ArrowError::ArrayLengthMismatch { expected, actual } => {
101                write!(f, "Array length mismatch: expected {}, got {}", expected, actual)
102            }
103            ArrowError::OutOfBounds { index, length } => {
104                write!(f, "Index {} out of bounds for array of length {}", index, length)
105            }
106            ArrowError::InvalidQuaternion { message } => {
107                write!(f, "Invalid quaternion: {}", message)
108            }
109            ArrowError::InvalidTensor { message } => {
110                write!(f, "Invalid tensor: {}", message)
111            }
112            ArrowError::ComputationError { message } => {
113                write!(f, "Computation error: {}", message)
114            }
115            ArrowError::InvalidData(message) => {
116                write!(f, "Invalid data: {}", message)
117            }
118            ArrowError::Internal { message } => {
119                write!(f, "Internal error: {}", message)
120            }
121        }
122    }
123}
124
125impl std::error::Error for ArrowError {}
126
127#[cfg(test)]
128mod tests {
129    use super::*;
130
131    #[test]
132    fn test_error_display() {
133        let err = ArrowError::InvalidSchema {
134            message: "empty schema".to_string(),
135        };
136        assert!(err.to_string().contains("Invalid schema"));
137    }
138
139    #[test]
140    fn test_schema_mismatch() {
141        let err = ArrowError::SchemaMismatch {
142            expected: "Int64".to_string(),
143            actual: "Float64".to_string(),
144        };
145        assert!(err.to_string().contains("mismatch"));
146    }
147
148    #[test]
149    fn test_out_of_bounds() {
150        let err = ArrowError::OutOfBounds {
151            index: 10,
152            length: 5,
153        };
154        assert!(err.to_string().contains("out of bounds"));
155    }
156}
157
158
159
160
161
avx_arrow/error.rs

avx_arrow/
error.rs
