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

text_document_common/direct_access/table/
table_table.rs
