use std::collections::BTreeMap;
use super::{Document, DocumentObject, ObjectId, SavedObject};
use crate::property::{Property, PropertyContainer};
static NEXT_TRANSACTION_ID: std::sync::atomic::AtomicUsize =
std::sync::atomic::AtomicUsize::new(1);
fn new_transaction_id() -> usize {
NEXT_TRANSACTION_ID.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
}
#[derive(Debug, Clone)]
pub struct PropertyChange {
pub object: ObjectId,
pub name: String,
pub old: Option<Property>,
pub new: Property,
}
#[derive(Debug, Clone)]
pub enum Change {
Property(PropertyChange),
AddObject { id: ObjectId, saved: SavedObject },
RemoveObject { id: ObjectId, saved: SavedObject },
AddExpression {
object: ObjectId,
prop: String,
old: Option<String>,
new: String,
},
RemoveExpression {
object: ObjectId,
prop: String,
old: String,
},
}
#[derive(Debug, Clone)]
pub struct Transaction {
pub id: usize,
pub name: String,
pub changes: Vec<Change>,
}
#[derive(Debug)]
struct Pending {
name: String,
id: usize,
}
#[derive(Debug, Default)]
pub struct TransactionManager {
pending: Option<Pending>,
active: Option<Transaction>,
undo: Vec<Transaction>,
redo: Vec<Transaction>,
}
impl TransactionManager {
pub fn open_named(&mut self, name: &str) {
self.pending = Some(Pending {
name: name.to_string(),
id: new_transaction_id(),
});
}
pub fn begin(&mut self) -> Option<String> {
if let Some(pending) = self.pending.take() {
if let Some(previous) = self.active.take() {
self.undo.push(previous);
}
self.redo.clear();
let name = pending.name.clone();
self.active = Some(Transaction {
id: pending.id,
name: name.clone(),
changes: Vec::new(),
});
return Some(name);
}
None
}
pub fn has_pending(&self) -> bool {
self.pending.is_some()
}
pub fn is_active(&self) -> bool {
self.active.is_some()
}
pub fn has_undo(&self) -> bool {
!self.undo.is_empty()
}
pub fn has_redo(&self) -> bool {
!self.redo.is_empty()
}
pub fn undo_names(&self) -> Vec<String> {
let mut names = Vec::new();
if let Some(active) = &self.active {
names.push(active.name.clone());
}
names.extend(self.undo.iter().rev().map(|t| t.name.clone()));
names
}
pub fn redo_names(&self) -> Vec<String> {
self.redo.iter().rev().map(|t| t.name.clone()).collect()
}
pub fn booked_transaction_id(&self) -> usize {
if let Some(pending) = &self.pending {
return pending.id;
}
self.active.as_ref().map(|t| t.id).unwrap_or(0)
}
pub fn available_undos(&self, id: usize) -> usize {
if id == 0 {
return self.undo.len() + usize::from(self.active.is_some());
}
let mut depth = 0;
if let Some(active) = &self.active {
depth += 1;
if active.id == id {
return depth;
}
}
for t in self.undo.iter().rev() {
depth += 1;
if t.id == id {
return depth;
}
}
0
}
pub fn available_redos(&self, id: usize) -> usize {
if id == 0 {
return self.redo.len();
}
let mut depth = 0;
for t in self.redo.iter().rev() {
depth += 1;
if t.id == id {
return depth;
}
}
0
}
pub fn record(&mut self, change: Change) {
self.begin();
if let Some(active) = &mut self.active {
active.changes.push(change);
}
}
pub fn commit(&mut self) -> bool {
self.pending = None;
match self.active.take() {
Some(active) => {
self.undo.push(active);
true
}
None => false,
}
}
pub fn abort(&mut self) -> Option<Transaction> {
self.pending = None;
self.active.take()
}
pub fn undo(&mut self) -> Option<Transaction> {
self.commit();
let t = self.undo.pop()?;
self.redo.push(t.clone());
Some(t)
}
pub fn redo(&mut self) -> Option<Transaction> {
self.commit();
let t = self.redo.pop()?;
self.undo.push(t.clone());
Some(t)
}
pub fn clear(&mut self) {
self.undo.clear();
self.redo.clear();
}
}
impl Document {
pub fn open_transaction_named(&mut self, name: &str) {
self.tx.open_named(name);
}
pub fn open_transaction(&mut self) {
self.tx.open_named("");
}
pub fn begin_transaction_if_pending(&mut self) -> Option<String> {
self.tx.begin()
}
pub fn commit_transaction(&mut self) -> bool {
self.tx.commit()
}
pub fn has_undo(&self) -> bool {
self.tx.has_undo()
}
pub fn has_redo(&self) -> bool {
self.tx.has_redo()
}
pub fn is_in_transaction(&self) -> bool {
self.tx.has_pending() || self.tx.is_active()
}
pub fn undo_names(&self) -> Vec<String> {
self.tx.undo_names()
}
pub fn redo_names(&self) -> Vec<String> {
self.tx.redo_names()
}
pub fn booked_transaction_id(&self) -> usize {
self.tx.booked_transaction_id()
}
pub fn available_undos(&self, id: usize) -> usize {
self.tx.available_undos(id)
}
pub fn available_redos(&self, id: usize) -> usize {
self.tx.available_redos(id)
}
pub fn clear_undos(&mut self) {
self.tx.clear();
}
pub(super) fn record_change(&mut self, change: Change) {
if self.tx.is_active() || self.tx.has_pending() {
self.tx.record(change);
}
}
pub fn abort_transaction(&mut self) -> bool {
match self.tx.abort() {
Some(tx) => {
for change in tx.changes.iter().rev() {
self.revert(change);
}
true
}
None => false,
}
}
pub fn undo(&mut self) -> bool {
match self.tx.undo() {
Some(tx) => {
for change in tx.changes.iter().rev() {
self.revert(change);
}
true
}
None => false,
}
}
pub fn redo(&mut self) -> bool {
match self.tx.redo() {
Some(tx) => {
for change in tx.changes.iter() {
self.apply(change);
}
true
}
None => false,
}
}
fn apply(&mut self, change: &Change) {
match change {
Change::Property(c) => {
if let Some(obj) = self.objects.get_mut(&c.object) {
obj.properties.set(c.name.clone(), c.new.clone());
}
}
Change::AddObject { id, saved } => self.insert_saved_object(*id, saved),
Change::RemoveObject { id, .. } => {
self.remove_object_raw(*id, true);
}
Change::AddExpression {
object,
prop,
new,
..
} => self.set_expression_raw(*object, prop, new),
Change::RemoveExpression { object, prop, .. } => {
if let Some(obj) = self.objects.get_mut(object) {
obj.expressions.remove(prop);
}
self.enforce_recompute(*object);
}
}
}
fn revert(&mut self, change: &Change) {
match change {
Change::Property(c) => {
if let Some(obj) = self.objects.get_mut(&c.object) {
match &c.old {
Some(old) => obj.properties.set(c.name.clone(), old.clone()),
None => {
obj.properties.remove(&c.name);
}
}
}
}
Change::AddObject { id, .. } => {
self.remove_object_raw(*id, false);
}
Change::RemoveObject { id, saved } => self.insert_saved_object(*id, saved),
Change::AddExpression {
object,
prop,
old,
..
} => match old {
Some(source) => self.set_expression_raw(*object, prop, source),
None => {
if let Some(obj) = self.objects.get_mut(object) {
obj.expressions.remove(prop);
}
self.enforce_recompute(*object);
}
},
Change::RemoveExpression { object, prop, old } => {
self.set_expression_raw(*object, prop, old);
}
}
}
fn set_expression_raw(&mut self, object: ObjectId, prop: &str, source: &str) {
if let Some(obj) = self.objects.get_mut(&object) {
obj.expressions.insert(prop.to_string(), source.to_string());
}
self.enforce_recompute(object);
}
fn insert_saved_object(&mut self, id: ObjectId, saved: &SavedObject) {
let node = self.graph.add_node(id);
self.index.insert(id, node);
let mut properties = PropertyContainer::new();
for (k, v) in &saved.properties {
let status = saved
.property_status
.get(k)
.copied()
.unwrap_or(crate::prop_status::NONE);
properties.set_with_status(k.clone(), v.clone(), status);
}
self.objects.insert(
id,
DocumentObject {
id,
name: saved.name.clone(),
label: saved.label.clone(),
type_id: saved.type_id.clone(),
properties,
expressions: saved.expressions.clone(),
extensions: saved.extensions.iter().cloned().collect(),
must_execute: false,
touched: false,
invalid: false,
property_versions: BTreeMap::new(),
python_state: saved.python_state.clone(),
},
);
if id >= self.next_id {
self.next_id = id + 1;
}
}
}