logisheets_parser 0.7.0

the parser of excel formula
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

use logisheets_base::errors::BasicError;
use logisheets_base::get_book_name::GetBookNameTrait;
use logisheets_base::id_fetcher::{IdFetcherTrait, VertexFetcherTrait};
use logisheets_base::{
    Cube, CubeId, ExtBookId, ExtRef, ExtRefId, FuncId, NameId, NormalCellId, Range, RangeId,
    SheetId, TextId,
};

pub trait ContextTrait: IdFetcherTrait + GetBookNameTrait + VertexFetcherTrait {}

pub struct Context<'a, T, F>
where
    T: IdFetcherTrait,
    F: VertexFetcherTrait,
{
    pub book_name: &'a str,
    pub id_fetcher: &'a mut T,
    pub vertex_fetcher: &'a mut F,
}

impl<'a, T, F> ContextTrait for Context<'a, T, F>
where
    T: IdFetcherTrait,
    F: VertexFetcherTrait,
{
}

impl<'a, T, F> VertexFetcherTrait for Context<'a, T, F>
where
    T: IdFetcherTrait,
    F: VertexFetcherTrait,
{
    fn fetch_range_id(&mut self, sheet_id: &SheetId, range: &Range) -> RangeId {
        self.vertex_fetcher.fetch_range_id(sheet_id, range)
    }

    fn fetch_cube_id(&mut self, cube: &Cube) -> CubeId {
        self.vertex_fetcher.fetch_cube_id(cube)
    }

    fn fetch_ext_ref_id(&mut self, ext_ref: &ExtRef) -> ExtRefId {
        self.vertex_fetcher.fetch_ext_ref_id(ext_ref)
    }
}

impl<'a, T, F> GetBookNameTrait for Context<'a, T, F>
where
    T: IdFetcherTrait,
    F: VertexFetcherTrait,
{
    fn get_book_name(&self) -> &str {
        self.book_name
    }
}

impl<'a, T, F> IdFetcherTrait for Context<'a, T, F>
where
    T: IdFetcherTrait,
    F: VertexFetcherTrait,
{
    fn fetch_row_id(
        &self,
        sheet_id: &SheetId,
        row_idx: usize,
    ) -> std::result::Result<logisheets_base::RowId, BasicError> {
        self.id_fetcher.fetch_row_id(sheet_id, row_idx)
    }

    fn fetch_col_id(
        &self,
        sheet_id: &SheetId,
        col_idx: usize,
    ) -> std::result::Result<logisheets_base::ColId, BasicError> {
        self.id_fetcher.fetch_col_id(sheet_id, col_idx)
    }

    fn fetch_cell_id(
        &self,
        sheet_id: &SheetId,
        row_idx: usize,
        col_idx: usize,
    ) -> std::result::Result<logisheets_base::CellId, BasicError> {
        self.id_fetcher.fetch_cell_id(sheet_id, row_idx, col_idx)
    }

    fn fetch_sheet_id(&mut self, sheet_name: &str) -> SheetId {
        self.id_fetcher.fetch_sheet_id(sheet_name)
    }

    fn fetch_name_id(&mut self, workbook: &Option<&str>, name: &str) -> NameId {
        self.id_fetcher.fetch_name_id(workbook, name)
    }

    fn fetch_ext_book_id(&mut self, book: &str) -> ExtBookId {
        self.id_fetcher.fetch_ext_book_id(book)
    }

    fn fetch_text_id(&mut self, text: &str) -> TextId {
        self.id_fetcher.fetch_text_id(text)
    }

    fn fetch_func_id(&mut self, func_name: &str) -> FuncId {
        self.id_fetcher.fetch_func_id(func_name)
    }

    fn fetch_norm_cell_id(
        &self,
        sheet_id: &SheetId,
        row_idx: usize,
        col_idx: usize,
    ) -> std::result::Result<NormalCellId, BasicError> {
        self.id_fetcher
            .fetch_norm_cell_id(sheet_id, row_idx, col_idx)
    }

    fn fetch_block_cell_id(
        &self,
        sheet_id: &SheetId,
        block_id: &logisheets_base::BlockId,
        row: usize,
        col: usize,
    ) -> Result<logisheets_base::BlockCellId, BasicError> {
        self.id_fetcher
            .fetch_block_cell_id(sheet_id, block_id, row, col)
    }
}