text_document_common/direct_access/table_cell/
table_cell_table.rs

1use crate::database::hashmap_store::{
2    HashMapStore, delete_from_backward_junction, junction_get, junction_remove, junction_set,
3};
4use crate::entities::*;
5use crate::error::RepositoryError;
6use crate::types::EntityId;
7use crate::{impl_relationship_methods, impl_write_relationship_methods};
8use std::collections::HashMap;
9use std::sync::RwLock;
10
11use super::table_cell_repository::{TableCellRelationshipField, TableCellTable, TableCellTableRO};
12
13pub struct TableCellHashMapTable<'a> {
14    store: &'a HashMapStore,
15}
16
17impl<'a> TableCellHashMapTable<'a> {
18    pub fn new(store: &'a HashMapStore) -> Self {
19        Self { store }
20    }
21
22    fn resolve_junction(
23        &self,
24        field: &TableCellRelationshipField,
25    ) -> &RwLock<HashMap<EntityId, Vec<EntityId>>> {
26        match field {
27            TableCellRelationshipField::CellFrame => {
28                &self.store.jn_frame_from_table_cell_cell_frame
29            }
30        }
31    }
32
33    fn hydrate(&self, entity: &mut TableCell) {
34        entity.cell_frame =
35            junction_get(&self.store.jn_frame_from_table_cell_cell_frame, &entity.id)
36                .into_iter()
37                .next();
38    }
39}
40
41impl<'a> TableCellTable for TableCellHashMapTable<'a> {
42    fn create(&mut self, entity: &TableCell) -> Result<TableCell, RepositoryError> {
43        self.create_multi(std::slice::from_ref(entity))
44            .map(|v| v.into_iter().next().unwrap())
45    }
46
47    fn create_multi(&mut self, entities: &[TableCell]) -> Result<Vec<TableCell>, RepositoryError> {
48        let mut created = Vec::with_capacity(entities.len());
49        let mut cells = self.store.table_cells.write().unwrap();
50
51        for entity in entities {
52            let new_entity = if entity.id == EntityId::default() {
53                let id = self.store.next_id("table_cell");
54                TableCell {
55                    id,
56                    ..entity.clone()
57                }
58            } else {
59                if cells.contains_key(&entity.id) {
60                    return Err(RepositoryError::DuplicateId {
61                        entity: "TableCell",
62                        id: entity.id,
63                    });
64                }
65                entity.clone()
66            };
67
68            cells.insert(new_entity.id, new_entity.clone());
69            junction_set(
70                &self.store.jn_frame_from_table_cell_cell_frame,
71                new_entity.id,
72                new_entity.cell_frame.into_iter().collect(),
73            );
74            created.push(new_entity);
75        }
76        Ok(created)
77    }
78
79    fn get(&self, id: &EntityId) -> Result<Option<TableCell>, RepositoryError> {
80        let cells = self.store.table_cells.read().unwrap();
81        match cells.get(id) {
82            Some(entity) => {
83                let mut e = entity.clone();
84                drop(cells);
85                self.hydrate(&mut e);
86                Ok(Some(e))
87            }
88            None => Ok(None),
89        }
90    }
91
92    fn get_multi(&self, ids: &[EntityId]) -> Result<Vec<Option<TableCell>>, RepositoryError> {
93        let mut result = Vec::with_capacity(ids.len());
94        for id in ids {
95            result.push(self.get(id)?);
96        }
97        Ok(result)
98    }
99
100    fn get_all(&self) -> Result<Vec<TableCell>, RepositoryError> {
101        let cells = self.store.table_cells.read().unwrap();
102        let entries: Vec<TableCell> = cells.values().cloned().collect();
103        drop(cells);
104        let mut result = Vec::with_capacity(entries.len());
105        for mut entity in entries {
106            self.hydrate(&mut entity);
107            result.push(entity);
108        }
109        Ok(result)
110    }
111
112    fn update(&mut self, entity: &TableCell) -> Result<TableCell, RepositoryError> {
113        self.update_multi(std::slice::from_ref(entity))
114            .map(|v| v.into_iter().next().unwrap())
115    }
116
117    fn update_multi(&mut self, entities: &[TableCell]) -> Result<Vec<TableCell>, RepositoryError> {
118        let mut cells = self.store.table_cells.write().unwrap();
119        for entity in entities {
120            cells.insert(entity.id, entity.clone());
121        }
122        drop(cells);
123        let ids: Vec<EntityId> = entities.iter().map(|e| e.id).collect();
124        let result = self.get_multi(&ids)?;
125        Ok(result.into_iter().flatten().collect())
126    }
127
128    fn update_with_relationships(
129        &mut self,
130        entity: &TableCell,
131    ) -> Result<TableCell, RepositoryError> {
132        self.update_with_relationships_multi(std::slice::from_ref(entity))
133            .map(|v| v.into_iter().next().unwrap())
134    }
135
136    fn update_with_relationships_multi(
137        &mut self,
138        entities: &[TableCell],
139    ) -> Result<Vec<TableCell>, RepositoryError> {
140        let mut cells = self.store.table_cells.write().unwrap();
141        for entity in entities {
142            cells.insert(entity.id, entity.clone());
143            junction_set(
144                &self.store.jn_frame_from_table_cell_cell_frame,
145                entity.id,
146                entity.cell_frame.into_iter().collect(),
147            );
148        }
149        drop(cells);
150        let ids: Vec<EntityId> = entities.iter().map(|e| e.id).collect();
151        let result = self.get_multi(&ids)?;
152        Ok(result.into_iter().flatten().collect())
153    }
154
155    fn remove(&mut self, id: &EntityId) -> Result<(), RepositoryError> {
156        self.remove_multi(std::slice::from_ref(id))
157    }
158
159    fn remove_multi(&mut self, ids: &[EntityId]) -> Result<(), RepositoryError> {
160        let mut cells = self.store.table_cells.write().unwrap();
161        for id in ids {
162            cells.remove(id);
163            junction_remove(&self.store.jn_frame_from_table_cell_cell_frame, id);
164            // backward: from table cells junction
165            delete_from_backward_junction(&self.store.jn_table_cell_from_table_cells, id);
166        }
167        Ok(())
168    }
169
170    impl_write_relationship_methods!(TableCellHashMapTable<'a>, TableCellRelationshipField);
171}
172
173pub struct TableCellHashMapTableRO<'a> {
174    store: &'a HashMapStore,
175}
176
177impl<'a> TableCellHashMapTableRO<'a> {
178    pub fn new(store: &'a HashMapStore) -> Self {
179        Self { store }
180    }
181
182    fn resolve_junction(
183        &self,
184        field: &TableCellRelationshipField,
185    ) -> &RwLock<HashMap<EntityId, Vec<EntityId>>> {
186        match field {
187            TableCellRelationshipField::CellFrame => {
188                &self.store.jn_frame_from_table_cell_cell_frame
189            }
190        }
191    }
192
193    fn hydrate(&self, entity: &mut TableCell) {
194        entity.cell_frame =
195            junction_get(&self.store.jn_frame_from_table_cell_cell_frame, &entity.id)
196                .into_iter()
197                .next();
198    }
199}
200
201impl<'a> TableCellTableRO for TableCellHashMapTableRO<'a> {
202    fn get(&self, id: &EntityId) -> Result<Option<TableCell>, RepositoryError> {
203        let cells = self.store.table_cells.read().unwrap();
204        match cells.get(id) {
205            Some(entity) => {
206                let mut e = entity.clone();
207                drop(cells);
208                self.hydrate(&mut e);
209                Ok(Some(e))
210            }
211            None => Ok(None),
212        }
213    }
214
215    fn get_multi(&self, ids: &[EntityId]) -> Result<Vec<Option<TableCell>>, RepositoryError> {
216        let mut result = Vec::with_capacity(ids.len());
217        for id in ids {
218            result.push(self.get(id)?);
219        }
220        Ok(result)
221    }
222
223    fn get_all(&self) -> Result<Vec<TableCell>, RepositoryError> {
224        let cells = self.store.table_cells.read().unwrap();
225        let entries: Vec<TableCell> = cells.values().cloned().collect();
226        drop(cells);
227        let mut result = Vec::with_capacity(entries.len());
228        for mut entity in entries {
229            self.hydrate(&mut entity);
230            result.push(entity);
231        }
232        Ok(result)
233    }
234
235    impl_relationship_methods!(TableCellHashMapTableRO<'a>, TableCellRelationshipField);
236}
text_document_common/direct_access/table_cell/table_cell_table.rs

text_document_common/direct_access/table_cell/
table_cell_table.rs
