use std::collections::BTreeMap;
use parking_lot::Mutex;
#[derive(Debug, Default)]
pub(crate) struct AccessLog {
branches: Mutex<BTreeMap<String, Mutex<BTreeMap<String, u64>>>>,
}
impl AccessLog {
pub(crate) fn new() -> Self {
Self::default()
}
pub(crate) fn record(&self, branch: &str, seq: u64, keys: impl Iterator<Item = String>) {
let mut keys = keys.peekable();
if keys.peek().is_none() {
return;
}
let branches = self.branches.lock();
match branches.get(branch) {
Some(entry) => {
let mut map = entry.lock();
for key in keys {
map.insert(key, seq);
}
}
None => {
drop(branches);
let mut branches = self.branches.lock();
let entry = branches.entry(branch.to_owned()).or_default();
let mut map = entry.lock();
for key in keys {
map.insert(key, seq);
}
}
}
}
pub(crate) fn snapshot(&self, branch: &str) -> BTreeMap<String, u64> {
self.branches
.lock()
.get(branch)
.map(|m| m.lock().clone())
.unwrap_or_default()
}
pub(crate) fn fork(&self, from: &str, to: &str) {
let copied = self.snapshot(from);
if copied.is_empty() {
return;
}
self.branches
.lock()
.insert(to.to_owned(), Mutex::new(copied));
}
pub(crate) fn forget(&self, branch: &str) {
self.branches.lock().remove(branch);
}
pub(crate) fn retain(&self, branch: &str, keep: impl Fn(&str) -> bool) {
if let Some(entry) = self.branches.lock().get(branch) {
entry.lock().retain(|k, _| keep(k));
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn readings_are_recorded_per_branch() {
let log = AccessLog::new();
log.record("main", 5, ["a".to_owned()].into_iter());
log.record("side", 9, ["a".to_owned()].into_iter());
assert_eq!(log.snapshot("main").get("a"), Some(&5));
assert_eq!(log.snapshot("side").get("a"), Some(&9));
assert!(log.snapshot("nowhere").is_empty());
}
#[test]
fn a_later_reading_replaces_an_earlier_one() {
let log = AccessLog::new();
log.record("main", 1, ["a".to_owned()].into_iter());
log.record("main", 7, ["a".to_owned()].into_iter());
assert_eq!(log.snapshot("main").get("a"), Some(&7));
}
#[test]
fn a_fork_inherits_a_snapshot_and_then_diverges() {
let log = AccessLog::new();
log.record("main", 5, ["a".to_owned()].into_iter());
log.fork("main", "side");
assert_eq!(log.snapshot("side").get("a"), Some(&5));
log.record("side", 10, ["a".to_owned()].into_iter());
assert_eq!(log.snapshot("side").get("a"), Some(&10));
assert_eq!(
log.snapshot("main").get("a"),
Some(&5),
"the fork's reading leaked back to its parent"
);
}
#[test]
fn a_discarded_branch_takes_its_readings_with_it() {
let log = AccessLog::new();
log.record("side", 5, ["a".to_owned()].into_iter());
log.forget("side");
assert!(log.snapshot("side").is_empty());
}
#[test]
fn readings_for_vanished_keys_are_dropped() {
let log = AccessLog::new();
log.record("main", 1, ["a".to_owned(), "b".to_owned()].into_iter());
log.retain("main", |k| k == "a");
let snap = log.snapshot("main");
assert!(snap.contains_key("a"));
assert!(!snap.contains_key("b"));
}
#[test]
fn recording_nothing_costs_nothing() {
let log = AccessLog::new();
log.record("main", 1, std::iter::empty());
assert!(log.snapshot("main").is_empty());
}
}