mmap_vecdeque/
lib.rs

1//! # mmap-vecdeque
2//!
3//! `mmap-vecdeque` is a file-backed, memory-mapped, durable, and thread-safe double-ended queue (deque) for Rust. Unlike a normal `VecDeque`, operations aren't immediately durable. Instead, you can batch multiple insertions, deletions, etc. and then call `commit()` to atomically persist all changes to disk.
4//!
5//! ## Key Features
6//!
7//! - **Deferred commits:** Changes are kept in memory until `commit()` is called.
8//! - **Atomic and durable commits:** Once `commit()` returns, all changes are atomically and durably persisted to disk.
9//! - **Configurable chunk size:** Items are stored in fixed-size chunks of elements. By default, 10,000 elements per chunk.
10//! - **Mmap-backed:** Data is accessed via memory mapping for potentially high performance.
11//! - **Iterators:** `iter()` and `iter_mut()` to traverse elements.
12//!
13//! ## Usage
14//!
15//! ```rust
16//! use mmap_vecdeque::MmapVecDeque;
17//! use std::path::Path;
18//!
19//! fn main() -> Result<(), mmap_vecdeque::MmapVecDequeError> {
20//!   let dir = Path::new("my_deque_storage");
21//!   let mut deque = MmapVecDeque::<u64>::open_or_create(dir, None)?;
22//!
23//!   deque.push_back(42)?;
24//!   deque.push_front(1)?;
25//!
26//!   // Changes are not yet durable on disk
27//!   deque.commit()?; // Now 1 and 42 are atomically committed.
28//!
29//!   println!("Front: {:?}", deque.front()); // Some(1)
30//!   println!("Back: {:?}", deque.back());   // Some(42)
31//!
32//!   deque.pop_front()?;
33//!   // Not durable yet.
34//!   deque.commit()?; // commit again
35//!
36//!   println!("Front after pop: {:?}", deque.front()); // Some(42)
37//!
38//!   // Iteration
39//!   for val in deque.iter() {
40//!     println!("{}", val);
41//!   }
42//!
43//!   Ok(())
44//! }
45//! ```
46
47mod error;
48mod mmap_vecdeque;
49pub use mmap_vecdeque::{MmapVecDeque, Iter, IterMut};
50pub use error::MmapVecDequeError;