litchi 0.0.1

High-performance parser for Microsoft Office, OpenDocument, and Apple iWork file formats with unified API
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 XLS file parsing

use std::fmt;

/// Result type alias for XLS operations
pub type XlsResult<T> = Result<T, XlsError>;

/// Errors that can occur during XLS file parsing
#[derive(Debug)]
pub enum XlsError {
    /// I/O error
    Io(std::io::Error),
    /// CFB (Compound File Binary) error
    Cfb(crate::ole::file::OleError),
    /// Invalid BIFF record
    InvalidRecord {
        /// Record type
        record_type: u16,
        /// Error description
        message: String,
    },
    /// Unsupported BIFF version
    UnsupportedBiffVersion(u16),
    /// Password protected workbook
    PasswordProtected,
    /// Invalid data length
    InvalidLength {
        /// Expected length
        expected: usize,
        /// Found length
        found: usize,
    },
    /// End of stream reached unexpectedly
    UnexpectedEndOfStream(String),
    /// Invalid formula
    InvalidFormula(String),
    /// Invalid cell reference
    InvalidCellReference(String),
    /// Worksheet not found
    WorksheetNotFound(String),
    /// Invalid format code
    InvalidFormat(u16),
    /// Encoding error
    Encoding(String),
    /// Unsupported feature
    UnsupportedFeature(String),
    /// Invalid data
    InvalidData(String),
    /// Unexpected record type
    UnexpectedRecordType {
        /// Expected record type
        expected: u16,
        /// Found record type
        found: u16,
    },
    /// End of file
    Eof(&'static str),
}

impl fmt::Display for XlsError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            XlsError::Io(e) => write!(f, "I/O error: {}", e),
            XlsError::Cfb(e) => write!(f, "CFB error: {}", e),
            XlsError::InvalidRecord { record_type, message } => {
                write!(f, "Invalid record 0x{:04X}: {}", record_type, message)
            }
            XlsError::UnsupportedBiffVersion(version) => {
                write!(f, "Unsupported BIFF version: {}", version)
            }
            XlsError::PasswordProtected => {
                write!(f, "Workbook is password protected")
            }
            XlsError::InvalidLength { expected, found } => {
                write!(f, "Invalid length: expected {}, found {}", expected, found)
            }
            XlsError::UnexpectedEndOfStream(context) => {
                write!(f, "Unexpected end of stream: {}", context)
            }
            XlsError::InvalidFormula(msg) => {
                write!(f, "Invalid formula: {}", msg)
            }
            XlsError::InvalidCellReference(ref_str) => {
                write!(f, "Invalid cell reference: {}", ref_str)
            }
            XlsError::WorksheetNotFound(name) => {
                write!(f, "Worksheet '{}' not found", name)
            }
            XlsError::InvalidFormat(code) => {
                write!(f, "Invalid format code: {}", code)
            }
            XlsError::Encoding(msg) => {
                write!(f, "Encoding error: {}", msg)
            }
            XlsError::UnsupportedFeature(feature) => {
                write!(f, "Unsupported feature: {}", feature)
            }
            XlsError::InvalidData(msg) => {
                write!(f, "Invalid data: {}", msg)
            }
            XlsError::UnexpectedRecordType { expected, found } => {
                write!(f, "Unexpected record type: expected 0x{:04X}, found 0x{:04X}", expected, found)
            }
            XlsError::Eof(context) => {
                write!(f, "End of file: {}", context)
            }
        }
    }
}

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

impl From<std::io::Error> for XlsError {
    fn from(err: std::io::Error) -> Self {
        XlsError::Io(err)
    }
}

impl From<crate::ole::file::OleError> for XlsError {
    fn from(err: crate::ole::file::OleError) -> Self {
        XlsError::Cfb(err)
    }
}