Process changes in smaller chunks

[simantics/interop.git] / org.simantics.interop.update / src / org / simantics / interop / update / model / UpdateTree.java

diff --git a/org.simantics.interop.update/src/org/simantics/interop/update/model/UpdateTree.java b/org.simantics.interop.update/src/org/simantics/interop/update/model/UpdateTree.java
index 739667228a01291bea2cdf07789e719b72624672..bf7e0688546beb2e053529ee30e54b41350b738d 100644 (file)
--- a/org.simantics.interop.update/src/org/simantics/interop/update/model/UpdateTree.java
+++ b/org.simantics.interop.update/src/org/simantics/interop/update/model/UpdateTree.java
@@ -3,11 +3,15 @@ package  org.simantics.interop.update.model;
 import java.util.HashMap;
 import java.util.Map;
 
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.NullProgressMonitor;
 import org.simantics.db.ReadGraph;
 import org.simantics.db.Resource;
+import org.simantics.db.Session;
+import org.simantics.db.common.request.ResourceRead;
 import org.simantics.db.exception.DatabaseException;
+import org.simantics.db.request.Read;
 import org.simantics.interop.test.GraphChanges;
-import org.simantics.interop.update.model.UpdateNode.Status;
 
 
 public class UpdateTree {
@@ -21,12 +25,48 @@ public class UpdateTree {
        public UpdateTree(ReadGraph g, GraphChanges changes, UpdateOperations updateOps) throws DatabaseException {
                this.changes = changes;
                this.nodes = new HashMap<Resource, UpdateNode>();
-               this.rootNode = createNode(g, Status.EXIST, changes.getResource1());
+               this.rootNode = createNode(g, UpdateStatus.EXIST, changes.getResource1());
                nodes.put(changes.getResource1(), rootNode);
                nodes.put(changes.getResource2(), rootNode);
                this.updateOps = updateOps;
                this.updateOps.populate(g);
                populate(g);
+               this.rootNode.sort();
+       }
+       
+       public UpdateTree(Session session, GraphChanges changes, UpdateOperations updateOps) throws DatabaseException {
+               this(session, changes, updateOps, new NullProgressMonitor());
+       }
+       
+       public UpdateTree(Session session, GraphChanges changes, UpdateOperations updateOps, IProgressMonitor monitor) throws DatabaseException {
+               this.changes = changes;
+               this.nodes = new HashMap<Resource, UpdateNode>();
+               this.rootNode = session.syncRequest(new NodeRequest(UpdateStatus.EXIST, changes.getResource1()));
+               nodes.put(changes.getResource1(), rootNode);
+               nodes.put(changes.getResource2(), rootNode);
+               this.updateOps = updateOps;
+               this.updateOps.populate(session, monitor);
+               populate(session, monitor);
+               if (monitor.isCanceled()) {
+                       this.changes = null;
+                       this.nodes.clear();
+                       this.updateOps = null;
+                       this.rootNode = null;
+               } else {
+                       this.rootNode.sort();
+               }
+       }
+       
+       private class NodeRequest extends ResourceRead<UpdateNode> {
+               UpdateStatus status;
+               public NodeRequest(UpdateStatus status, Resource r) {
+                       super(r);
+                       this.status = status;
+               }
+               @Override
+               public UpdateNode perform(ReadGraph graph) throws DatabaseException {
+                       return createNode(graph, status, resource);
+               }
        }
        
        public UpdateOperations getUpdateOps() {
@@ -41,34 +81,37 @@ public class UpdateTree {
                return changes;
        }
        
-       protected UpdateNode createNode(ReadGraph g, Status status, Resource r) throws DatabaseException {
+       protected UpdateNode createNode(ReadGraph g, UpdateStatus status, Resource r) throws DatabaseException {
                return new UpdateNode(g,status, r);
        }
        
-       protected UpdateNode createNode(ReadGraph g, Status status, UpdateOp op) throws DatabaseException{
+       protected UpdateNode createNode(ReadGraph g, UpdateStatus status, UpdateOp op) throws DatabaseException{
                return new UpdateNode(g,status, op);
        }
        
        private UpdateNode createNode(ReadGraph g, Resource r1, Resource r2) throws DatabaseException {
                UpdateNode node = null;
                if (r1 != null && r2 != null) {
-                       node =  createNode(g, Status.EXIST, r1);
+                   UpdateOp op = updateOps.getUpdateOp(r1);
+                   if (op == null)
+                       op = updateOps.getUpdateOp(r2);
+            if (op == null)                    
+                node = createNode(g, UpdateStatus.EXIST, r1);
+            else
+                node = createNode(g, UpdateStatus.EXIST, op);
                        nodes.put(r1, node);
                        nodes.put(r2, node);
                } else if (r1 != null) {
-                       node = createNode(g,Status.DELETED ,updateOps.getUpdateOp(r1));
+                       node = createNode(g,UpdateStatus.DELETED ,updateOps.getUpdateOp(r1));
                        nodes.put(r1, node);
                } else if (r2 != null) {
-                       node = createNode(g,Status.NEW, updateOps.getUpdateOp(r2));
+                       node = createNode(g,UpdateStatus.NEW, updateOps.getUpdateOp(r2));
                        nodes.put(r2, node);
                }
                return node;
        }
        
        public UpdateNode addNode(ReadGraph g, Resource r1, Resource r2) throws DatabaseException {
-               if (r1 != null && r2 != null) {
-                       return null;
-               }
                if (nodes.containsKey(r1))
                        return nodes.get(r1);
                if (nodes.containsKey(r2))
@@ -79,7 +122,7 @@ public class UpdateTree {
                return node;
        }
        
-       protected UpdateNode getNode(Resource r) {
+       public UpdateNode getNode(Resource r) {
                return nodes.get(r);
        }
        
@@ -125,18 +168,54 @@ public class UpdateTree {
                return false;
        }
        
-       private void populate(ReadGraph g) throws DatabaseException{
+       protected void populate(ReadGraph g) throws DatabaseException{
 
                for (UpdateOp op : updateOps.getOperations()) {
-                       if (!handleCustom(g, op)) {
-                               if (op.isAdd()) {
-                                       addNode(g, null,op.getResource());
-                               } else {
-                                       addNode(g, op.getResource(), null);
-                               }
+                       populate(g, op);
+               }
+               
+       }
+       
+       protected void populate(ReadGraph g, UpdateOp op) throws DatabaseException{
+               if (!handleCustom(g, op)) {
+                       if (op.isAdd()) {
+                               addNode(g, null,op.getResource());
+                       } else if (op.isDelete()){
+                               addNode(g, op.getResource(), null);
+                       } else if (op.isChange()) {
+                               Resource o = op.getResource();
+                           Resource l = getChanges().getComparable().containsLeft(o) ? o :getChanges().getComparable().getLeft(o);
+                           Resource r = getChanges().getComparable().containsRight(o) ? o :getChanges().getComparable().getRight(o);
+                           addNode(g, l, r);
                        }
                }
+       }
+       
+       protected void populate(Session session, IProgressMonitor monitor) throws DatabaseException{
+               int i = 0;
+               while (i < updateOps.getOperations().size()) {
+                       if (monitor.isCanceled())
+                               return;
+                       i = session.syncRequest(new PopulateRead(i));
+               }
+       }
+       
+       protected class PopulateRead implements Read<Integer> {
+               int s;
+               public PopulateRead(int s) {
+                       this.s = s;
+               }
                
+               public Integer perform(ReadGraph graph) throws DatabaseException {
+                       int l = s + 100;
+                       if (l > updateOps.getOperations().size())
+                               l = updateOps.getOperations().size();
+                       for (int i = s; i < l; i++) {
+                               UpdateOp op = updateOps.getOperations().get(i);
+                               populate(graph, op);
+                       }
+                       return l;
+               }
        }
 
 }