scirs2-core 0.4.2

Core utilities and common functionality for SciRS2 (scirs2-core)
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

//! Error types for Arrow interoperability
//!
//! Provides specialized error types for Arrow ↔ ndarray conversions,
//! IPC serialization, and schema operations.

use crate::error::{CoreError, ErrorContext};
use std::fmt;

/// Errors that can occur during Arrow interoperability operations
#[derive(Debug)]
pub enum ArrowCompatError {
    /// Type mismatch between expected and actual Arrow data types
    TypeMismatch { expected: String, actual: String },
    /// Shape mismatch when converting between Arrow and ndarray
    ShapeMismatch {
        expected: Vec<usize>,
        actual: Vec<usize>,
    },
    /// Column index out of bounds in a RecordBatch
    ColumnOutOfBounds { index: usize, num_columns: usize },
    /// Column name not found in a RecordBatch
    ColumnNotFound { name: String },
    /// Null values encountered where not expected
    NullValuesPresent {
        null_count: usize,
        total_count: usize,
    },
    /// Error from the underlying Arrow library
    ArrowError(arrow::error::ArrowError),
    /// I/O error during IPC operations
    IoError(std::io::Error),
    /// Schema validation error
    SchemaError(String),
    /// Zero-copy operation not possible
    ZeroCopyNotPossible(String),
    /// Inconsistent column lengths in a RecordBatch
    InconsistentColumnLengths {
        expected_len: usize,
        column_index: usize,
        column_len: usize,
    },
}

impl fmt::Display for ArrowCompatError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::TypeMismatch { expected, actual } => {
                write!(
                    f,
                    "Arrow type mismatch: expected {}, got {}",
                    expected, actual
                )
            }
            Self::ShapeMismatch { expected, actual } => {
                write!(
                    f,
                    "Shape mismatch: expected {:?}, got {:?}",
                    expected, actual
                )
            }
            Self::ColumnOutOfBounds { index, num_columns } => {
                write!(
                    f,
                    "Column index {} out of bounds (num_columns={})",
                    index, num_columns
                )
            }
            Self::ColumnNotFound { name } => {
                write!(f, "Column '{}' not found in RecordBatch", name)
            }
            Self::NullValuesPresent {
                null_count,
                total_count,
            } => {
                write!(
                    f,
                    "Found {} null values out of {} total (use nullable conversion instead)",
                    null_count, total_count
                )
            }
            Self::ArrowError(e) => write!(f, "Arrow error: {}", e),
            Self::IoError(e) => write!(f, "I/O error: {}", e),
            Self::SchemaError(msg) => write!(f, "Schema error: {}", msg),
            Self::ZeroCopyNotPossible(reason) => {
                write!(f, "Zero-copy not possible: {}", reason)
            }
            Self::InconsistentColumnLengths {
                expected_len,
                column_index,
                column_len,
            } => {
                write!(
                    f,
                    "Inconsistent column lengths: expected {} rows, column {} has {} rows",
                    expected_len, column_index, column_len
                )
            }
        }
    }
}

impl std::error::Error for ArrowCompatError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match self {
            Self::ArrowError(e) => Some(e),
            Self::IoError(e) => Some(e),
            _ => None,
        }
    }
}

impl From<arrow::error::ArrowError> for ArrowCompatError {
    fn from(e: arrow::error::ArrowError) -> Self {
        Self::ArrowError(e)
    }
}

impl From<std::io::Error> for ArrowCompatError {
    fn from(e: std::io::Error) -> Self {
        Self::IoError(e)
    }
}

impl From<ArrowCompatError> for CoreError {
    fn from(e: ArrowCompatError) -> Self {
        CoreError::ComputationError(ErrorContext::new(format!("Arrow interop: {}", e)))
    }
}

/// Result type for Arrow interoperability operations
pub type ArrowResult<T> = Result<T, ArrowCompatError>;