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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

//! Worksheet implementation for XLSB files

use std::collections::BTreeMap;
use crate::sheet::{Worksheet, Cell as SheetCell, CellValue, CellIterator, RowIterator};
use crate::ooxml::xlsb::cell::XlsbCell;

/// XLSB worksheet implementation
#[derive(Debug, Clone)]
pub struct XlsbWorksheet {
    name: String,
    cells: BTreeMap<(u32, u32), XlsbCell>,
    max_row: u32,
    max_col: u32,
}

impl XlsbWorksheet {
    /// Create a new worksheet
    pub fn new(name: String) -> Self {
        XlsbWorksheet {
            name,
            cells: BTreeMap::new(),
            max_row: 0,
            max_col: 0,
        }
    }

    /// Add a cell to the worksheet
    pub fn add_cell(&mut self, cell: XlsbCell) {
        let pos = (cell.row(), cell.column());
        self.max_row = self.max_row.max(cell.row());
        self.max_col = self.max_col.max(cell.column());
        self.cells.insert(pos, cell);
    }

    /// Get cell at position
    pub fn get_cell(&self, row: u32, col: u32) -> Option<&XlsbCell> {
        self.cells.get(&(row, col))
    }
}

impl Worksheet for XlsbWorksheet {
    fn name(&self) -> &str {
        &self.name
    }

    fn row_count(&self) -> usize {
        (self.max_row + 1) as usize
    }

    fn column_count(&self) -> usize {
        (self.max_col + 1) as usize
    }

    fn dimensions(&self) -> Option<(u32, u32, u32, u32)> {
        if self.cells.is_empty() {
            None
        } else {
            Some((0, 0, self.max_row, self.max_col))
        }
    }

    fn cell(&self, row: u32, column: u32) -> Result<Box<dyn SheetCell + '_>, Box<dyn std::error::Error>> {
        match self.cells.get(&(row, column)) {
            Some(cell) => Ok(Box::new(cell.clone())),
            None => {
                // Return empty cell for missing positions
                let empty_cell = XlsbCell::new(row, column, CellValue::Empty);
                Ok(Box::new(empty_cell))
            }
        }
    }

    fn cell_by_coordinate(&self, coordinate: &str) -> Result<Box<dyn SheetCell + '_>, Box<dyn std::error::Error>> {
        let (row, col) = crate::ooxml::xlsb::utils::parse_cell_reference(coordinate)?;
        self.cell(row, col)
    }

    fn cells(&self) -> Box<dyn CellIterator<'_> + '_> {
        Box::new(XlsbCellIterator {
            cells: self.cells.values().collect(),
            index: 0,
        })
    }

    fn rows(&self) -> Box<dyn RowIterator<'_> + '_> {
        Box::new(XlsbRowIterator {
            worksheet: self,
            current_row: 0,
        })
    }

    fn row(&self, row_idx: usize) -> Result<Vec<CellValue>, Box<dyn std::error::Error>> {
        let row_idx = row_idx as u32;
        let mut row_data = Vec::new();

        for col in 0..=self.max_col {
            match self.cells.get(&(row_idx, col)) {
                Some(cell) => row_data.push(cell.value().clone()),
                None => row_data.push(CellValue::Empty),
            }
        }

        Ok(row_data)
    }

    fn cell_value(&self, row: u32, column: u32) -> Result<CellValue, Box<dyn std::error::Error>> {
        match self.cells.get(&(row, column)) {
            Some(cell) => Ok(cell.value().clone()),
            None => Ok(CellValue::Empty),
        }
    }
}

/// Cell iterator for XLSB worksheets
struct XlsbCellIterator<'a> {
    cells: Vec<&'a XlsbCell>,
    index: usize,
}

impl<'a> CellIterator<'a> for XlsbCellIterator<'a> {
    fn next(&mut self) -> Option<Result<Box<dyn SheetCell + 'a>, Box<dyn std::error::Error>>> {
        if self.index >= self.cells.len() {
            None
        } else {
            let cell = self.cells[self.index];
            self.index += 1;
            Some(Ok(Box::new(cell.clone())))
        }
    }
}

/// Row iterator for XLSB worksheets
struct XlsbRowIterator<'a> {
    worksheet: &'a XlsbWorksheet,
    current_row: usize,
}

impl<'a> RowIterator<'a> for XlsbRowIterator<'a> {
    fn next(&mut self) -> Option<Result<Vec<CellValue>, Box<dyn std::error::Error>>> {
        if self.current_row >= self.worksheet.row_count() {
            None
        } else {
            let result = self.worksheet.row(self.current_row);
            self.current_row += 1;
            Some(result)
        }
    }
}