1use std::{
2 collections::{BTreeMap, BTreeSet},
3 path::PathBuf,
4};
5
6use allocative::Allocative;
7use rawdb::{Database, Reader, Region};
8
9use crate::{
10 AnyCollectableVec, AnyIterableVec, AnyStoredVec, AnyVec, BoxedVecIterator, CollectableVec,
11 GenericStoredVec, Header, Result, StoredCompressed, StoredIndex, Version,
12 variants::ImportOptions,
13};
14
15use super::{CompressedVec, RawVec};
16
17mod format;
18mod iterator;
19
20pub use format::*;
21pub use iterator::*;
22
23#[derive(Debug, Clone, Allocative)]
24pub enum StoredVec<I, T> {
25 Raw(RawVec<I, T>),
26 Compressed(CompressedVec<I, T>),
27}
28
29impl<I, T> StoredVec<I, T>
30where
31 I: StoredIndex,
32 T: StoredCompressed,
33{
34 pub fn forced_import(
35 db: &Database,
36 name: &str,
37 version: Version,
38 format: Format,
39 ) -> Result<Self> {
40 Self::forced_import_with((db, name, version).into(), format)
41 }
42
43 pub fn forced_import_with(options: ImportOptions, format: Format) -> Result<Self> {
44 if options.version == Version::ZERO {
45 dbg!(options);
46 panic!("Version must be at least 1, can't verify endianness otherwise");
47 }
48
49 if format.is_compressed() {
50 Ok(Self::Compressed(CompressedVec::forced_import_with(
51 options,
52 )?))
53 } else {
54 Ok(Self::Raw(RawVec::forced_import_with(options)?))
55 }
56 }
57}
58
59impl<I, T> AnyVec for StoredVec<I, T>
60where
61 I: StoredIndex,
62 T: StoredCompressed,
63{
64 #[inline]
65 fn version(&self) -> Version {
66 match self {
67 StoredVec::Raw(v) => v.version(),
68 StoredVec::Compressed(v) => v.version(),
69 }
70 }
71
72 #[inline]
73 fn index_type_to_string(&self) -> &'static str {
74 I::to_string()
75 }
76
77 #[inline]
78 fn len(&self) -> usize {
79 self.pushed_len() + self.stored_len()
80 }
81
82 fn name(&self) -> &str {
83 match self {
84 StoredVec::Raw(v) => v.name(),
85 StoredVec::Compressed(v) => v.name(),
86 }
87 }
88
89 #[inline]
90 fn value_type_to_size_of(&self) -> usize {
91 size_of::<T>()
92 }
93
94 #[inline]
95 fn region_names(&self) -> Vec<String> {
96 match self {
97 StoredVec::Raw(v) => v.region_names(),
98 StoredVec::Compressed(v) => v.region_names(),
99 }
100 }
101}
102
103impl<I, T> AnyStoredVec for StoredVec<I, T>
104where
105 I: StoredIndex,
106 T: StoredCompressed,
107{
108 #[inline]
109 fn db_path(&self) -> PathBuf {
110 match self {
111 StoredVec::Raw(v) => v.db_path(),
112 StoredVec::Compressed(v) => v.db_path(),
113 }
114 }
115
116 #[inline]
117 fn region(&self) -> &Region {
118 match self {
119 StoredVec::Raw(v) => v.region(),
120 StoredVec::Compressed(v) => v.region(),
121 }
122 }
123
124 #[inline]
125 fn header(&self) -> &Header {
126 match self {
127 StoredVec::Raw(v) => v.header(),
128 StoredVec::Compressed(v) => v.header(),
129 }
130 }
131
132 #[inline]
133 fn mut_header(&mut self) -> &mut Header {
134 match self {
135 StoredVec::Raw(v) => v.mut_header(),
136 StoredVec::Compressed(v) => v.mut_header(),
137 }
138 }
139
140 #[inline]
141 fn saved_stamped_changes(&self) -> u16 {
142 match self {
143 StoredVec::Raw(v) => v.saved_stamped_changes(),
144 StoredVec::Compressed(v) => v.saved_stamped_changes(),
145 }
146 }
147
148 #[inline]
149 fn stored_len(&self) -> usize {
150 match self {
151 StoredVec::Raw(v) => v.stored_len(),
152 StoredVec::Compressed(v) => v.stored_len(),
153 }
154 }
155
156 #[inline]
157 fn real_stored_len(&self) -> usize {
158 match self {
159 StoredVec::Raw(v) => v.real_stored_len(),
160 StoredVec::Compressed(v) => v.real_stored_len(),
161 }
162 }
163
164 fn flush(&mut self) -> Result<()> {
165 match self {
166 StoredVec::Raw(v) => v.flush(),
167 StoredVec::Compressed(v) => v.flush(),
168 }
169 }
170
171 fn serialize_changes(&self) -> Result<Vec<u8>> {
172 match self {
173 StoredVec::Raw(v) => v.serialize_changes(),
174 StoredVec::Compressed(v) => v.serialize_changes(),
175 }
176 }
177}
178
179impl<I, T> GenericStoredVec<I, T> for StoredVec<I, T>
180where
181 I: StoredIndex,
182 T: StoredCompressed,
183{
184 #[inline]
185 fn read_(&self, index: usize, reader: &Reader) -> Result<T> {
186 match self {
187 StoredVec::Raw(v) => v.read_(index, reader),
188 StoredVec::Compressed(v) => v.read_(index, reader),
189 }
190 }
191
192 #[inline]
193 fn pushed(&self) -> &[T] {
194 match self {
195 StoredVec::Raw(v) => v.pushed(),
196 StoredVec::Compressed(v) => v.pushed(),
197 }
198 }
199 #[inline]
200 fn mut_pushed(&mut self) -> &mut Vec<T> {
201 match self {
202 StoredVec::Raw(v) => v.mut_pushed(),
203 StoredVec::Compressed(v) => v.mut_pushed(),
204 }
205 }
206 #[inline]
207 fn prev_pushed(&self) -> &[T] {
208 match self {
209 StoredVec::Raw(v) => v.prev_pushed(),
210 StoredVec::Compressed(v) => v.prev_pushed(),
211 }
212 }
213 #[inline]
214 fn mut_prev_pushed(&mut self) -> &mut Vec<T> {
215 match self {
216 StoredVec::Raw(v) => v.mut_prev_pushed(),
217 StoredVec::Compressed(v) => v.mut_prev_pushed(),
218 }
219 }
220
221 #[inline]
222 fn holes(&self) -> &BTreeSet<usize> {
223 match self {
224 StoredVec::Raw(v) => v.holes(),
225 StoredVec::Compressed(v) => v.holes(),
226 }
227 }
228 #[inline]
229 fn mut_holes(&mut self) -> &mut BTreeSet<usize> {
230 match self {
231 StoredVec::Raw(v) => v.mut_holes(),
232 StoredVec::Compressed(v) => v.mut_holes(),
233 }
234 }
235 #[inline]
236 fn prev_holes(&self) -> &BTreeSet<usize> {
237 match self {
238 StoredVec::Raw(v) => v.prev_holes(),
239 StoredVec::Compressed(v) => v.prev_holes(),
240 }
241 }
242 #[inline]
243 fn mut_prev_holes(&mut self) -> &mut BTreeSet<usize> {
244 match self {
245 StoredVec::Raw(v) => v.mut_prev_holes(),
246 StoredVec::Compressed(v) => v.mut_prev_holes(),
247 }
248 }
249
250 #[inline]
251 fn updated(&self) -> &BTreeMap<usize, T> {
252 match self {
253 StoredVec::Raw(v) => v.updated(),
254 StoredVec::Compressed(v) => v.updated(),
255 }
256 }
257 #[inline]
258 fn mut_updated(&mut self) -> &mut BTreeMap<usize, T> {
259 match self {
260 StoredVec::Raw(v) => v.mut_updated(),
261 StoredVec::Compressed(v) => v.mut_updated(),
262 }
263 }
264 #[inline]
265 fn prev_updated(&self) -> &BTreeMap<usize, T> {
266 match self {
267 StoredVec::Raw(v) => v.prev_updated(),
268 StoredVec::Compressed(v) => v.prev_updated(),
269 }
270 }
271 #[inline]
272 fn mut_prev_updated(&mut self) -> &mut BTreeMap<usize, T> {
273 match self {
274 StoredVec::Raw(v) => v.mut_prev_updated(),
275 StoredVec::Compressed(v) => v.mut_prev_updated(),
276 }
277 }
278
279 #[inline]
280 #[doc(hidden)]
281 fn update_stored_len(&self, val: usize) {
282 match self {
283 StoredVec::Raw(v) => v.update_stored_len(val),
284 StoredVec::Compressed(v) => v.update_stored_len(val),
285 }
286 }
287 fn prev_stored_len(&self) -> usize {
288 match self {
289 StoredVec::Raw(v) => v.prev_stored_len(),
290 StoredVec::Compressed(v) => v.prev_stored_len(),
291 }
292 }
293 fn mut_prev_stored_len(&mut self) -> &mut usize {
294 match self {
295 StoredVec::Raw(v) => v.mut_prev_stored_len(),
296 StoredVec::Compressed(v) => v.mut_prev_stored_len(),
297 }
298 }
299
300 #[inline]
301 fn truncate_if_needed(&mut self, index: I) -> Result<()> {
302 match self {
303 StoredVec::Raw(v) => v.truncate_if_needed(index),
304 StoredVec::Compressed(v) => v.truncate_if_needed(index),
305 }
306 }
307
308 #[inline]
309 fn reset(&mut self) -> Result<()> {
310 match self {
311 StoredVec::Raw(v) => v.reset(),
312 StoredVec::Compressed(v) => v.reset(),
313 }
314 }
315}
316
317impl<'a, I, T> IntoIterator for &'a StoredVec<I, T>
318where
319 I: StoredIndex,
320 T: StoredCompressed,
321{
322 type Item = T;
323 type IntoIter = StoredVecIterator<'a, I, T>;
324
325 fn into_iter(self) -> Self::IntoIter {
326 match self {
327 StoredVec::Compressed(v) => StoredVecIterator::Compressed(v.into_iter()),
328 StoredVec::Raw(v) => StoredVecIterator::Raw(v.into_iter()),
329 }
330 }
331}
332
333impl<I, T> AnyIterableVec<I, T> for StoredVec<I, T>
334where
335 I: StoredIndex,
336 T: StoredCompressed,
337{
338 fn boxed_iter(&self) -> BoxedVecIterator<'_, I, T> {
339 Box::new(self.into_iter())
340 }
341}
342
343impl<I, T> AnyCollectableVec for StoredVec<I, T>
344where
345 I: StoredIndex,
346 T: StoredCompressed,
347{
348 fn collect_range_json_bytes(&self, from: Option<usize>, to: Option<usize>) -> Vec<u8> {
349 CollectableVec::collect_range_json_bytes(self, from, to)
350 }
351
352 fn collect_range_string(&self, from: Option<usize>, to: Option<usize>) -> Vec<String> {
353 CollectableVec::collect_range_string(self, from, to)
354 }
355}