Edit tracking + undo redo for primitive properties

Working on class/struct properties next. Don't want to resort to making every complex field a full EditorObject like I did in C++. That created some serious bloat in the DB text file and could add unecessary overhead if editor objects get heavier in the future.

Author: Moneyl

src/App/Project/DiffUtil.bf

@@ -0,0 +1,118 @@
+using System.Collections;
+using System.Reflection;
+using Nanoforge;
+using System;
+
+namespace Nanoforge.App.Project
+{
+    static
+    {
+        public static mixin BeginCommit(StringView commitName)
+        {
+            DiffUtil diffUtil = scope:: .(commitName);
+            diffUtil
+        }
+
+        //Override for when you're only tracking changes on one object
+        public static mixin BeginCommit<T>(StringView commitName, T obj) where T : EditorObject
+        {
+            DiffUtil diffUtil = scope:: .(commitName);
+            diffUtil.Track<T>(obj);
+            diffUtil
+        }
+    }
+
+    //Tracks changes made to editor objects, generates a set of transactions representing those changes, and commits them to the project DB.
+    //Transactions can be rolled back prior to committing them. Useful if an error occurs.
+    //DiffUtil is NOT thread safe. You should only use an instance with one thread at a time.
+    public class DiffUtil : IDisposable
+    {
+        private Dictionary<EditorObject, ISnapshot> _snapshots = new .() ~DeleteDictionaryAndValues!(_);
+        private List<EditorObject> _newObjects = new .() ~delete _;
+        private Dictionary<EditorObject, String> _newObjectNames = new .() ~DeleteDictionaryAndValues!(_);
+        public readonly String CommitName = new .() ~delete _;
+        public bool Cancelled { get; private set; } = false;
+
+        public this(StringView commitName)
+        {
+            CommitName.Set(commitName);
+        }
+
+        public void Track<T>(T target) where T : EditorObject
+        {
+            _snapshots[target] = new Snapshot<T>(target);
+        }
+
+        public void Commit()
+        {
+            //Generate property change transactions
+            List<ITransaction> transactions = scope .();
+            for (var kv in _snapshots)
+            {
+                EditorObject target = kv.key;
+                var snapshot = kv.value;
+
+                //For new objects generate a creation transaction + add the object to the DB
+                if (_newObjects.Contains(target))
+                {
+					transactions.Add(new CreateObjectTransaction(target, _newObjectNames.GetValueOrDefault(target)));
+                    ProjectDB.AddObject(target);
+                    if (_newObjectNames.ContainsKey(target))
+                        ProjectDB.SetObjectName(target, _newObjectNames[target]);
+                }
+
+                //Generate transactions describing property changes
+                snapshot.GenerateDiffTransactions(transactions);
+            }
+
+            ProjectDB.Commit(transactions, CommitName);
+        }
+
+        public void Rollback()
+        {
+            Cancelled = true;
+
+            //Delete new objects + their names
+            for (EditorObject obj in _newObjects)
+                delete obj;
+
+            DeleteDictionaryAndValues!(_newObjectNames);
+
+            //Apply snapshots to pre-existing objects to undo changes
+            for (var kv in _snapshots)
+            {
+                EditorObject obj = kv.key;
+                ISnapshot snapshot = kv.value;
+                snapshot.Apply(obj);
+            }
+        }
+
+        public void Cancel()
+        {
+            Cancelled = true;
+        }
+
+        public void Dispose()
+        {
+            if (Cancelled)
+            {
+                Rollback();
+            }
+            else
+            {
+                Commit();
+            }
+        }
+
+        public T CreateObject<T>(StringView name) where T : EditorObject
+        {
+            T obj = new T();
+            _newObjects.Add(obj);
+            if (name != "")
+                _newObjectNames[obj] = new .()..Set(name);
+
+            Track<T>(obj);
+            return obj;
+        }
+    }
+}

src/App/Project/EditorObject.bf

