use serde::{Deserialize, Serialize};
use super::fork::{LogId, Provenance};
use super::seq::Seq;
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Journal<T> {
#[serde(default)]
id: Option<LogId>,
#[serde(default)]
provenance: Option<Provenance>,
entries: Vec<T>,
#[serde(default)]
parents: Vec<Vec<Seq>>,
}
impl<T> Default for Journal<T> {
fn default() -> Self {
Self {
id: None,
provenance: None,
entries: Vec::new(),
parents: Vec::new(),
}
}
}
impl<T> Journal<T> {
pub fn new() -> Self {
Self::default()
}
pub fn starting_from(id: LogId, provenance: Provenance) -> Self {
Self::with_identity(Some(id), Some(provenance))
}
pub(crate) fn with_identity(id: Option<LogId>, provenance: Option<Provenance>) -> Self {
Self {
id,
provenance,
..Self::default()
}
}
pub fn with_id(id: LogId) -> Self {
Self {
id: Some(id),
..Self::default()
}
}
pub(crate) fn parents_of(&self, seq: Seq) -> &[Seq] {
self.parents
.get(seq.index())
.map(Vec::as_slice)
.unwrap_or(&[])
}
pub(crate) fn set_parents(&mut self, seq: Seq, causes: Vec<Seq>) {
if causes.is_empty() {
return;
}
if self.parents.len() <= seq.index() {
self.parents.resize_with(seq.index() + 1, Vec::new);
}
self.parents[seq.index()] = causes;
}
pub fn id(&self) -> Option<&LogId> {
self.id.as_ref()
}
pub fn provenance(&self) -> Option<&Provenance> {
self.provenance.as_ref()
}
pub fn append(&mut self, entry: T) -> Seq {
let seq = Seq(self.entries.len() as u64);
self.entries.push(entry);
seq
}
pub fn get(&self, seq: Seq) -> Option<&T> {
self.entries.get(seq.index())
}
pub fn entries(&self) -> &[T] {
&self.entries
}
pub fn from(&self, seq: Seq) -> &[T] {
let start = seq.index().min(self.entries.len());
&self.entries[start..]
}
pub fn len(&self) -> usize {
self.entries.len()
}
pub fn is_empty(&self) -> bool {
self.entries.is_empty()
}
pub fn next_seq(&self) -> Seq {
Seq(self.entries.len() as u64)
}
pub fn replay<S, F>(&self, init: S, f: F) -> S
where
F: FnMut(S, &T) -> S,
{
self.entries.iter().fold(init, f)
}
pub fn replay_from<S, F>(&self, seq: Seq, init: S, f: F) -> S
where
F: FnMut(S, &T) -> S,
{
self.from(seq).iter().fold(init, f)
}
}
impl<T: Clone> Journal<T> {
pub fn fork(&self, new_id: LogId) -> Self {
Self {
id: Some(new_id),
provenance: Some(Provenance {
source: self.id.clone(),
at: self.next_seq(),
}),
entries: self.entries.clone(),
parents: self.parents.clone(),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn append_stamps_monotonic_sequences() {
let mut log = Journal::new();
assert_eq!(log.append("a"), Seq(0));
assert_eq!(log.append("b"), Seq(1));
assert_eq!(log.append("c"), Seq(2));
assert_eq!(log.len(), 3);
assert_eq!(log.next_seq(), Seq(3));
}
#[test]
fn get_addresses_stable_entries() {
let mut log = Journal::new();
log.append(10);
log.append(20);
assert_eq!(log.get(Seq(0)), Some(&10));
assert_eq!(log.get(Seq(1)), Some(&20));
assert_eq!(log.get(Seq(2)), None);
}
#[test]
fn fork_copies_history_and_records_provenance() {
let mut source = Journal::with_id(LogId::new("source"));
source.append("a");
source.append("b");
let mut fork = source.fork(LogId::new("fork"));
assert_eq!(fork.entries(), source.entries());
let provenance = fork.provenance().expect("a fork has provenance");
assert_eq!(provenance.source, Some(LogId::new("source")));
assert_eq!(provenance.at, Seq(2), "forked at the source's length");
assert_eq!(fork.id(), Some(&LogId::new("fork")));
fork.append("c");
assert_eq!(source.len(), 2, "the source is unchanged");
assert_eq!(fork.len(), 3);
}
#[test]
fn from_returns_only_newer_entries() {
let mut log = Journal::new();
for n in 0..5 {
log.append(n);
}
assert_eq!(log.from(Seq(3)), &[3, 4]);
assert_eq!(log.from(Seq(5)), &[] as &[i32]);
assert_eq!(log.from(Seq(99)), &[] as &[i32]);
}
#[test]
fn replay_folds_entries_into_state() {
let mut log: Journal<i64> = Journal::new();
log.append(5);
log.append(-2);
log.append(10);
let total = log.replay(0i64, |sum, delta| sum + delta);
assert_eq!(total, 13);
}
#[test]
fn replay_from_advances_an_existing_state() {
let mut log: Journal<i64> = Journal::new();
log.append(5);
log.append(-2);
let partial = log.replay(0, |s, d| s + d); let at = log.next_seq();
log.append(10);
log.append(1);
let advanced = log.replay_from(at, partial, |s, d| s + d);
assert_eq!(
advanced, 14,
"only the entries after the cursor were applied"
);
}
}