1 package org.simantics.interop.mapping;
\r
3 import java.util.ArrayList;
\r
4 import java.util.Collection;
\r
5 import java.util.Iterator;
\r
6 import java.util.List;
\r
8 import org.eclipse.core.runtime.IProgressMonitor;
\r
9 import org.eclipse.core.runtime.NullProgressMonitor;
\r
10 import org.simantics.db.ReadGraph;
\r
11 import org.simantics.db.Resource;
\r
12 import org.simantics.db.Session;
\r
13 import org.simantics.db.VirtualGraph;
\r
14 import org.simantics.db.WriteGraph;
\r
15 import org.simantics.db.common.request.ReadRequest;
\r
16 import org.simantics.db.common.request.WriteRequest;
\r
17 import org.simantics.db.common.request.WriteResultRequest;
\r
18 import org.simantics.db.common.utils.NameUtils;
\r
19 import org.simantics.db.exception.DatabaseException;
\r
20 import org.simantics.db.exception.ServiceException;
\r
21 import org.simantics.db.layer0.util.SessionGarbageCollection;
\r
22 import org.simantics.db.request.Read;
\r
23 import org.simantics.interop.mapping.data.GraphNode;
\r
24 import org.simantics.interop.mapping.data.Identifiable;
\r
25 import org.simantics.interop.mapping.data.Link;
\r
26 import org.simantics.interop.mapping.data.ResourceIdentifiable;
\r
27 import org.simantics.ui.jobs.SessionGarbageCollectorJob;
\r
28 import org.simantics.utils.datastructures.MapList;
\r
29 import org.simantics.utils.datastructures.Pair;
\r
33 * @author Marko Luukkainen <marko.luukkainen@vtt.fi>
\r
36 public class Mapper {
\r
38 public static final boolean USE_SPLIT_TRANSACTIONS = false; // Split transactions
\r
39 public static int OBJECTS_PER_TRANSACTION = 5000; // number of objects handled per transaction (split mode)
\r
40 private static boolean SLEEP_BETWEEN_WRITES = false; // sleep between transactions (split mode)
\r
41 private static int SLEEP_TIME = 10; // time to sleep (ms)
\r
42 private static boolean COLLECT_BETWEEN_WRITES = false; // Run SessionGC between split transactions
\r
43 private static boolean COLLECT_WITHIN_TRANSACTIONS = true; // Run Collect within transactions (both modes)
\r
44 public static int OBJECTS_BEFORE_COLLECT = 5000; // number of objects that are handled before collect (non-split mode)
\r
46 private List<InitializedRule> initializedRules = new ArrayList<InitializedRule>();
\r
47 private List<Pair<IdentificationRule, Pair<Integer,GenerationRule>>> generationRules;
\r
48 private List<List<ModificationRule>> globalModificationRules;
\r
49 private List<List<Pair<IdentificationRule, ModificationRule>>> modificationRules;
\r
50 private List<Pair<ConnectionIdentificationRule, ConnectionGenerationRule>> connectionRules;
\r
55 long maxMemory = Runtime.getRuntime().maxMemory();
\r
56 maxMemory /= (1024*1024); // Convert to MB;
\r
57 int use = 290; // Estimated memory usage of the system
\r
58 int freeMem = (int)maxMemory-use; // Free memory for mappings
\r
59 OBJECTS_BEFORE_COLLECT = (freeMem * freeMem) / 1000; //600M heap -> 84, 3000M heap -> 5645
\r
60 if (OBJECTS_BEFORE_COLLECT < 2)
\r
61 OBJECTS_BEFORE_COLLECT = 2;
\r
62 OBJECTS_PER_TRANSACTION = OBJECTS_BEFORE_COLLECT;
\r
65 generationRules = new ArrayList<Pair<IdentificationRule,Pair<Integer,GenerationRule>>>();
\r
66 modificationRules = new ArrayList<List<Pair<IdentificationRule,ModificationRule>>>();
\r
67 globalModificationRules = new ArrayList<List<ModificationRule>>();
\r
68 connectionRules = new ArrayList<Pair<ConnectionIdentificationRule, ConnectionGenerationRule>>();
\r
71 public void addRule(int pass, IdentificationRule idRule, GenerationRule genRule) {
\r
72 if (idRule == null || genRule == null) throw new NullPointerException();
\r
73 generationRules.add(new Pair<IdentificationRule, Pair<Integer,GenerationRule>>(idRule, new Pair<Integer,GenerationRule>(pass,genRule)));
\r
74 maxGenPass = Math.max(maxGenPass, pass);
\r
75 if (genRule instanceof InitializedRule)
\r
76 initializedRules.add((InitializedRule)genRule);
\r
79 public void addRule(IdentificationRule idRule, MappingRule mappingRule) {
\r
80 addRule(0,idRule,mappingRule);
\r
83 public void addRule(int pass, IdentificationRule idRule, MappingRule mappingRule) {
\r
84 if (idRule == null || mappingRule == null) throw new NullPointerException();
\r
85 if (mappingRule instanceof ModificationRule) {
\r
86 while (pass >= modificationRules.size()) {
\r
87 modificationRules.add(new ArrayList<Pair<IdentificationRule,ModificationRule>>());
\r
89 List<Pair<IdentificationRule,ModificationRule>> priList = modificationRules.get(pass);
\r
90 priList.add(new Pair<IdentificationRule, ModificationRule>(idRule, (ModificationRule)mappingRule));
\r
92 if (mappingRule instanceof GenerationRule)
\r
93 generationRules.add(new Pair<IdentificationRule, Pair<Integer,GenerationRule>>(idRule, new Pair<Integer,GenerationRule>(pass,(GenerationRule)mappingRule)));
\r
94 if (mappingRule instanceof InitializedRule)
\r
95 initializedRules.add((InitializedRule)mappingRule);
\r
98 public void addRule(IdentificationRule idRule, ModificationRule... modRules) {
\r
99 addRule(0, idRule, modRules);
\r
102 public void addRule(int pass, IdentificationRule idRule, ModificationRule... modRules) {
\r
103 if (idRule == null) throw new NullPointerException();
\r
105 while (pass >= modificationRules.size()) {
\r
106 modificationRules.add(new ArrayList<Pair<IdentificationRule,ModificationRule>>());
\r
108 List<Pair<IdentificationRule,ModificationRule>> priList = modificationRules.get(pass);
\r
110 for (ModificationRule modRule : modRules){
\r
111 if (modRule == null) throw new NullPointerException();
\r
112 priList.add(new Pair<IdentificationRule, ModificationRule>(idRule, modRule));
\r
113 if (modRule instanceof InitializedRule)
\r
114 initializedRules.add((InitializedRule)modRule);
\r
117 public void addRule(ModificationRule modRule) {
\r
118 addRule(0, modRule);
\r
121 public void addRule(InitializedRule initRule) {
\r
122 initializedRules.add(initRule);
\r
125 public void addRule(int pass, ModificationRule modRule) {
\r
126 if (modRule == null) throw new NullPointerException();
\r
127 while (pass >= globalModificationRules.size()) {
\r
128 globalModificationRules.add(new ArrayList<ModificationRule>());
\r
130 List<ModificationRule> priList = globalModificationRules.get(pass);
\r
131 priList.add(modRule);
\r
132 if (modRule instanceof InitializedRule)
\r
133 initializedRules.add((InitializedRule)modRule);
\r
136 public void addRule(ConnectionIdentificationRule idRule, ConnectionGenerationRule genRule) {
\r
137 if (idRule == null || genRule == null) throw new NullPointerException();
\r
138 connectionRules.add(new Pair<ConnectionIdentificationRule, ConnectionGenerationRule>(idRule, genRule));
\r
139 if (genRule instanceof InitializedRule)
\r
140 initializedRules.add((InitializedRule)genRule);
\r
144 * Runs the mapping procedure. Disposes nodes after mapping is done.
\r
149 * @throws Exception
\r
151 public void map(WriteGraph g, Resource model, Collection<GraphNode<Identifiable>> nodes, IProgressMonitor monitor) throws Exception {
\r
152 startMapping(null);
\r
154 if (monitor == null)
\r
155 monitor = new NullProgressMonitor();
\r
157 for (InitializedRule rule : initializedRules)
\r
158 rule.initialize(g, model);
\r
160 applyModifications(g, nodes, monitor);
\r
162 applyGenerations(g,nodes,monitor);
\r
164 applyConnections(g,nodes,monitor);
\r
167 MappingTools.disposeNodes(nodes);
\r
174 * Runs the mapping procedure. Disposes nodes after mapping is done.
\r
179 * @throws Exception
\r
181 public void map(Session session, Resource model, Collection<GraphNode<Identifiable>> nodes, IProgressMonitor monitor) throws Exception {
\r
182 map(session, model, null, nodes, monitor);
\r
186 * Runs the mapping procedure. Disposes nodes after mapping is done.
\r
192 * @throws Exception
\r
194 public void map(Session session, Resource model, VirtualGraph vg, Collection<GraphNode<Identifiable>> nodes, IProgressMonitor monitor) throws Exception {
\r
197 long time = System.currentTimeMillis();
\r
198 if (monitor == null)
\r
199 monitor = new NullProgressMonitor();
\r
201 initializeRules(session, vg, model);
\r
202 if (USE_SPLIT_TRANSACTIONS) {
\r
203 applyModifications(session, nodes, monitor);
\r
205 applyGenerations(session, vg, nodes, monitor);
\r
207 applyConnections(session, vg, nodes, monitor);
\r
210 applyModifications2(session, nodes, monitor);
\r
212 applyGenerations2(session, vg, nodes, monitor);
\r
214 applyConnections2(session, vg, nodes, monitor);
\r
217 long time2 = System.currentTimeMillis();
\r
218 System.out.println("Mapping took " + ((time2-time)/1000) + " seconds");
\r
220 MappingTools.disposeNodes(nodes);
\r
221 if (COLLECT_BETWEEN_WRITES) {
\r
223 SessionGarbageCollection.gc(null, session, true, null);
\r
231 //private boolean autosaveEndabled = false;
\r
232 private VirtualGraph vg;
\r
234 protected void startMapping(VirtualGraph vg) {
\r
235 SessionGarbageCollectorJob.getInstance().setEnabled(false);
\r
236 //autosaveEndabled = AutosaveCommands.getInstance().isEnabled();
\r
237 //AutosaveCommands.getInstance().setEnabled(false);
\r
241 protected void endMapping() {
\r
242 SessionGarbageCollectorJob.getInstance().setEnabled(true).scheduleAfterQuietTime();
\r
243 // AutosaveCommands.getInstance().setEnabled(autosaveEndabled);
\r
247 private void applyModifications(ReadGraph g, Collection<GraphNode<Identifiable>> nodes, IProgressMonitor monitor) throws Exception {
\r
249 // Apply global modification rules first
\r
251 int passCount = Math.max(globalModificationRules.size(),modificationRules.size());
\r
253 for (int pass = 0; pass < passCount; pass++) {
\r
254 if (globalModificationRules.size() > pass) {
\r
256 List<ModificationRule> modRules = globalModificationRules.get(pass);
\r
257 int size = modRules.size();
\r
258 monitor.subTask("Running global modification rules: pass (" + (pass+1) + "/" + passCount + "), rule ("+ (++count) + "/" + size + ")");
\r
259 for (ModificationRule r : modRules) {
\r
260 Collection<GraphNode<Identifiable>> ruleModified = r.modify(g, nodes);
\r
261 if (ruleModified == null)
\r
263 for (GraphNode<Identifiable> m : ruleModified) {
\r
264 if (m.isDisposed()) {
\r
267 else if (!nodes.contains(m)) {
\r
271 monitor.subTask("Running global modification rules: pass (" + (pass+1) + "/" + passCount + "), rule ("+ (++count) + "/" + size + ")");
\r
272 if(monitor.isCanceled()) {
\r
273 throw new CancelException("Cancel requested.");
\r
275 if (COLLECT_WITHIN_TRANSACTIONS)
\r
278 } if (modificationRules.size() > pass) {
\r
280 List<Pair<IdentificationRule, ModificationRule>> modRules = modificationRules.get(pass);
\r
281 int size = modRules.size();
\r
282 monitor.subTask("Running object modification rules: pass (" + (pass+1) + "/" + passCount + "), rule ("+ (++count) + "/" + size + ")");
\r
283 // Apply per object modification rules
\r
284 for (Pair<IdentificationRule, ModificationRule> modRule : modRules) {
\r
285 Collection<GraphNode<Identifiable>> ruleModified = new ArrayList<GraphNode<Identifiable>>();
\r
286 for (GraphNode<Identifiable> n : nodes) {
\r
287 applyModifications(g, n, modRule, ruleModified);
\r
288 if (COLLECT_WITHIN_TRANSACTIONS)
\r
292 for (GraphNode<Identifiable> m : ruleModified) {
\r
293 if (m.isDisposed()) {
\r
296 else if (!nodes.contains(m)) {
\r
300 monitor.subTask("Running object modification rules: pass (" + (pass+1) + "/" + passCount + "), rule ("+ (++count) + "/" + size + ")");
\r
301 if(monitor.isCanceled()) {
\r
302 throw new CancelException("Cancel requested.");
\r
313 private void applyGenerations(WriteGraph graph, Collection<GraphNode<Identifiable>> nodes, IProgressMonitor monitor) throws Exception {
\r
315 int size = nodes.size();
\r
317 monitor.subTask("Assigning generation rules ("+ count + "/" + size + ")");
\r
318 // populate generation rules
\r
319 for (GraphNode<Identifiable> n : nodes) {
\r
321 for (Pair<IdentificationRule,Pair<Integer,GenerationRule>> r : generationRules) {
\r
322 if (r.first.matches(graph, n)) {
\r
323 MappingTools.assignGenerationRule(n, r.second.first,r.second.second);
\r
326 monitor.subTask("Assigning generation rules ("+ (++count) + "/" + size + ")");
\r
327 if(monitor.isCanceled()) {
\r
328 throw new CancelException("Cancel requested.");
\r
330 if (COLLECT_WITHIN_TRANSACTIONS)
\r
335 monitor.subTask("Generating objects ("+ count + "/" + size + ")");
\r
337 // apply generation rules.
\r
338 //WriteWrapper g = new WriteWrapper(graph);
\r
340 //Collection<GenerationRule> usedRules = new ArrayList<GenerationRule>();
\r
341 for (int stage = 0; stage <= maxGenPass; stage++) {
\r
343 for (GraphNode<Identifiable> n : nodes) {
\r
345 MapList<Integer,GenerationRule> priRules = n.getHint(MappingHints.KEY_GENERATION_RULES);
\r
346 List<GenerationRule> rules = priRules.getValues(stage);
\r
347 for (GenerationRule r : rules) {
\r
348 r.generate(graph, n);
\r
351 monitor.subTask("Generating objects, stage " + stage + " : ("+ (++count) + "/" + size + ")");
\r
352 if(monitor.isCanceled()) {
\r
353 throw new CancelException("Cancel requested.");
\r
355 if (COLLECT_WITHIN_TRANSACTIONS)
\r
361 private void applyConnections(WriteGraph g, Collection<GraphNode<Identifiable>> nodes, IProgressMonitor monitor) throws Exception {
\r
362 int size = nodes.size();
\r
365 monitor.subTask("Generating connections ("+ count + "/" + size + ")");
\r
367 for (GraphNode<Identifiable> node : nodes) {
\r
368 applyConnections(g, node);
\r
369 monitor.subTask("Generating connections ("+ (++count) + "/" + size + ")");
\r
370 if(monitor.isCanceled()) {
\r
371 throw new CancelException("Cancel requested.");
\r
373 if (COLLECT_WITHIN_TRANSACTIONS)
\r
380 protected String getName(ReadGraph g, Identifiable res) throws DatabaseException {
\r
381 if (res instanceof ResourceIdentifiable)
\r
382 return NameUtils.getSafeName(g, ((ResourceIdentifiable)res).getResource());
\r
384 return res.toString();
\r
387 public class WriteWrapper extends WriteGraphProxy {
\r
390 private Collection<Resource> createdResources = new ArrayList<Resource>();
\r
392 public WriteWrapper(WriteGraph graph) {
\r
396 public Collection<Resource> getCreatedResources() {
\r
397 return createdResources;
\r
400 public void clearCreated() {
\r
401 createdResources = new ArrayList<Resource>();
\r
405 public Resource newResource() throws ServiceException {
\r
406 Resource res = graph.newResource();
\r
407 createdResources.add(res);
\r
412 public Resource newResource(long clusterId) throws ServiceException {
\r
413 Resource res = graph.newResource(clusterId);
\r
414 createdResources.add(res);
\r
421 private void initializeRules(Session session, VirtualGraph vg, final Resource model ) throws DatabaseException{
\r
422 session.syncRequest(new WriteRequest(vg) {
\r
424 public void perform(WriteGraph g) throws DatabaseException {
\r
425 for (InitializedRule rule : initializedRules)
\r
426 rule.initialize(g, model);
\r
433 private void collect(ReadGraph g) throws DatabaseException {
\r
436 SessionGarbageCollection.gc(g, 0, -1);
\r
441 private void collect2(ReadGraph g) throws DatabaseException {
\r
445 if (collect == OBJECTS_BEFORE_COLLECT) {
\r
446 SessionGarbageCollection.gc(g, 0, -1);
\r
453 private void applyModifications(Session session, final Collection<GraphNode<Identifiable>> nodes, final IProgressMonitor monitor) throws Exception {
\r
457 int passCount = Math.max(globalModificationRules.size(),modificationRules.size());
\r
459 for (int pass = 0; pass <passCount; pass++) {
\r
460 // Apply global modification rules first
\r
461 if (globalModificationRules.size() > pass) {
\r
463 List<ModificationRule> modRules = globalModificationRules.get(pass);
\r
464 int size = modRules.size();
\r
465 monitor.subTask("Running global modification rules: pass (" + (pass+1) + "/" + passCount + "), rule ("+ (++count) + "/" + size + ")");
\r
466 for (final ModificationRule r : modRules) {
\r
467 session.syncRequest(new ReadRequest() {
\r
470 public void run(ReadGraph g) throws DatabaseException {
\r
472 Collection<GraphNode<Identifiable>> ruleModified = r.modify(g, nodes);
\r
474 if (ruleModified == null)
\r
476 for (GraphNode<Identifiable> m : ruleModified) {
\r
477 if (m.isDisposed()) {
\r
480 else if (!nodes.contains(m)) {
\r
484 if (COLLECT_WITHIN_TRANSACTIONS)
\r
486 } catch (Exception e) {
\r
487 throw new DatabaseException(e);
\r
492 //SessionGarbageCollection.gc(null, session, true, null);
\r
493 monitor.subTask("Running global modification rules: pass (" + (pass+1) + "/" + passCount + "), rule ("+ (++count) + "/" + size + ")");
\r
494 if(monitor.isCanceled()) {
\r
495 throw new CancelException("Cancel requested.");
\r
499 if (modificationRules.size() > pass) {
\r
501 List<Pair<IdentificationRule, ModificationRule>> modRules = modificationRules.get(pass);
\r
502 int size = modRules.size();
\r
503 monitor.subTask("Running object modification rules: pass (" + (pass+1) + "/" + passCount + "), rule ("+ (++count) + "/" + size + ")");
\r
505 // Apply per object modification rules
\r
506 for (final Pair<IdentificationRule, ModificationRule> modRule : modRules) {
\r
507 final Iterator<GraphNode<Identifiable>> iter = nodes.iterator();
\r
508 final Collection<GraphNode<Identifiable>> ruleModified = new ArrayList<GraphNode<Identifiable>>();
\r
509 while (iter.hasNext()) {
\r
510 session.syncRequest(new ReadRequest() {
\r
513 public void run(ReadGraph g) throws DatabaseException {
\r
517 //for (GraphNode<Identifiable> n : nodes) {
\r
518 while (iter.hasNext() && j < OBJECTS_PER_TRANSACTION) {
\r
519 GraphNode<Identifiable> n = iter.next();
\r
520 applyModifications(g, n, modRule, ruleModified);
\r
523 if (COLLECT_WITHIN_TRANSACTIONS)
\r
526 } catch (Exception e) {
\r
527 throw new DatabaseException(e);
\r
533 for (GraphNode<Identifiable> m : ruleModified) {
\r
534 if (m.isDisposed()) {
\r
537 else if (!nodes.contains(m)) {
\r
541 ruleModified.clear();
\r
543 //SessionGarbageCollection.gc(null, session, true, null);
\r
544 monitor.subTask("Running object modification rules: pass (" + (pass+1) + "/" + passCount + "), rule ("+ (++count) + "/" + size + ")");
\r
545 if(monitor.isCanceled()) {
\r
546 throw new CancelException("Cancel requested.");
\r
554 private void applyModifications2(Session session, final Collection<GraphNode<Identifiable>> nodes, final IProgressMonitor monitor) throws Exception {
\r
555 session.syncRequest(new ReadRequest() {
\r
558 public void run(ReadGraph g) throws DatabaseException {
\r
560 applyModifications(g, nodes, monitor);
\r
561 } catch (Exception e) {
\r
562 throw new DatabaseException(e);
\r
569 private void applyGenerations(Session session, VirtualGraph vg, Collection<GraphNode<Identifiable>> nodes, IProgressMonitor monitor) throws Exception {
\r
571 int size = nodes.size();
\r
573 monitor.subTask("Assigning generation rules ("+ count + "/" + size + ")");
\r
574 // populate generation rules
\r
577 final Iterator<GraphNode<Identifiable>> iter = nodes.iterator();
\r
578 while (iter.hasNext()) {
\r
579 int c = session.syncRequest(new Read<Integer>() {
\r
582 public Integer perform(ReadGraph graph)
\r
583 throws DatabaseException {
\r
585 while (iter.hasNext() && j < OBJECTS_PER_TRANSACTION) {
\r
586 GraphNode<Identifiable> n = iter.next();
\r
587 for (Pair<IdentificationRule,Pair<Integer,GenerationRule>> r : generationRules) {
\r
588 if (r.first.matches(graph, n)) {
\r
589 MapList<Integer,GenerationRule> rules = n.getHint(MappingHints.KEY_GENERATION_RULES);
\r
590 if (rules == null) {
\r
591 rules = new MapList<Integer,GenerationRule>();
\r
593 rules.add(r.second.first,r.second.second);
\r
594 n.setHint(MappingHints.KEY_GENERATION_RULES, rules);
\r
599 if (COLLECT_WITHIN_TRANSACTIONS)
\r
606 monitor.subTask("Assigning generation rules ("+ (count+=c) + "/" + size + ")");
\r
607 if(monitor.isCanceled()) {
\r
608 throw new CancelException("Cancel requested.");
\r
615 monitor.subTask("Generating objects ("+ (count) + "/" + size + ")");
\r
617 // apply generation rules.
\r
620 for (int stage = 0; stage <= maxGenPass; stage++) {
\r
621 final int fStage = stage;
\r
623 final Iterator<GraphNode<Identifiable>> iter = nodes.iterator();
\r
624 while (iter.hasNext()) {
\r
625 int c = session.syncRequest(new WriteResultRequest<Integer>(vg) {
\r
628 public Integer perform(WriteGraph graph) throws DatabaseException {
\r
631 while (iter.hasNext() && j < OBJECTS_PER_TRANSACTION) {
\r
632 GraphNode<Identifiable> n = iter.next();
\r
634 MapList<Integer,GenerationRule> priRules = n.getHint(MappingHints.KEY_GENERATION_RULES);
\r
635 if (priRules == null) {
\r
639 final List<GenerationRule> rules = priRules.getValues(fStage);
\r
641 if (fStage == 0 && rules.size() == 0)
\r
642 System.out.println();
\r
643 for (GenerationRule r : rules) {
\r
644 r.generate(graph, n);
\r
652 if (COLLECT_WITHIN_TRANSACTIONS)
\r
656 } catch (Exception e) {
\r
657 throw new DatabaseException(e);
\r
661 monitor.subTask("Generating objects, stage " + stage + " : ("+ (count+=c) + "/" + size + ")");
\r
662 if(monitor.isCanceled()) {
\r
663 throw new CancelException("Cancel requested.");
\r
671 private void applyGenerations2(Session session, VirtualGraph vg, final Collection<GraphNode<Identifiable>> nodes, final IProgressMonitor monitor) throws Exception {
\r
672 session.syncRequest(new WriteRequest(vg) {
\r
675 public void perform(WriteGraph graph) throws DatabaseException {
\r
677 applyGenerations(graph, nodes, monitor);
\r
678 } catch (Exception e) {
\r
679 throw new DatabaseException(e);
\r
686 private void collect(Session session) {
\r
687 if (COLLECT_BETWEEN_WRITES)
\r
688 SessionGarbageCollection.gc(null, session, true, null);
\r
692 private void sleep() {
\r
693 if (SLEEP_BETWEEN_WRITES) {
\r
695 Thread.sleep(SLEEP_TIME);
\r
696 } catch (InterruptedException e) {
\r
702 private void applyConnections(Session session, VirtualGraph vg, Collection<GraphNode<Identifiable>> nodes, IProgressMonitor monitor) throws Exception {
\r
703 int size = nodes.size();
\r
706 monitor.subTask("Generating connections ("+ count + "/" + size + ")");
\r
708 final Iterator<GraphNode<Identifiable>> iter = nodes.iterator();
\r
709 while (iter.hasNext()) {
\r
710 int c = session.syncRequest(new WriteResultRequest<Integer>(vg) {
\r
713 public Integer perform(WriteGraph g) throws DatabaseException {
\r
716 while (iter.hasNext() && j < OBJECTS_PER_TRANSACTION) {
\r
717 GraphNode<Identifiable> node = iter.next();
\r
718 applyConnections(g, node);
\r
721 if (COLLECT_WITHIN_TRANSACTIONS)
\r
725 } catch (Exception e) {
\r
726 throw new DatabaseException(e);
\r
731 monitor.subTask("Generating connections ("+ (count+=c) + "/" + size + ")");
\r
732 if(monitor.isCanceled()) {
\r
733 throw new CancelException("Cancel requested.");
\r
739 private void applyConnections2(Session session, VirtualGraph vg, final Collection<GraphNode<Identifiable>> nodes, final IProgressMonitor monitor) throws Exception {
\r
740 session.syncRequest(new WriteRequest(vg) {
\r
743 public void perform(WriteGraph graph) throws DatabaseException {
\r
745 applyConnections(graph, nodes, monitor);
\r
746 } catch (Exception e) {
\r
747 throw new DatabaseException(e);
\r
754 private void applyModifications(ReadGraph g, GraphNode<Identifiable> n, Pair<IdentificationRule, ModificationRule> modRule, Collection<GraphNode<Identifiable>> ruleModified) throws Exception {
\r
755 if (!n.isDisposed() && modRule.first.matches(g, n)) { // we have to check
\r
756 Collection<GraphNode<Identifiable>> perRule = new ArrayList<GraphNode<Identifiable>>();
\r
758 ruleModified.addAll(modRule.second.modify(g, perRule));
\r
762 private void applyConnections(WriteGraph g, GraphNode<Identifiable> node) throws Exception {
\r
763 for (Link<Identifiable> link : node.getLinks()) {
\r
764 if (link.isMain()) {
\r
766 for (Pair<ConnectionIdentificationRule, ConnectionGenerationRule> r : connectionRules) {
\r
767 if (r.first.mathces(g, node, link.to(), link)) {
\r
768 Logger.defaultLogInfo("Connecting " + getName(g, node.getData()) + " to " + getName(g, link.to().getData()) + " " + link.getName() + "/"+link.getInverseName());
\r
769 r.second.generate(g, node, link.to(), link);
\r