use crate::database::block_offset_index::BlockOffsetIndex;
use crate::entities::*;
use crate::format_runs::{FootnoteRefAnchor, FormatRun, ImageAnchor};
use crate::snapshot::{StoreSnapshot, StoreSnapshotTrait};
use crate::types::EntityId;
use im::HashMap;
use parking_lot::{Mutex, RwLock};
use ropey::Rope;
use std::collections::HashMap as StdHashMap;
use std::collections::HashSet as StdHashSet;
use std::thread::ThreadId;
#[derive(Debug, Default)]
pub struct RopeStore {
pub rope: RwLock<Rope>,
pub roots: RwLock<HashMap<EntityId, Root>>,
pub documents: RwLock<HashMap<EntityId, Document>>,
pub frames: RwLock<HashMap<EntityId, Frame>>,
pub blocks: RwLock<HashMap<EntityId, Block>>,
pub lists: RwLock<HashMap<EntityId, List>>,
pub resources: RwLock<HashMap<EntityId, Resource>>,
pub tables: RwLock<HashMap<EntityId, Table>>,
pub table_cells: RwLock<HashMap<EntityId, TableCell>>,
pub format_runs: RwLock<HashMap<EntityId, Vec<FormatRun>>>,
pub block_images: RwLock<HashMap<EntityId, Vec<ImageAnchor>>>,
pub block_footnote_refs: RwLock<HashMap<EntityId, Vec<FootnoteRefAnchor>>>,
pub footnote_markers: RwLock<StdHashMap<String, String>>,
pub block_offsets: RwLock<BlockOffsetIndex>,
pub counters: RwLock<StdHashMap<String, EntityId>>,
savepoints: RwLock<StdHashMap<u64, RopeStoreSnapshot>>,
next_savepoint_id: RwLock<u64>,
transient: Mutex<TransientEdits>,
}
#[derive(Debug, Default)]
struct TransientEdits {
base: Option<RopeStoreSnapshot>,
writer: Option<ThreadId>,
open_writes: StdHashSet<u64>,
beginning: StdHashSet<ThreadId>,
}
impl TransientEdits {
fn writes_open(&self, besides: Option<ThreadId>) -> bool {
!self.open_writes.is_empty() || self.beginning.iter().any(|thread| Some(*thread) != besides)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, thiserror::Error)]
#[non_exhaustive]
pub enum TransientWriteRefused {
#[error("a transient write is in progress: transient writes do not nest")]
TransientWriteInProgress,
#[error("a write is open on the store: a transient write begins once it ends")]
WriteInProgress,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, thiserror::Error)]
#[error(
"transient edits are outstanding: revert them before writing the document's recorded content"
)]
pub struct TransientEditsOutstanding;
impl RopeStore {
pub fn new() -> Self {
Self::default()
}
pub fn snapshot(&self) -> RopeStoreSnapshot {
RopeStoreSnapshot {
rope: self.rope.read().clone(),
roots: self.roots.read().clone(),
documents: self.documents.read().clone(),
frames: self.frames.read().clone(),
blocks: self.blocks.read().clone(),
lists: self.lists.read().clone(),
resources: self.resources.read().clone(),
tables: self.tables.read().clone(),
table_cells: self.table_cells.read().clone(),
format_runs: self.format_runs.read().clone(),
block_images: self.block_images.read().clone(),
block_footnote_refs: self.block_footnote_refs.read().clone(),
footnote_markers: self.footnote_markers.read().clone(),
block_offsets: self.block_offsets.read().clone(),
counters: self.counters.read().clone(),
}
}
pub fn restore(&self, snap: &RopeStoreSnapshot) {
*self.rope.write() = snap.rope.clone();
*self.roots.write() = snap.roots.clone();
*self.documents.write() = snap.documents.clone();
*self.frames.write() = snap.frames.clone();
*self.blocks.write() = snap.blocks.clone();
*self.lists.write() = snap.lists.clone();
*self.resources.write() = snap.resources.clone();
*self.tables.write() = snap.tables.clone();
*self.table_cells.write() = snap.table_cells.clone();
*self.format_runs.write() = snap.format_runs.clone();
*self.block_images.write() = snap.block_images.clone();
*self.block_footnote_refs.write() = snap.block_footnote_refs.clone();
*self.footnote_markers.write() = snap.footnote_markers.clone();
*self.block_offsets.write() = snap.block_offsets.clone();
*self.counters.write() = snap.counters.clone();
}
pub fn restore_without_counters(&self, snap: &RopeStoreSnapshot) {
*self.rope.write() = snap.rope.clone();
*self.roots.write() = snap.roots.clone();
*self.documents.write() = snap.documents.clone();
*self.frames.write() = snap.frames.clone();
*self.blocks.write() = snap.blocks.clone();
*self.lists.write() = snap.lists.clone();
*self.resources.write() = snap.resources.clone();
*self.tables.write() = snap.tables.clone();
*self.table_cells.write() = snap.table_cells.clone();
*self.format_runs.write() = snap.format_runs.clone();
*self.block_images.write() = snap.block_images.clone();
*self.block_footnote_refs.write() = snap.block_footnote_refs.clone();
*self.footnote_markers.write() = snap.footnote_markers.clone();
*self.block_offsets.write() = snap.block_offsets.clone();
}
pub fn create_savepoint(&self) -> u64 {
let snap = self.snapshot();
let mut id_counter = self.next_savepoint_id.write();
let id = *id_counter;
*id_counter += 1;
drop(id_counter);
self.savepoints.write().insert(id, snap);
let mut state = self.transient.lock();
if state.beginning.remove(&std::thread::current().id()) {
state.open_writes.insert(id);
}
id
}
pub fn restore_savepoint(&self, savepoint_id: u64) {
let snap = self
.savepoints
.read()
.get(&savepoint_id)
.expect("savepoint not found")
.clone();
self.restore(&snap);
}
pub fn discard_savepoint(&self, savepoint_id: u64) {
self.savepoints.write().remove(&savepoint_id);
self.transient.lock().open_writes.remove(&savepoint_id);
}
pub fn savepoint_count(&self) -> usize {
self.savepoints.read().len()
}
pub(crate) fn next_id(&self, entity_name: &str) -> EntityId {
let mut counters = self.counters.write();
let counter = counters.entry(entity_name.to_string()).or_insert(1);
let id = *counter;
*counter += 1;
id
}
pub fn store_snapshot(&self) -> StoreSnapshot {
StoreSnapshot::new(self.snapshot())
}
pub fn restore_store_snapshot(&self, snap: &StoreSnapshot) {
let s = snap
.downcast_ref::<RopeStoreSnapshot>()
.expect("StoreSnapshot must contain RopeStoreSnapshot");
self.restore_without_counters(s);
}
pub fn begin_transient_write(&self) -> Result<TransientWrite<'_>, TransientWriteRefused> {
let mut state = self.transient.lock();
if state.writer.is_some() {
return Err(TransientWriteRefused::TransientWriteInProgress);
}
let thread = std::thread::current().id();
if state.writes_open(Some(thread)) {
return Err(TransientWriteRefused::WriteInProgress);
}
state.beginning.remove(&thread);
let before = self.snapshot();
let opens = state.base.is_none();
let before = if opens {
state.base = Some(before);
None
} else {
Some(before)
};
state.writer = Some(std::thread::current().id());
Ok(TransientWrite {
store: self,
before,
opens,
kept: false,
})
}
pub fn has_transient_edits(&self) -> bool {
self.transient.lock().base.is_some()
}
pub fn recorded_snapshot(&self) -> Option<RopeStoreSnapshot> {
let mut recorded = self.transient.lock().base.clone()?;
recorded.footnote_markers = self.footnote_markers.read().clone();
Some(recorded)
}
pub fn revert_transient_edits(&self) -> Result<bool, TransientWriteRefused> {
let mut state = self.transient.lock();
if state.writer.is_some() {
return Err(TransientWriteRefused::TransientWriteInProgress);
}
if state.writes_open(None) {
return Err(TransientWriteRefused::WriteInProgress);
}
let Some(base) = state.base.as_ref() else {
return Ok(false);
};
self.restore_content(base);
state.base = None;
Ok(true)
}
pub fn check_write_allowed(&self) -> anyhow::Result<()> {
let mut state = self.transient.lock();
let thread = std::thread::current().id();
if state.base.is_some() && state.writer != Some(thread) {
return Err(TransientEditsOutstanding.into());
}
state.beginning.insert(thread);
Ok(())
}
pub fn is_write_allowed(&self) -> bool {
let state = self.transient.lock();
state.base.is_none() || state.writer == Some(std::thread::current().id())
}
fn restore_content(&self, snap: &RopeStoreSnapshot) {
let markers = self.footnote_markers.read().clone();
self.restore_without_counters(snap);
*self.footnote_markers.write() = markers;
}
}
#[derive(Debug)]
pub struct TransientWrite<'a> {
store: &'a RopeStore,
before: Option<RopeStoreSnapshot>,
opens: bool,
kept: bool,
}
impl TransientWrite<'_> {
pub fn opens(&self) -> bool {
self.opens
}
pub fn keep(mut self) {
self.kept = true;
}
}
impl Drop for TransientWrite<'_> {
fn drop(&mut self) {
let mut state = self.store.transient.lock();
state.writer = None;
if self.kept {
return;
}
debug_assert!(
!state.writes_open(None),
"a transient write ended with a write it opened still open"
);
if self.opens {
if let Some(base) = state.base.as_ref() {
self.store.restore_content(base);
}
state.base = None;
} else if let Some(before) = self.before.take() {
self.store.restore_content(&before);
}
}
}
#[derive(Debug, Clone, Default)]
pub struct RopeStoreSnapshot {
pub(crate) rope: Rope,
pub(crate) roots: HashMap<EntityId, Root>,
pub(crate) documents: HashMap<EntityId, Document>,
pub(crate) frames: HashMap<EntityId, Frame>,
pub(crate) blocks: HashMap<EntityId, Block>,
pub(crate) lists: HashMap<EntityId, List>,
pub(crate) resources: HashMap<EntityId, Resource>,
pub(crate) tables: HashMap<EntityId, Table>,
pub(crate) table_cells: HashMap<EntityId, TableCell>,
pub(crate) format_runs: HashMap<EntityId, Vec<FormatRun>>,
pub(crate) block_images: HashMap<EntityId, Vec<ImageAnchor>>,
pub(crate) block_footnote_refs: HashMap<EntityId, Vec<FootnoteRefAnchor>>,
pub(crate) footnote_markers: StdHashMap<String, String>,
pub(crate) block_offsets: BlockOffsetIndex,
pub(crate) counters: StdHashMap<String, EntityId>,
}
impl StoreSnapshotTrait for RopeStoreSnapshot {
fn clone_box(&self) -> Box<dyn StoreSnapshotTrait> {
Box::new(self.clone())
}
fn as_any(&self) -> &dyn std::any::Any {
self
}
}