wip - op invalidation

Author: sbazerque

src/data/model/CascadedInvalidateOp.ts

@@ -0,0 +1,28 @@
+import { InvalidateAfterOp } from "./InvalidateAfterOp";
+import { MutationOp } from "./MutationOp";
+
+
+class CascadedInvalidateOp extends MutationOp {
+
+    targetOp?: MutationOp;
+    undo?: boolean;
+
+    constructor(undo?: boolean, targetOp?: MutationOp, causalOp?: InvalidateAfterOp|CascadedInvalidateOp) {
+        super(targetOp?.targetObject, causalOp === undefined? undefined : [causalOp].values());
+
+        if (undo !== undefined) {
+            this.undo = undo;
+        }
+        
+    }
+
+    getClassName(): string {
+        throw new Error("Method not implemented.");
+    }
+    init(): void {
+        throw new Error("Method not implemented.");
+    }
+
+}
+
+export { CascadedInvalidateOp };

src/data/model/UndoOp.ts

@@ -26,7 +26,7 @@ import { RedoOp } from './RedoOp';
   /* The diagram above shows the situations where an UndoOp may be necessary. Here
    * InvAfterOp on the top left is invalidating Op1, and transitively Op2 that is
    * causally dependant on Op1. However, InvAfterOp is itself being undone, then
-   * redone, then undone again, and those are also cascaded to Op1 and Op2.
+   * redone, then undone again, and those actions are also cascaded to Op1 and Op2.
    * 
    * There are 4 possible cases, marked above:
    * 
@@ -36,15 +36,13 @@ import { RedoOp } from './RedoOp';
    *  (2) is a cascade of (1) to Op2, that is dependent on Op1.
    * 
    *  (3) is a cascade of a RedoOp on the original InvAfterOp, that triggers a new
-   *  undo for Op1. Notice in this case that te RedoOp is cascaded as an undo.
+   *  undo for Op1. Notice in this case that the RedoOp is cascaded as an undo.
    * 
    *  (4) is similar to (2), but is undoing a RedoOp for Op2 instead of Op2 itself.
    * 
    * It is important to notice that in all cases but (1),
    * 
-   *          undo.target.causal == undo.causal.target
-   * 
-   * i.e. the squares in the diagram above commute.
+   *          undo.causal.target \in undo.target.causalOps
    * 
    */
 
@@ -54,8 +52,8 @@ class UndoOp extends MutationOp {
 
     targetOp?: MutationOp; // the op that will be undone
 
-    constructor(targetOp?: MutationOp, reason?: InvalidateAfterOp|UndoOp|RedoOp) {
-        super(targetOp?.targetObject);
+    constructor(targetOp?: MutationOp, causalOp?: InvalidateAfterOp|UndoOp|RedoOp) {
+        super(targetOp?.targetObject, causalOp === undefined? undefined : [causalOp].values());
 
         if (targetOp !== undefined) {
             this.targetOp = targetOp;
@@ -64,74 +62,51 @@ class UndoOp extends MutationOp {
                 throw new Error("An undo op can't be undone this way, please see RedoOp.");
             }
 
-            const targetOpCausalOps = this.targetOp.causalOps;
+            const undoneOp = targetOp;
 
-            if (targetOpCausalOps === undefined) {
+            if (undoneOp.causalOps === undefined) {
                 throw new Error("Can't undo an op that has no causal assumptions.");
             }
 
-            if (reason === undefined) {
-                throw new Error('Creating an undo op, but no reason was provided.');
+            if (causalOp === undefined) {
+                throw new Error('Creating an undo op, but no causal op was provided.');
             }
 
-            this.reasonOp = reason.createReference();
-
-            if (reason instanceof InvalidateAfterOp) {
+            if (causalOp instanceof InvalidateAfterOp) {
 
-                const invalidateAfterOp = reason as InvalidateAfterOp;
+                const invAfterOp = causalOp;
 
-                const targetOp = invalidateAfterOp.getTargetOp();
+                if (!undoneOp.causalOps.has((invAfterOp.targetOp as MutationOp).createReference())) {
 
-                if (!targetOpCausalOps.has(targetOp.createReference())) {
-                    throw new Error('Wrong undo: the target op is not a consequence of the invalidated op.');
+                    throw new Error('Creating undo because of an InvalidateAfterOp, but the op being undone does not depend on the invalidated one.');
                 }
 
-                // here we could check that targetOp is really outside of invalidateAfterOp.terminalOps,
+                // here we could also check that targetOp is really outside of invalidateAfterOp.terminalOps,
                 // but that's costly, and constructor checks aim only to aid debugging, so we'll not.
 
-                if (!this.getTargetObject().equals(invalidateAfterOp.getTargetObject())) {
+                if (!this.getTargetObject().equals(invAfterOp.getTargetObject())) {
                     throw new Error('Trying to undo an op in a different mutable object than the invalidation op.');
                 }
 
 
             } else {
 
-                // the op that is being undone (this.targetOp) has the op
-                // that was undone/redone by reason (this.reasonOp.targetOp)
-                // in its causalOps (i.e. this.reasonOp.targetOp \in this.targetOp.causalOps)
-
-                // this diagram commutes:
-
-                /*  this.reasonOp.targetOp
-                 *       ===                < --------- this.targetOp
-                 *  this.targetOp.reasonOp                 ^
-                 *    ^                                    |
-                 *    | targetOp                           | targetOp
-                 *    |                   reasonOp         |
-                 *  this.reasonOp <--------------------- this
-                 */ 
-
-                
-
-
-
-                if (this.targetOp.causalOps === undefined) {
-                    throw new Error('The targetOp of an UndoOp must have a non-empty causalOps set.');
-                }
+                // Must be one of the cases 2-4 mentioned in the note above, hence:
+                //   undo.causal.target \in undo.target.causalOps
 
-                if (!this.targetOp.causalOps.has((reason.targetOp as HashedObject).createReference())) {
-                    throw new Error('The targetOp of an UndoOp must have a non-empty causalOps set.');
+                if (!undoneOp.causalOps.has((causalOp.targetOp as MutationOp).createReference())) {
+                    throw new Error('Attempting to create a cascaded UndoOp, but the received causal op does not trigger a valid cascade for the op being undone.')
                 }
 
-                if (reason instanceof RedoOp) { 
+                if (causalOp instanceof RedoOp) { 
 
                     if (! (this.targetOp instanceof RedoOp)) {
                         throw new Error('If the reason for an UndoOp is a RedoOp, its target must be a RedoOp too.');
                     }
 
-                } else if (reason instanceof UndoOp) {
+                } else if (causalOp instanceof UndoOp) {
 
-                    const cascadedUndoOp = reason as UndoOp;
+                    const cascadedUndoOp = causalOp as UndoOp;
 
                     const undoneDepOp = cascadedUndoOp.getTargetOp();