1use crate::DbError;
2use crate::StorageData;
3use crate::storage::Storage;
4use crate::storage::StorageIndex;
5use crate::utilities::serialize::Serialize;
6use crate::utilities::serialize::SerializeStatic;
7use std::marker::PhantomData;
8
9pub trait VecData<T, D, E>
10where
11 D: StorageData,
12{
13 fn capacity(&self) -> u64;
14 fn len(&self) -> u64;
15 fn reallocate(&mut self, storage: &mut Storage<D>, capacity: u64) -> Result<(), E>;
16 fn remove_from_storage(self, storage: &mut Storage<D>) -> Result<(), E>;
17 fn remove(&mut self, storage: &mut Storage<D>, index: u64) -> Result<T, E>;
18 fn replace(&mut self, storage: &mut Storage<D>, index: u64, value: &T) -> Result<T, E>;
19 fn resize(&mut self, storage: &mut Storage<D>, new_len: u64, value: &T) -> Result<(), E>;
20 fn swap(&mut self, storage: &mut Storage<D>, index: u64, other: u64) -> Result<(), E>;
21 fn value(&self, storage: &Storage<D>, index: u64) -> Result<T, E>;
22}
23
24pub trait VecValue<D: StorageData>: Sized {
25 fn store(&self, storage: &mut Storage<D>) -> Result<Vec<u8>, DbError>;
26 fn load(storage: &Storage<D>, bytes: &[u8]) -> Result<Self, DbError>;
27 fn remove(storage: &mut Storage<D>, bytes: &[u8]) -> Result<(), DbError>;
28 fn storage_len() -> u64;
29}
30
31impl<D: StorageData> VecValue<D> for u64 {
32 fn store(&self, _storage: &mut Storage<D>) -> Result<Vec<u8>, DbError> {
33 Ok(self.serialize())
34 }
35
36 fn load(_storage: &Storage<D>, bytes: &[u8]) -> Result<Self, DbError> {
37 Self::deserialize(bytes)
38 }
39
40 fn remove(_storage: &mut Storage<D>, _bytes: &[u8]) -> Result<(), DbError> {
41 Ok(())
42 }
43
44 fn storage_len() -> u64 {
45 Self::serialized_size_static()
46 }
47}
48
49impl<D: StorageData> VecValue<D> for i64 {
50 fn store(&self, _storage: &mut Storage<D>) -> Result<Vec<u8>, DbError> {
51 Ok(self.serialize())
52 }
53
54 fn load(_storage: &Storage<D>, bytes: &[u8]) -> Result<Self, DbError> {
55 Self::deserialize(bytes)
56 }
57
58 fn remove(_storage: &mut Storage<D>, _bytes: &[u8]) -> Result<(), DbError> {
59 Ok(())
60 }
61
62 fn storage_len() -> u64 {
63 Self::serialized_size_static()
64 }
65}
66
67impl<D: StorageData> VecValue<D> for String {
68 fn store(&self, storage: &mut Storage<D>) -> Result<Vec<u8>, DbError> {
69 let index = storage.insert(self)?;
70 Ok(index.serialize())
71 }
72
73 fn load(storage: &Storage<D>, bytes: &[u8]) -> Result<Self, DbError> {
74 let index = StorageIndex::deserialize(bytes)?;
75 storage.value(index)
76 }
77
78 fn remove(storage: &mut Storage<D>, bytes: &[u8]) -> Result<(), DbError> {
79 let index = StorageIndex::deserialize(bytes)?;
80 storage.remove(index)
81 }
82
83 fn storage_len() -> u64 {
84 StorageIndex::serialized_size_static()
85 }
86}
87
88pub struct DbVecData<T, D, E>
89where
90 T: VecValue<D>,
91 D: StorageData,
92 E: From<DbError>,
93{
94 capacity: u64,
95 len: u64,
96 storage_index: StorageIndex,
97 phantom_data: PhantomData<(T, D, E)>,
98}
99
100impl<T, D, E> DbVecData<T, D, E>
101where
102 T: VecValue<D>,
103 D: StorageData,
104 E: From<DbError>,
105{
106 fn offset(index: u64) -> u64 {
107 u64::serialized_size_static() + T::storage_len() * index
108 }
109}
110
111impl<T, D, E> VecData<T, D, E> for DbVecData<T, D, E>
112where
113 T: VecValue<D>,
114 D: StorageData,
115 E: From<DbError>,
116{
117 fn capacity(&self) -> u64 {
118 self.capacity
119 }
120
121 fn len(&self) -> u64 {
122 self.len
123 }
124
125 fn reallocate(&mut self, storage: &mut Storage<D>, capacity: u64) -> Result<(), E> {
126 storage.resize_value(
127 self.storage_index,
128 self.len().serialized_size() + T::storage_len() * capacity,
129 )?;
130
131 self.capacity = capacity;
132
133 Ok(())
134 }
135
136 fn remove(&mut self, storage: &mut Storage<D>, index: u64) -> Result<T, E> {
137 let offset_from = Self::offset(index + 1);
138 let offset_to = Self::offset(index);
139 let move_len = T::storage_len() * (self.len() - index - 1);
140 let bytes = storage
141 .value_as_bytes_at_size(self.storage_index, Self::offset(index), T::storage_len())?
142 .to_vec();
143
144 let value = T::load(storage, &bytes)?;
145 self.len -= 1;
146
147 let id = storage.transaction();
148 T::remove(storage, &bytes)?;
149 storage.move_at(self.storage_index, offset_from, offset_to, move_len)?;
150 storage.insert_at(self.storage_index, 0, &self.len)?;
151 storage.commit(id)?;
152
153 Ok(value)
154 }
155
156 fn remove_from_storage(self, storage: &mut Storage<D>) -> Result<(), E> {
157 let id = storage.transaction();
158
159 for index in 0..self.len() {
160 let bytes = storage
161 .value_as_bytes_at_size(self.storage_index, Self::offset(index), T::storage_len())?
162 .to_vec();
163 T::remove(storage, &bytes)?;
164 }
165
166 storage.remove(self.storage_index)?;
167 storage.commit(id)?;
168 Ok(())
169 }
170
171 fn replace(&mut self, storage: &mut Storage<D>, index: u64, value: &T) -> Result<T, E> {
172 let old_bytes = storage
173 .value_as_bytes_at_size(self.storage_index, Self::offset(index), T::storage_len())?
174 .to_vec();
175 let old_value = T::load(storage, &old_bytes)?;
176
177 let id = storage.transaction();
178 T::remove(storage, &old_bytes)?;
179 let bytes = value.store(storage)?;
180 storage.insert_bytes_at(self.storage_index, Self::offset(index), &bytes)?;
181 storage.commit(id)?;
182
183 Ok(old_value)
184 }
185
186 fn resize(&mut self, storage: &mut Storage<D>, new_len: u64, value: &T) -> Result<(), E> {
187 let id = storage.transaction();
188
189 for index in self.len()..new_len {
190 let bytes = value.store(storage)?;
191 storage.insert_bytes_at(self.storage_index, Self::offset(index), &bytes)?;
192 }
193
194 for index in new_len..self.len() {
195 let old_bytes = storage
196 .value_as_bytes_at_size(self.storage_index, Self::offset(index), T::storage_len())?
197 .to_vec();
198 T::remove(storage, &old_bytes)?;
199 }
200
201 storage.insert_at(self.storage_index, 0, &new_len)?;
202 storage.commit(id)?;
203
204 self.len = new_len;
205
206 Ok(())
207 }
208
209 fn swap(&mut self, storage: &mut Storage<D>, index: u64, other: u64) -> Result<(), E> {
210 let offset_from = Self::offset(other);
211 let offset_to = Self::offset(index);
212 let size = T::storage_len();
213 let bytes = storage
214 .value_as_bytes_at_size(self.storage_index, Self::offset(index), T::storage_len())?
215 .to_vec();
216
217 let id = storage.transaction();
218 storage.move_at(self.storage_index, offset_from, offset_to, size)?;
219 storage.insert_bytes_at(self.storage_index, Self::offset(other), &bytes)?;
220 storage.commit(id)?;
221
222 Ok(())
223 }
224
225 fn value(&self, storage: &Storage<D>, index: u64) -> Result<T, E> {
226 let bytes = storage.value_as_bytes_at_size(
227 self.storage_index,
228 Self::offset(index),
229 T::storage_len(),
230 )?;
231
232 Ok(T::load(storage, &bytes)?)
233 }
234}
235
236pub struct VecImpl<T, D, Data, E>
237where
238 T: VecValue<D>,
239 D: StorageData,
240 Data: VecData<T, D, E>,
241 E: From<DbError> + From<String>,
242{
243 phantom_data: PhantomData<(T, D, E)>,
244 data: Data,
245}
246
247pub struct VecIterator<'a, T, D, Data, E>
248where
249 T: VecValue<D>,
250 D: StorageData,
251 Data: VecData<T, D, E>,
252 E: From<DbError> + From<String>,
253{
254 pub index: u64,
255 pub vec: &'a VecImpl<T, D, Data, E>,
256 pub storage: &'a Storage<D>,
257}
258
259pub type DbVec<T, D> = VecImpl<T, D, DbVecData<T, D, DbError>, DbError>;
260
261impl<T, D, Data, E> Iterator for VecIterator<'_, T, D, Data, E>
262where
263 T: VecValue<D>,
264 D: StorageData,
265 Data: VecData<T, D, E>,
266 E: From<DbError> + From<String>,
267{
268 type Item = T;
269
270 fn next(&mut self) -> Option<Self::Item> {
271 let value = self.vec.value(self.storage, self.index).ok();
272 self.index += 1;
273
274 value
275 }
276}
277
278impl<T, D, Data, E> VecImpl<T, D, Data, E>
279where
280 T: VecValue<D>,
281 D: StorageData,
282 Data: VecData<T, D, E>,
283 E: From<DbError> + From<String>,
284{
285 pub fn capacity(&self) -> u64 {
286 self.data.capacity()
287 }
288
289 pub fn len(&self) -> u64 {
290 self.data.len()
291 }
292
293 #[allow(dead_code)]
294 pub fn is_empty(&self) -> bool {
295 self.len() == 0
296 }
297
298 pub fn iter<'a>(&'a self, storage: &'a Storage<D>) -> VecIterator<'a, T, D, Data, E> {
299 VecIterator {
300 index: 0,
301 vec: self,
302 storage,
303 }
304 }
305
306 pub fn push(&mut self, storage: &mut Storage<D>, value: &T) -> Result<(), E> {
307 if self.data.len() == self.data.capacity() {
308 self.data.reallocate(
309 storage,
310 match self.capacity() {
311 0 => 1,
312 1 => 2,
313 _ => self.capacity() + self.capacity() / 2,
314 },
315 )?;
316 }
317
318 self.data.resize(storage, self.data.len() + 1, value)
319 }
320
321 pub fn remove_from_storage(self, storage: &mut Storage<D>) -> Result<(), E> {
322 self.data.remove_from_storage(storage)
323 }
324
325 pub fn remove(&mut self, storage: &mut Storage<D>, index: u64) -> Result<T, E> {
326 self.validate_index(index)?;
327 self.data.remove(storage, index)
328 }
329
330 pub fn replace(&mut self, storage: &mut Storage<D>, index: u64, value: &T) -> Result<T, E> {
331 self.validate_index(index)?;
332 self.data.replace(storage, index, value)
333 }
334
335 pub fn reserve(&mut self, storage: &mut Storage<D>, capacity: u64) -> Result<(), E> {
336 if self.capacity() < capacity {
337 self.data.reallocate(storage, capacity)?;
338 }
339
340 Ok(())
341 }
342
343 pub fn resize(&mut self, storage: &mut Storage<D>, new_len: u64, value: &T) -> Result<(), E> {
344 self.reserve(storage, new_len)?;
345 self.data.resize(storage, new_len, value)
346 }
347
348 pub fn shrink_to_fit(&mut self, storage: &mut Storage<D>) -> Result<(), E> {
349 self.data.reallocate(storage, self.len())
350 }
351
352 pub fn swap(&mut self, storage: &mut Storage<D>, index: u64, other: u64) -> Result<(), E> {
353 if index == other {
354 return Ok(());
355 }
356
357 self.validate_index(index)?;
358 self.validate_index(other)?;
359 self.data.swap(storage, index, other)
360 }
361
362 pub fn value(&self, storage: &Storage<D>, index: u64) -> Result<T, E> {
363 self.validate_index(index)?;
364 self.data.value(storage, index)
365 }
366
367 fn validate_index(&self, index: u64) -> Result<(), E> {
368 if self.len() <= index {
369 return Err(E::from(format!(
370 "Index ({index}) out of bounds ({})",
371 self.len()
372 )));
373 }
374
375 Ok(())
376 }
377}
378
379impl<T, D> DbVec<T, D>
380where
381 T: VecValue<D>,
382 D: StorageData,
383{
384 pub fn new(storage: &mut Storage<D>) -> Result<Self, DbError> {
385 let storage_index = storage.insert(&0_u64)?;
386
387 Ok(Self {
388 phantom_data: PhantomData,
389 data: DbVecData {
390 capacity: 0,
391 len: 0,
392 storage_index,
393 phantom_data: PhantomData,
394 },
395 })
396 }
397
398 pub fn from_storage(
399 storage: &Storage<D>,
400 storage_index: StorageIndex,
401 ) -> Result<Self, DbError> {
402 let len = storage.value::<u64>(storage_index)?;
403 let data_len = storage.value_size(storage_index)?;
404 let capacity = data_len / T::storage_len();
405
406 Ok(DbVec {
407 phantom_data: PhantomData,
408 data: DbVecData {
409 capacity,
410 len,
411 storage_index,
412 phantom_data: PhantomData,
413 },
414 })
415 }
416
417 pub fn storage_index(&self) -> StorageIndex {
418 self.data.storage_index
419 }
420}
421
422#[cfg(test)]
423mod tests {
424 use super::*;
425 use crate::{
426 MemoryStorage, storage::file_storage_memory_mapped::FileStorageMemoryMapped,
427 test_utilities::test_file::TestFile,
428 };
429
430 #[test]
431 fn from_storage_index() {
432 let test_file = TestFile::new();
433 let mut storage = Storage::new(test_file.file_name()).unwrap();
434
435 let index;
436
437 {
438 let mut vec = DbVec::<String, FileStorageMemoryMapped>::new(&mut storage).unwrap();
439 vec.push(&mut storage, &"Hello".to_string()).unwrap();
440 vec.push(&mut storage, &", ".to_string()).unwrap();
441 vec.push(&mut storage, &"World".to_string()).unwrap();
442 vec.push(&mut storage, &"!".to_string()).unwrap();
443 index = vec.storage_index();
444 }
445
446 let vec = DbVec::<String, FileStorageMemoryMapped>::from_storage(&storage, index).unwrap();
447
448 assert_eq!(
449 vec.iter(&storage).collect::<Vec<String>>(),
450 vec![
451 "Hello".to_string(),
452 ", ".to_string(),
453 "World".to_string(),
454 "!".to_string()
455 ]
456 );
457 }
458
459 #[test]
460 fn from_storage_missing_index() {
461 let test_file = TestFile::new();
462 let storage = Storage::new(test_file.file_name()).unwrap();
463
464 assert_eq!(
465 DbVec::<String, FileStorageMemoryMapped>::from_storage(
466 &storage,
467 StorageIndex::from(1_u64)
468 )
469 .err()
470 .unwrap(),
471 DbError::from("Storage error: index (1) not found")
472 );
473 }
474
475 #[test]
476 fn iter() {
477 let test_file = TestFile::new();
478 let mut storage = Storage::new(test_file.file_name()).unwrap();
479
480 let mut vec = DbVec::<String, FileStorageMemoryMapped>::new(&mut storage).unwrap();
481 vec.push(&mut storage, &"Hello".to_string()).unwrap();
482 vec.push(&mut storage, &", ".to_string()).unwrap();
483 vec.push(&mut storage, &"World".to_string()).unwrap();
484 vec.push(&mut storage, &"!".to_string()).unwrap();
485
486 assert_eq!(
487 vec.iter(&storage).collect::<Vec<String>>(),
488 vec!["Hello", ", ", "World", "!"]
489 );
490 }
491
492 #[test]
493 fn is_empty() {
494 let test_file = TestFile::new();
495 let mut storage = Storage::new(test_file.file_name()).unwrap();
496
497 let mut vec = DbVec::<String, FileStorageMemoryMapped>::new(&mut storage).unwrap();
498
499 assert!(vec.is_empty());
500
501 vec.push(&mut storage, &"Hello, World!".to_string())
502 .unwrap();
503
504 assert!(!vec.is_empty());
505 }
506
507 #[test]
508 fn len() {
509 let test_file = TestFile::new();
510 let mut storage = Storage::new(test_file.file_name()).unwrap();
511
512 let mut vec = DbVec::<String, FileStorageMemoryMapped>::new(&mut storage).unwrap();
513
514 assert_eq!(vec.len(), 0);
515
516 vec.push(&mut storage, &"Hello".to_string()).unwrap();
517 vec.push(&mut storage, &", ".to_string()).unwrap();
518 vec.push(&mut storage, &"World".to_string()).unwrap();
519 vec.push(&mut storage, &"!".to_string()).unwrap();
520
521 assert_eq!(vec.len(), 4)
522 }
523
524 #[test]
525 fn min_capacity() {
526 let test_file = TestFile::new();
527 let mut storage = Storage::new(test_file.file_name()).unwrap();
528
529 let mut vec = DbVec::<String, FileStorageMemoryMapped>::new(&mut storage).unwrap();
530
531 assert_eq!(vec.capacity(), 0);
532
533 vec.push(&mut storage, &"Hello".to_string()).unwrap();
534 vec.push(&mut storage, &", ".to_string()).unwrap();
535 vec.push(&mut storage, &"World".to_string()).unwrap();
536 vec.push(&mut storage, &"!".to_string()).unwrap();
537
538 assert_eq!(vec.capacity(), 4);
539 }
540
541 #[test]
542 fn push() {
543 let test_file = TestFile::new();
544 let mut storage = Storage::new(test_file.file_name()).unwrap();
545
546 let mut vec = DbVec::<String, FileStorageMemoryMapped>::new(&mut storage).unwrap();
547 vec.push(&mut storage, &"Hello".to_string()).unwrap();
548 vec.push(&mut storage, &", ".to_string()).unwrap();
549 vec.push(&mut storage, &"World".to_string()).unwrap();
550 vec.push(&mut storage, &"!".to_string()).unwrap();
551
552 let indexes = storage
553 .value::<Vec<StorageIndex>>(vec.storage_index())
554 .unwrap();
555
556 let mut values = Vec::<String>::new();
557
558 for index in indexes {
559 values.push(storage.value::<String>(index).unwrap());
560 }
561
562 assert_eq!(
563 values,
564 vec![
565 "Hello".to_string(),
566 ", ".to_string(),
567 "World".to_string(),
568 "!".to_string()
569 ]
570 );
571 }
572
573 #[test]
574 fn remove() {
575 let test_file = TestFile::new();
576 let mut storage = Storage::new(test_file.file_name()).unwrap();
577
578 let mut vec = DbVec::<String, FileStorageMemoryMapped>::new(&mut storage).unwrap();
579 vec.push(&mut storage, &"Hello".to_string()).unwrap();
580 vec.push(&mut storage, &", ".to_string()).unwrap();
581 vec.push(&mut storage, &"World".to_string()).unwrap();
582 vec.push(&mut storage, &"!".to_string()).unwrap();
583
584 vec.remove(&mut storage, 1).unwrap();
585
586 assert_eq!(
587 vec.iter(&storage).collect::<Vec<String>>(),
588 vec!["Hello".to_string(), "World".to_string(), "!".to_string()]
589 );
590 }
591
592 #[test]
593 fn remove_at_end() {
594 let test_file = TestFile::new();
595 let mut storage = Storage::new(test_file.file_name()).unwrap();
596
597 let mut vec = DbVec::<String, FileStorageMemoryMapped>::new(&mut storage).unwrap();
598 vec.push(&mut storage, &"Hello".to_string()).unwrap();
599 vec.push(&mut storage, &", ".to_string()).unwrap();
600 vec.push(&mut storage, &"World".to_string()).unwrap();
601 vec.push(&mut storage, &"!".to_string()).unwrap();
602
603 vec.remove(&mut storage, 3).unwrap();
604
605 assert_eq!(
606 vec.iter(&storage).collect::<Vec<String>>(),
607 vec!["Hello".to_string(), ", ".to_string(), "World".to_string(),]
608 );
609 }
610
611 #[test]
612 fn remove_index_out_of_bounds() {
613 let test_file = TestFile::new();
614 let mut storage = Storage::new(test_file.file_name()).unwrap();
615
616 let mut vec = DbVec::<String, FileStorageMemoryMapped>::new(&mut storage).unwrap();
617
618 assert_eq!(
619 vec.remove(&mut storage, 0),
620 Err(DbError::from("Index (0) out of bounds (0)"))
621 );
622 }
623
624 #[test]
625 fn reserve_larger() {
626 let test_file = TestFile::new();
627 let mut storage = Storage::new(test_file.file_name()).unwrap();
628
629 let mut vec = DbVec::<String, FileStorageMemoryMapped>::new(&mut storage).unwrap();
630 assert_eq!(vec.capacity(), 0);
631
632 vec.reserve(&mut storage, 20).unwrap();
633
634 assert_eq!(vec.capacity(), 20);
635 }
636
637 #[test]
638 fn reserve_smaller() {
639 let test_file = TestFile::new();
640 let mut storage = Storage::new(test_file.file_name()).unwrap();
641
642 let mut vec = DbVec::<String, FileStorageMemoryMapped>::new(&mut storage).unwrap();
643 vec.reserve(&mut storage, 20).unwrap();
644 vec.reserve(&mut storage, 10).unwrap();
645
646 assert_eq!(vec.capacity(), 20);
647 }
648
649 #[test]
650 fn resize_larger() {
651 let test_file = TestFile::new();
652 let mut storage = Storage::new(test_file.file_name()).unwrap();
653
654 let mut vec = DbVec::<String, FileStorageMemoryMapped>::new(&mut storage).unwrap();
655 vec.push(&mut storage, &"Hello".to_string()).unwrap();
656 vec.push(&mut storage, &", ".to_string()).unwrap();
657 vec.push(&mut storage, &"World".to_string()).unwrap();
658 vec.push(&mut storage, &"!".to_string()).unwrap();
659
660 vec.resize(&mut storage, 6, &" ".to_string()).unwrap();
661
662 assert_eq!(
663 vec.iter(&storage).collect::<Vec<String>>(),
664 vec![
665 "Hello".to_string(),
666 ", ".to_string(),
667 "World".to_string(),
668 "!".to_string(),
669 " ".to_string(),
670 " ".to_string(),
671 ]
672 );
673 }
674
675 #[test]
676 fn resize_over_capacity() {
677 let test_file = TestFile::new();
678 let mut storage = Storage::new(test_file.file_name()).unwrap();
679
680 let mut vec = DbVec::<String, FileStorageMemoryMapped>::new(&mut storage).unwrap();
681 vec.push(&mut storage, &"Hello".to_string()).unwrap();
682 vec.push(&mut storage, &", ".to_string()).unwrap();
683 vec.push(&mut storage, &"World".to_string()).unwrap();
684 vec.push(&mut storage, &"!".to_string()).unwrap();
685
686 vec.resize(&mut storage, 100, &" ".to_string()).unwrap();
687
688 let mut expected = Vec::<String>::new();
689 expected.resize(100, " ".to_string());
690 expected[0] = "Hello".to_string();
691 expected[1] = ", ".to_string();
692 expected[2] = "World".to_string();
693 expected[3] = "!".to_string();
694
695 assert_eq!(vec.len(), 100);
696 assert_eq!(vec.capacity(), 100);
697
698 assert_eq!(vec.iter(&storage).collect::<Vec<String>>(), expected);
699 }
700
701 #[test]
702 fn resize_same() {
703 let test_file = TestFile::new();
704 let mut storage = Storage::new(test_file.file_name()).unwrap();
705
706 let mut vec = DbVec::<String, FileStorageMemoryMapped>::new(&mut storage).unwrap();
707 vec.push(&mut storage, &"Hello".to_string()).unwrap();
708 vec.push(&mut storage, &", ".to_string()).unwrap();
709 vec.push(&mut storage, &"World".to_string()).unwrap();
710 vec.push(&mut storage, &"!".to_string()).unwrap();
711
712 vec.resize(&mut storage, 4, &String::default()).unwrap();
713
714 assert_eq!(
715 vec.iter(&storage).collect::<Vec<String>>(),
716 vec![
717 "Hello".to_string(),
718 ", ".to_string(),
719 "World".to_string(),
720 "!".to_string()
721 ]
722 );
723 }
724
725 #[test]
726 fn resize_smaller() {
727 let test_file = TestFile::new();
728 let mut storage = Storage::new(test_file.file_name()).unwrap();
729
730 let mut vec = DbVec::<String, FileStorageMemoryMapped>::new(&mut storage).unwrap();
731 vec.push(&mut storage, &"Hello".to_string()).unwrap();
732 vec.push(&mut storage, &", ".to_string()).unwrap();
733 vec.push(&mut storage, &"World".to_string()).unwrap();
734 vec.push(&mut storage, &"!".to_string()).unwrap();
735
736 vec.resize(&mut storage, 3, &String::default()).unwrap();
737
738 assert_eq!(
739 vec.iter(&storage).collect::<Vec<String>>(),
740 vec!["Hello".to_string(), ", ".to_string(), "World".to_string()]
741 );
742 }
743
744 #[test]
745 fn replace() {
746 let test_file = TestFile::new();
747 let mut storage = Storage::new(test_file.file_name()).unwrap();
748
749 let mut vec = DbVec::<String, FileStorageMemoryMapped>::new(&mut storage).unwrap();
750 vec.push(&mut storage, &"Hello".to_string()).unwrap();
751 vec.push(&mut storage, &", ".to_string()).unwrap();
752 vec.push(&mut storage, &"World".to_string()).unwrap();
753 vec.push(&mut storage, &"!".to_string()).unwrap();
754
755 vec.replace(&mut storage, 1, &" ".to_string()).unwrap();
756
757 assert_eq!(vec.value(&storage, 0), Ok("Hello".to_string()));
758 assert_eq!(vec.value(&storage, 1), Ok(" ".to_string()));
759 assert_eq!(vec.value(&storage, 2), Ok("World".to_string()));
760 assert_eq!(vec.value(&storage, 3), Ok("!".to_string()));
761 }
762
763 #[test]
764 fn replace_out_of_bounds() {
765 let test_file = TestFile::new();
766 let mut storage = Storage::new(test_file.file_name()).unwrap();
767
768 let mut vec = DbVec::<String, FileStorageMemoryMapped>::new(&mut storage).unwrap();
769
770 assert_eq!(
771 vec.replace(&mut storage, 0, &"".to_string()),
772 Err(DbError::from("Index (0) out of bounds (0)"))
773 );
774 }
775
776 #[test]
777 fn shrink_to_fit() {
778 let test_file = TestFile::new();
779 let mut storage = Storage::new(test_file.file_name()).unwrap();
780
781 let mut vec = DbVec::<String, FileStorageMemoryMapped>::new(&mut storage).unwrap();
782 vec.push(&mut storage, &"Hello".to_string()).unwrap();
783 vec.push(&mut storage, &", ".to_string()).unwrap();
784 vec.push(&mut storage, &"World".to_string()).unwrap();
785 vec.push(&mut storage, &"!".to_string()).unwrap();
786 vec.push(&mut storage, &"".to_string()).unwrap();
787
788 assert_eq!(vec.capacity(), 6);
789
790 vec.shrink_to_fit(&mut storage).unwrap();
791
792 assert_eq!(vec.capacity(), 5);
793
794 vec.shrink_to_fit(&mut storage).unwrap();
795
796 assert_eq!(vec.capacity(), 5);
797 }
798
799 #[test]
800 fn shrink_to_fit_empty() {
801 let test_file = TestFile::new();
802 let mut storage = Storage::new(test_file.file_name()).unwrap();
803
804 let mut vec = DbVec::<String, FileStorageMemoryMapped>::new(&mut storage).unwrap();
805
806 assert_eq!(vec.capacity(), 0);
807
808 vec.shrink_to_fit(&mut storage).unwrap();
809
810 assert_eq!(vec.capacity(), 0);
811 }
812
813 #[test]
814 fn swap() {
815 let test_file = TestFile::new();
816 let mut storage = Storage::new(test_file.file_name()).unwrap();
817 let mut vec = DbVec::<String, FileStorageMemoryMapped>::new(&mut storage).unwrap();
818 vec.push(&mut storage, &"Hello".to_string()).unwrap();
819 vec.push(&mut storage, &", ".to_string()).unwrap();
820 vec.push(&mut storage, &"World".to_string()).unwrap();
821 vec.push(&mut storage, &"!".to_string()).unwrap();
822 vec.swap(&mut storage, 0, 2).unwrap();
823 assert_eq!(
824 vec.iter(&storage).collect::<Vec<String>>(),
825 vec![
826 "World".to_string(),
827 ", ".to_string(),
828 "Hello".to_string(),
829 "!".to_string()
830 ]
831 );
832 }
833 #[test]
834 fn swap_self() {
835 let test_file = TestFile::new();
836 let mut storage = Storage::new(test_file.file_name()).unwrap();
837 let mut vec = DbVec::<String, FileStorageMemoryMapped>::new(&mut storage).unwrap();
838 vec.push(&mut storage, &"Hello".to_string()).unwrap();
839 vec.push(&mut storage, &", ".to_string()).unwrap();
840 vec.push(&mut storage, &"World".to_string()).unwrap();
841 vec.push(&mut storage, &"!".to_string()).unwrap();
842 vec.swap(&mut storage, 1, 1).unwrap();
843 assert_eq!(
844 vec.iter(&storage).collect::<Vec<String>>(),
845 vec![
846 "Hello".to_string(),
847 ", ".to_string(),
848 "World".to_string(),
849 "!".to_string()
850 ]
851 );
852 }
853 #[test]
854 fn swap_invalid() {
855 let test_file = TestFile::new();
856 let mut storage = Storage::new(test_file.file_name()).unwrap();
857 let mut vec = DbVec::<String, FileStorageMemoryMapped>::new(&mut storage).unwrap();
858 vec.push(&mut storage, &"Hello".to_string()).unwrap();
859 vec.push(&mut storage, &", ".to_string()).unwrap();
860 vec.push(&mut storage, &"World".to_string()).unwrap();
861 vec.push(&mut storage, &"!".to_string()).unwrap();
862 assert_eq!(
863 vec.swap(&mut storage, 1, 10),
864 Err(DbError::from("Index (10) out of bounds (4)"))
865 );
866 assert_eq!(
867 vec.swap(&mut storage, 10, 1),
868 Err(DbError::from("Index (10) out of bounds (4)"))
869 );
870 }
871
872 #[test]
873 fn value() {
874 let test_file = TestFile::new();
875 let mut storage = Storage::new(test_file.file_name()).unwrap();
876
877 let mut vec = DbVec::<String, FileStorageMemoryMapped>::new(&mut storage).unwrap();
878 vec.push(&mut storage, &"Hello".to_string()).unwrap();
879 vec.push(&mut storage, &", ".to_string()).unwrap();
880 vec.push(&mut storage, &"World".to_string()).unwrap();
881 vec.push(&mut storage, &"!".to_string()).unwrap();
882
883 assert_eq!(vec.value(&storage, 0), Ok("Hello".to_string()));
884 assert_eq!(vec.value(&storage, 1), Ok(", ".to_string()));
885 assert_eq!(vec.value(&storage, 2), Ok("World".to_string()));
886 assert_eq!(vec.value(&storage, 3), Ok("!".to_string()));
887 }
888
889 #[test]
890 fn value_out_of_bounds() {
891 let test_file = TestFile::new();
892 let mut storage = Storage::new(test_file.file_name()).unwrap();
893
894 let vec = DbVec::<String, FileStorageMemoryMapped>::new(&mut storage).unwrap();
895
896 assert_eq!(
897 vec.value(&storage, 0),
898 Err(DbError::from("Index (0) out of bounds (0)"))
899 );
900 }
901
902 #[test]
903 fn remove_from_storage() {
904 let mut storage: Storage<MemoryStorage> = Storage::new("test").unwrap();
905 let mut vec = DbVec::<String, MemoryStorage>::new(&mut storage).unwrap();
906 vec.push(
907 &mut storage,
908 &"This is a long string that does not fit into small value".to_string(),
909 )
910 .unwrap();
911
912 vec.remove_from_storage(&mut storage).unwrap();
913 let len = storage.len();
914 storage.optimize_storage().unwrap();
915
916 assert!(storage.len() < len)
917 }
918
919 #[test]
920 fn remove_at_end_trivial_after_optimize() {
921 let mut storage: Storage<MemoryStorage> = Storage::new("test").unwrap();
922 let mut vec = DbVec::<u64, MemoryStorage>::new(&mut storage).unwrap();
923 vec.push(&mut storage, &1).unwrap();
924 vec.push(&mut storage, &2).unwrap();
925 vec.push(&mut storage, &3).unwrap();
926 vec.shrink_to_fit(&mut storage).unwrap();
927 vec.remove(&mut storage, 2).unwrap();
928
929 assert_eq!(vec.len(), 2);
930 }
931}