@@ -14,16 +14,8 @@ namespace Nanoforge.App
 
     public class EditorObject
     {
-        public String Name
-        {
-            get
-            {
-                return ProjectDB.GetObjectName(this);
-            }
-            set
-            {
-                ProjectDB.SetObjectName(this, value);
-            }
-        }
+        public bool HasName => ProjectDB.GetObjectName(this) case .Ok;
+        public Result<String> GetName() => ProjectDB.GetObjectName(this);
+        public void SetName(StringView name) => ProjectDB.SetObjectName(this, name);
     }
 }

src/App/Project/Helpers.bf

@@ -1,20 +1,9 @@
 using System.Collections;
-using System.Reflection;
 using Nanoforge;
 using System;
 
 namespace Nanoforge.App.Project
 {
-    static
-    {
-        public static DiffUtil<T> TrackChanges<T>(T obj, StringView commitName) where T : EditorObject
-        {
-            DiffUtil<T> self = new .(obj, commitName);
-            self.CreateSnapshot(obj);
-            return self;
-        }
-    }
-
     public struct EditorPropertyInfo
     {
         public StringView Name;
@@ -33,20 +22,10 @@ namespace Nanoforge.App.Project
         }
     }
 
-    public class DiffUtil<T> : IDisposable
-		                       where T : EditorObject 
+    public struct TypeUtil<T> where T : EditorObject
     {
-        public T Target;
-        public readonly String CommitName = new .() ~delete _;
-
         public const EditorPropertyInfo[?] PropertyInfo = GetEditorProperties();
 
-        public this(T target, StringView commitName)
-        {
-            Target = target;
-            CommitName.Set(commitName);
-        }
-
         //Grab a list of tracked properties and their metadata during comptime for quick operations at runtime
         [Comptime(ConstEval=true)]
         private static Span<EditorPropertyInfo> GetEditorProperties()
@@ -65,54 +44,5 @@ namespace Nanoforge.App.Project
             }
             return properties;
         }
-
-        [OnCompile(.TypeInit), Comptime]
-        public static void GenerateCode()
-        {
-            //Generate fields for holding snapshot of the object state
-            Type selfType = typeof(Self);
-            for (var field in typeof(T).GetFields())
-            {
-                //Only track fields with [EditorProperty] attribute
-                var result = field.GetCustomAttribute<EditorPropertyAttribute>();
-                if (result == .Err)
-                    continue;
-
-                StringView fieldName = field.Name;
-                var fieldTypeName = field.FieldType.GetFullName(.. scope .());
-                Compiler.EmitTypeBody(selfType, scope $"private {fieldTypeName} {fieldName};\n");
-            }
-
-            //Generate CreateSnapshot()
-            Compiler.EmitTypeBody(selfType, scope $"\npublic void CreateSnapshot({typeof(T).GetFullName(.. scope .())} obj)");
-            Compiler.EmitTypeBody(selfType, "\n{\n");
-            int offset = 0;
-            for (var field in typeof(T).GetFields())
-            {
-                //Only track fields with [EditorProperty] attribute
-                var result = field.GetCustomAttribute<EditorPropertyAttribute>();
-                if (result == .Err)
-                    continue;
-
-                StringView fieldName = field.Name;
-                Compiler.EmitTypeBody(selfType, scope $"    this.{fieldName} = obj.[Friend]{fieldName};\n");
-                offset += field.FieldType.InstanceSize;
-            }
-            Compiler.EmitTypeBody(selfType, "}");
-
-            //TODO: Generate Commit()
-        }
-
-        public void Commit()
-        {
-            //TODO: Iterate through properties and compare snapshot value with current value
-            //TODO: Generate transactions for different properties
-        }
-
-        public void Dispose()
-        {
-            Commit();
-            delete this;
-        }
     }
 }

src/App/Project/ProjectDB.bf

@@ -1,3 +1,4 @@
+using Nanoforge.App.Project;
 using System.Diagnostics;
 using System.Collections;
 using System.Threading;
@@ -23,25 +24,49 @@ namespace Nanoforge.App
         static Dictionary<EditorObject, String> _objectNames = new .() ~DeleteDictionaryAndValues!(_); //Names owned by Project so we don't add unnecessary bloat to unnamed objects
         static append Monitor _objectNameDictionaryLock;
         static append Monitor _objectCreationLock;
