feat: track uncommitted Model changes

5 files changed, 41 insertions, 13 deletions

diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/Model.java b/subprojects/store/src/main/java/tools/refinery/store/model/Model.java
index 8d2a4614..6ca1ac7b 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/Model.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/Model.java
@@ -9,10 +9,14 @@ import tools.refinery.store.representation.Symbol;
 import java.util.Optional;
 
 public interface Model extends Versioned {
+        long NO_STATE_ID = -1;
+
         ModelStore getStore();
 
         long getState();
 
+        boolean hasUncommittedChanges();
+
         default AnyInterpretation getInterpretation(AnySymbol symbol) {
                 return getInterpretation((Symbol<?>) symbol);
         }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/ModelStore.java b/subprojects/store/src/main/java/tools/refinery/store/model/ModelStore.java
index bc863d4b..2e7e62c3 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/ModelStore.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/ModelStore.java
@@ -12,9 +12,9 @@ import java.util.Set;
 public interface ModelStore {
         Collection<AnySymbol> getSymbols();
 
-        Model createModel();
+        Model createEmptyModel();
 
-        Model createModel(long state);
+        Model createModelForState(long state);
 
         Set<Long> getStates();
 
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelImpl.java b/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelImpl.java
index 10331e28..9eb438c4 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelImpl.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelImpl.java
@@ -18,8 +18,9 @@ public class ModelImpl implements Model {
         private Map<? extends AnySymbol, ? extends VersionedInterpretation<?>> interpretations;
         private final AdapterList<ModelAdapter> adapters;
         private final List<ModelListener> listeners = new ArrayList<>();
+        private boolean uncommittedChanges;
         private ModelAction pendingAction = ModelAction.NONE;
-        private long restoringToState = -1;
+        private long restoringToState = NO_STATE_ID;
 
         ModelImpl(ModelStore store, long state, int adapterCount) {
                 this.store = store;
@@ -61,9 +62,29 @@ public class ModelImpl implements Model {
                 return new ModelDiffCursor(diffCursors);
         }
 
+        private void setState(long state) {
+                this.state = state;
+                uncommittedChanges = false;
+        }
+
+        void markAsChanged() {
+                if (!uncommittedChanges) {
+                        uncommittedChanges = true;
+                }
+        }
+
+        @Override
+        public boolean hasUncommittedChanges() {
+                return uncommittedChanges;
+        }
+
+        private boolean hasPendingAction() {
+                return pendingAction != ModelAction.NONE || restoringToState != NO_STATE_ID;
+        }
+
         @Override
         public long commit() {
-                if (pendingAction != ModelAction.NONE) {
+                if (hasPendingAction()) {
                         throw pendingActionError("commit");
                 }
                 pendingAction = ModelAction.COMMIT;
@@ -88,7 +109,7 @@ public class ModelImpl implements Model {
                                         versionSet = true;
                                 }
                         }
-                        state = version;
+                        setState(version);
                         while (i < listenerCount) {
                                 listeners.get(i).afterCommit();
                                 i++;
@@ -101,7 +122,7 @@ public class ModelImpl implements Model {
 
         @Override
         public void restore(long version) {
-                if (pendingAction != ModelAction.NONE) {
+                if (hasPendingAction()) {
                         throw pendingActionError("restore to %d".formatted(version));
                 }
                 if (!store.getStates().contains(version)) {
@@ -119,14 +140,14 @@ public class ModelImpl implements Model {
                         for (var interpretation : interpretations.values()) {
                                 interpretation.restore(version);
                         }
-                        state = version;
+                        setState(version);
                         while (i < listenerCount) {
                                 listeners.get(i).afterRestore();
                                 i++;
                         }
                 } finally {
                         pendingAction = ModelAction.NONE;
-                        restoringToState = -1;
+                        restoringToState = NO_STATE_ID;
                 }
         }
 
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelStoreImpl.java b/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelStoreImpl.java
index 8aab57af..e8c205e4 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelStoreImpl.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelStoreImpl.java
@@ -6,6 +6,7 @@ import tools.refinery.store.adapter.ModelAdapterType;
 import tools.refinery.store.adapter.ModelStoreAdapter;
 import tools.refinery.store.map.DiffCursor;
 import tools.refinery.store.map.VersionedMapStore;
+import tools.refinery.store.model.Model;
 import tools.refinery.store.model.ModelDiffCursor;
 import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.representation.AnySymbol;
@@ -27,13 +28,13 @@ public class ModelStoreImpl implements ModelStore {
                 return Collections.unmodifiableCollection(stores.keySet());
         }
 
-        private ModelImpl createEmptyModel(long state) {
+        private ModelImpl createModelWithoutInterpretations(long state) {
                 return new ModelImpl(this, state, adapters.size());
         }
 
         @Override
-        public ModelImpl createModel() {
-                var model = createEmptyModel(-1);
+        public ModelImpl createEmptyModel() {
+                var model = createModelWithoutInterpretations(Model.NO_STATE_ID);
                 var interpretations = new HashMap<AnySymbol, VersionedInterpretation<?>>(stores.size());
                 for (var entry : this.stores.entrySet()) {
                         var symbol = entry.getKey();
@@ -45,8 +46,8 @@ public class ModelStoreImpl implements ModelStore {
         }
 
         @Override
-        public synchronized ModelImpl createModel(long state) {
-                var model = createEmptyModel(state);
+        public synchronized ModelImpl createModelForState(long state) {
+                var model = createModelWithoutInterpretations(state);
                 var interpretations = new HashMap<AnySymbol, VersionedInterpretation<?>>(stores.size());
                 for (var entry : this.stores.entrySet()) {
                         var symbol = entry.getKey();
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/internal/VersionedInterpretation.java b/subprojects/store/src/main/java/tools/refinery/store/model/internal/VersionedInterpretation.java
index 1bdb1cdf..6d82f5d7 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/internal/VersionedInterpretation.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/internal/VersionedInterpretation.java
@@ -77,6 +77,7 @@ public class VersionedInterpretation<T> implements Interpretation<T> {
         @Override
         public T put(Tuple key, T value) {
                 checkKey(key);
+                model.markAsChanged();
                 var oldValue = map.put(key, value);
                 notifyListeners(key, oldValue, value, false);
                 return oldValue;
@@ -88,6 +89,7 @@ public class VersionedInterpretation<T> implements Interpretation<T> {
                         map.putAll(cursor);
                         return;
                 }
+                model.markAsChanged();
                 if (cursor.getDependingMaps().contains(map)) {
                         List<Tuple> keys = new ArrayList<>();
                         List<T> values = new ArrayList<>();