org.simantics.interop.update/src/org/simantics/interop/update/model/UpdateOperations.java

   1 package org.simantics.interop.update.model;
   2
   3 import java.util.ArrayList;
   4 import java.util.HashMap;
   5 import java.util.List;
   6 import java.util.Map;
   7 import java.util.Stack;
   8
   9 import org.simantics.db.ReadGraph;
  10 import org.simantics.db.Resource;
  11 import org.simantics.db.Session;
  12 import org.simantics.db.Statement;
  13 import org.simantics.db.WriteGraph;
  14 import org.simantics.db.common.request.ReadRequest;
  15 import org.simantics.db.exception.DatabaseException;
  16 import org.simantics.interop.test.GraphChanges;
  17
  18 /**
  19  *
  20  * @author Marko Luukkainen <marko.luukkainen@vtt.fi>
  21  *
  22  */
  23 public abstract  class UpdateOperations {
  24
  25         private List<UpdateOp> operations = new ArrayList<UpdateOp>();
  26         private Map<Resource, UpdateOp> resourceMap = new HashMap<Resource, UpdateOp>();
  27         private Map<Statement, UpdateOp> statementMap = new HashMap<Statement, UpdateOp>();
  28         private GraphChanges changes;
  29
  30         public UpdateOperations(GraphChanges changes) {
  31                 this.changes = changes;
  32         }
  33
  34         public UpdateOp getUpdateOp(Resource r) {
  35                 return resourceMap.get(r);
  36         }
  37
  38         public UpdateOp getUpdateOp(Statement s) {
  39                 return statementMap.get(s);
  40         }
  41
  42         public void applyAll(WriteGraph g) throws DatabaseException {
  43                 for (UpdateOp op : operations) {
  44                         apply(g, op);
  45                 }
  46         }
  47
  48         public void applySelected(WriteGraph g) throws DatabaseException {
  49                 for (UpdateOp op : operations) {
  50                         if (op.selected())
  51                                 apply(g, op);
  52                 }
  53         }
  54
  55         public List<UpdateOp> getOperations() {
  56                 return operations;
  57         }
  58
  59         public GraphChanges getChanges() {
  60                 return changes;
  61         }
  62
  63         public Map<Resource, UpdateOp> getResourceMap() {
  64                 return resourceMap;
  65         }
  66
  67         public Map<Statement, UpdateOp> getStatementMap() {
  68                 return statementMap;
  69         }
  70
  71         private void apply(WriteGraph g, UpdateOp op) throws DatabaseException {
  72                 Stack<UpdateOp> stack = new Stack<UpdateOp>();
  73                 _apply(g, stack, op);
  74         }
  75
  76         private void _apply(WriteGraph g, Stack<UpdateOp> stack, UpdateOp op) throws DatabaseException {
  77                 if (op.applied())
  78                         return;
  79                 if (stack.contains(op)) {
  80                         op.apply(g);
  81                         return;
  82                 }
  83                 stack.push(op);
  84                 for (UpdateOp pop : op.getParentOps())
  85                     if (op.requiresOp(pop)) {
  86                 if (!pop.applied())
  87                     _apply(g, stack, pop);
  88         }
  89                 for (UpdateOp sop : op.getSubOps())
  90                     if (op.requiresOp(sop)) {
  91                 if (!sop.applied())
  92                     _apply(g, stack, sop);
  93         }
  94                 stack.pop();
  95                 op.apply(g);
  96         }
  97
  98         protected List<UpdateOp> getOps() {
  99                 List<UpdateOp> list = new ArrayList<UpdateOp>(operations.size());
 100                 list.addAll(operations);
 101                 return list;
 102         }
 103
 104         protected void addOp(Resource r, UpdateOp op) {
 105                 resourceMap.put(r, op);
 106                 operations.add(op);
 107         }
 108
 109         protected void addOp(Statement s, UpdateOp op) {
 110                 statementMap.put(s, op);
 111                 operations.add(op);
 112         }
 113
 114         protected void replaceOp(Resource r, UpdateOp op) {
 115                 UpdateOp oldOp = resourceMap.remove(r);
 116                 if (oldOp != null) {
 117                         operations.remove(oldOp);
 118                 }
 119                 resourceMap.put(r, op);
 120                 operations.add(op);
 121         }
 122
 123         protected UpdateOp getOP(Resource r) {
 124                 return resourceMap.get(r);
 125         }
 126
 127         protected UpdateOp getOP(Statement r) {
 128                 return statementMap.get(r);
 129         }
 130
 131         public abstract void populate(ReadGraph g) throws DatabaseException;
 132
 133         /**
 134          * Secondary populate method. Override this for chunked DB operations.
 135          * @param session
 136          * @throws DatabaseException
 137          */
 138         public void populate(Session session) throws DatabaseException {
 139                 session.syncRequest(new ReadRequest() {
 140
 141                         @Override
 142                         public void run(ReadGraph graph) throws DatabaseException {
 143                                 populate(graph);
 144                         }
 145                 });
 146         }
 147
 148         protected boolean compares(Resource r1, Resource r2) {
 149                 if (r1.equals(r2))
 150                         return true;
 151                 if (changes.getComparable().contains(r1, r2))
 152                         return true;
 153                 return false;
 154         }
 155
 156 }