+        static append Monitor _commitLock;
 
-        public static T CreateObject<T>() where T : EditorObject, new
+        //Undo/redo stacks. Just using plain lists + Add() & PopBack() to handle pushing onto the stack and popping off it.
+        //Eventually should replace with a Stack<T> class that inherits List<T> and hides non stack function. At the moment Beef doesn't have a standard stack class.
+        public static List<Commit> UndoStack = new .() ~DeleteContainerAndItems!(_);
+        public static List<Commit> RedoStack = new .() ~DeleteContainerAndItems!(_);
+         
+        public static T CreateObject<T>(StringView name = "") where T : EditorObject, new
         {
             ScopedLock!(_objectCreationLock);
             T obj = new T();
             _objects.Add(obj);
+            if (name != "")
+                SetObjectName(obj, name);
             return obj;
         }
 
-        public static String GetObjectName(EditorObject object)
+        //Used to add objects created by DiffUtil when it commits changes. It creates its own objects so they can be destroyed on rollback and don't exist program wide until commit.
+        public static void AddObject(EditorObject obj)
+        {
+            ScopedLock!(_objectCreationLock);
+            _objects.Add(obj);
+        }
+
+        //Removes object from ProjectDB. Not recommended for direct use. Doesn't delete the object. That way transactions can still hold object info on the redo stack to restore it as required
+        //Currently doesn't remove any references to this object that others might have. If used in the undo/redo stack that shouldn't frequently be a problem.
+        public static void RemoveObject(EditorObject obj)
+        {
+            ScopedLock!(_objectCreationLock);
+            _objects.Remove(obj);
+            _objectNames.Remove(obj);
+        }
+
+        public static Result<String> GetObjectName(EditorObject object)
         {
             ScopedLock!(_objectNameDictionaryLock);
             if (_objectNames.ContainsKey(object))
             {
-                return _objectNames[object];
+                return .Ok(_objectNames[object]);
             }
             else
             {
-                return null;
+                return .Err;
             }
         }
 
@@ -58,7 +83,7 @@ namespace Nanoforge.App
             }
         }
 
-        public static EditorObject GetObjectByName(StringView name)
+        public static EditorObject Find(StringView name)
         {
             for (var kv in _objectNames)
                 if (StringView.Equals(kv.value, name))
@@ -67,10 +92,10 @@ namespace Nanoforge.App
             return null;
         }
 
-        public static T GetObjectByName<T>(StringView name) where T : EditorObject
+        public static T Find<T>(StringView name) where T : EditorObject
         {
-            Object obj = GetObjectByName(name);
-            return obj.GetType() == typeof(T) ? (T)obj : null;
+            Object obj = Find(name);
+            return (obj != null && obj.GetType() == typeof(T)) ? (T)obj : null;
         }
 
         public static void Reset()
@@ -86,5 +111,42 @@ namespace Nanoforge.App
             _objectNames.Clear();
             Ready = false;
         }
+
+        //Commit changes to undo stack. ProjectDB takes ownership of the transactions
+        public static void Commit(Span<ITransaction> transactions, StringView commitName)
+        {
+            ScopedLock!(_commitLock);
+            UndoStack.Add(new Commit(commitName, transactions));
+        }
+
+        //Undo single commit
+        public static void Undo()
+        {
+            ScopedLock!(_commitLock);
+            if (UndoStack.Count > 0)
+            {
+                Commit undo = UndoStack.PopBack();
+                for (ITransaction transaction in undo.Transactions)
+                {
+                    transaction.Revert();
+                }
+                RedoStack.Add(undo);
+            }
+        }
+
+        //Redo single commit
+        public static void Redo()
+        {
+            ScopedLock!(_commitLock);
+            if (RedoStack.Count > 0)
+            {
+                Commit redo = RedoStack.PopBack();
+                for (ITransaction transaction in redo.Transactions)
+                {
+                    transaction.Apply();
+                }
+                UndoStack.Add(redo);
+            }
+        }
 	}
 }