gerrit.simantics Code Review - simantics/platform.git/blob

   1 /*******************************************************************************\r
   2  * Copyright (c) 2007, 2012 Association for Decentralized Information Management in\r
   3  * Industry THTH ry.\r
   4  * All rights reserved. This program and the accompanying materials\r
   5  * are made available under the terms of the Eclipse Public License v1.0\r
   6  * which accompanies this distribution, and is available at\r
   7  * http://www.eclipse.org/legal/epl-v10.html\r
   8  *\r
   9  * Contributors:\r
  10  *     VTT Technical Research Centre of Finland - initial API and implementation\r
  11  *******************************************************************************/\r
  12 package org.simantics.modeling.typicals;\r
  13 \r
  14 import gnu.trove.map.hash.THashMap;\r
  15 import gnu.trove.set.hash.THashSet;\r
  16 \r
  17 import java.awt.geom.Point2D;\r
  18 import java.util.ArrayList;\r
  19 import java.util.Collection;\r
  20 import java.util.Collections;\r
  21 import java.util.Date;\r
  22 import java.util.HashMap;\r
  23 import java.util.HashSet;\r
  24 import java.util.Iterator;\r
  25 import java.util.List;\r
  26 import java.util.Map;\r
  27 import java.util.Set;\r
  28 \r
  29 import org.eclipse.core.runtime.IProgressMonitor;\r
  30 import org.simantics.Logger;\r
  31 import org.simantics.Simantics;\r
  32 import org.simantics.databoard.Bindings;\r
  33 import org.simantics.db.ReadGraph;\r
  34 import org.simantics.db.Resource;\r
  35 import org.simantics.db.Statement;\r
  36 import org.simantics.db.WriteGraph;\r
  37 import org.simantics.db.common.CommentMetadata;\r
  38 import org.simantics.db.common.NamedResource;\r
  39 import org.simantics.db.common.primitiverequest.Adapter;\r
  40 import org.simantics.db.common.procedure.adapter.TransientCacheListener;\r
  41 import org.simantics.db.common.request.ObjectsWithType;\r
  42 import org.simantics.db.common.request.PossibleIndexRoot;\r
  43 import org.simantics.db.common.request.WriteRequest;\r
  44 import org.simantics.db.common.uri.UnescapedChildMapOfResource;\r
  45 import org.simantics.db.common.utils.CommonDBUtils;\r
  46 import org.simantics.db.common.utils.NameUtils;\r
  47 import org.simantics.db.exception.DatabaseException;\r
  48 import org.simantics.db.layer0.adapter.Instances;\r
  49 import org.simantics.db.layer0.request.ActiveModels;\r
  50 import org.simantics.db.layer0.util.RemoverUtil;\r
  51 import org.simantics.diagram.content.ConnectionUtil;\r
  52 import org.simantics.diagram.handler.CopyPasteStrategy;\r
  53 import org.simantics.diagram.handler.ElementObjectAssortment;\r
  54 import org.simantics.diagram.handler.PasteOperation;\r
  55 import org.simantics.diagram.handler.Paster;\r
  56 import org.simantics.diagram.stubs.DiagramResource;\r
  57 import org.simantics.diagram.synchronization.CollectingModificationQueue;\r
  58 import org.simantics.diagram.synchronization.CopyAdvisor;\r
  59 import org.simantics.diagram.synchronization.SynchronizationHints;\r
  60 import org.simantics.diagram.synchronization.graph.GraphSynchronizationContext;\r
  61 import org.simantics.diagram.ui.DiagramModelHints;\r
  62 import org.simantics.document.DocumentResource;\r
  63 import org.simantics.g2d.canvas.ICanvasContext;\r
  64 import org.simantics.g2d.diagram.DiagramClass;\r
  65 import org.simantics.g2d.diagram.IDiagram;\r
  66 import org.simantics.g2d.diagram.impl.Diagram;\r
  67 import org.simantics.layer0.Layer0;\r
  68 import org.simantics.modeling.ModelingResources;\r
  69 import org.simantics.modeling.ModelingUtils;\r
  70 import org.simantics.modeling.mapping.ModelingSynchronizationHints;\r
  71 import org.simantics.modeling.typicals.rules.AuxKeys;\r
  72 import org.simantics.modeling.typicals.rules.FlagRule;\r
  73 import org.simantics.modeling.typicals.rules.InstanceOfRule;\r
  74 import org.simantics.modeling.typicals.rules.LabelRule;\r
  75 import org.simantics.modeling.typicals.rules.MonitorRule;\r
  76 import org.simantics.modeling.typicals.rules.NameRule;\r
  77 import org.simantics.modeling.typicals.rules.ProfileMonitorRule;\r
  78 import org.simantics.modeling.typicals.rules.SVGElementRule;\r
  79 import org.simantics.modeling.typicals.rules.TransformRule;\r
  80 import org.simantics.scenegraph.g2d.events.command.Commands;\r
  81 import org.simantics.scl.runtime.function.Function4;\r
  82 import org.simantics.structural.stubs.StructuralResource2;\r
  83 import org.simantics.utils.datastructures.MapSet;\r
  84 import org.simantics.utils.strings.AlphanumComparator;\r
  85 import org.simantics.utils.strings.EString;\r
  86 import org.simantics.utils.ui.ErrorLogger;\r
  87 \r
  88 /**\r
  89  * A write request that synchronizes typical master templates and their\r
  90  * instances as specified.\r
  91  * \r
  92  * <p>\r
  93  * Use {@link #SyncTypicalTemplatesToInstances(Resource[], MapSet)} to\r
  94  * synchronize all instances of specified templates. Use\r
  95  * {@link #syncSingleInstance(Resource)} to synchronize a single typical\r
  96  * instance with its master template.\r
  97  * \r
  98  * @author Tuukka Lehtonen\r
  99  * \r
 100  * @see ReadTypicalInfo\r
 101  * @see TypicalInfo\r
 102  * @see TypicalSynchronizationMetadata\r
 103  */\r
 104 public class SyncTypicalTemplatesToInstances extends WriteRequest {\r
 105 \r
 106     /**\r
 107      * A constant used as the second argument to\r
 108      * {@link #SyncTemplates(Resource[], MapSet)} for stating that all specified\r
 109      * templates should be fully synchronized to their instances.\r
 110      * \r
 111      * This is useful for forcing complete synchronization and unit testing. \r
 112      */\r
 113     public static final EmptyMapSet ALL = EmptyMapSet.INSTANCE;\r
 114 \r
 115     public static class EmptyMapSet extends MapSet<Resource, Resource> {\r
 116 \r
 117         public static final EmptyMapSet INSTANCE = new EmptyMapSet();\r
 118 \r
 119         public EmptyMapSet() {\r
 120             this.sets = Collections.emptyMap();\r
 121         }\r
 122 \r
 123         @Override\r
 124         protected Set<Resource> getOrCreateSet(Resource key) {\r
 125             throw new UnsupportedOperationException("immutable constant instance");\r
 126         }\r
 127 \r
 128     };\r
 129 \r
 130     protected static final boolean           DEBUG = false;\r
 131 \r
 132     // Input\r
 133 \r
 134     final private IProgressMonitor monitor;\r
 135     /**\r
 136      * Typical diagram rules to apply\r
 137      */\r
 138     protected Set<Resource>                                     selectedRules;\r
 139     \r
 140     /**\r
 141      * Typical diagram templates to synchronize with their instances.\r
 142      */\r
 143     protected Resource[]                     templates;\r
 144 \r
 145     /**\r
 146      * Typical diagram instances to synchronize with their templates.\r
 147      */\r
 148     protected Resource[]                     instances;\r
 149 \r
 150     /**\r
 151      * For each template diagram in {@link #templates}, shall contain a set of\r
 152      * elements that have changed and should be synchronized into the instance\r
 153      * diagrams. Provided as an argument by the client. Allows optimizing\r
 154      * real-time synchronization by not processing everything all the time.\r
 155      * \r
 156      * If the value is {@link #ALL}, all elements of the template shall be fully\r
 157      * synchronized.\r
 158      */\r
 159     protected MapSet<Resource, Resource>     changedElementsByDiagram;\r
 160 \r
 161     // Temporary data\r
 162 \r
 163     protected Layer0                         L0;\r
 164     protected StructuralResource2            STR;\r
 165     protected DiagramResource                DIA;\r
 166     protected ModelingResources              MOD;\r
 167 \r
 168     /**\r
 169      * Needed for using {@link Paster} in\r
 170      * {@link #addMissingElements(WriteGraph, TypicalInfo, Resource, Resource, Set)}\r
 171      */\r
 172     protected GraphSynchronizationContext    syncCtx;\r
 173 \r
 174     /**\r
 175      * For collecting commit metadata during the processing of this request.\r
 176      */\r
 177     protected TypicalSynchronizationMetadata metadata;\r
 178 \r
 179     /**\r
 180      * Necessary for using {@link CopyPasteStrategy} and {@link PasteOperation}\r
 181      * for now. Will be removed in the future once IDiagram is removed from\r
 182      * PasteOperation.\r
 183      */\r
 184     protected IDiagram                       temporaryDiagram;\r
 185 \r
 186     protected ConnectionUtil                 cu;\r
 187 \r
 188     /**\r
 189      * Maps source -> target connection route nodes, i.e. connectors and\r
 190      * interior route nodes (route lines). Inverse mapping of {@link #t2s}.\r
 191      */\r
 192     protected Map<Resource, Resource>        s2t;\r
 193 \r
 194     /**\r
 195      * Maps target -> source connection route nodes, i.e. connectors and\r
 196      * interior route nodes (route lines). Inverse mapping of {@link #s2t}.\r
 197      */\r
 198     protected Map<Resource, Resource>        t2s;\r
 199 \r
 200     /**\r
 201      * An auxiliary resource map for extracting the correspondences between\r
 202      * originals and copied resource when diagram contents are copied from\r
 203      * template to instance.\r
 204      */\r
 205     protected Map<Object, Object>            copyMap;\r
 206 \r
 207     final private Map<Resource, List<String>> messageLogs = new HashMap<Resource, List<String>>();\r
 208     \r
 209     public List<Resource> logs = new ArrayList<Resource>();\r
 210 \r
 211         private boolean writeLog;\r
 212 \r
 213     /**\r
 214      * @param templates typical diagram templates to completely synchronize with\r
 215      *        their instances\r
 216      */\r
 217     public SyncTypicalTemplatesToInstances(Set<Resource> selectedRules, Resource... templates) {\r
 218         this(selectedRules, templates, null, ALL, null);\r
 219     }\r
 220 \r
 221     /**\r
 222      * @param templates typical diagram templates to partially synchronize with\r
 223      *        their instances\r
 224      * @param changedElementsByDiagram see {@link #changedElementsByDiagram}\r
 225      */\r
 226     public SyncTypicalTemplatesToInstances(Set<Resource> selectedRules, Resource[] templates, MapSet<Resource, Resource> changedElementsByDiagram) {\r
 227         this(selectedRules, templates, null, changedElementsByDiagram, null);\r
 228     }\r
 229 \r
 230     /**\r
 231      * Return a write request that completely synchronizes the specified\r
 232      * instance diagram with its template.\r
 233      * \r
 234      * @param instance\r
 235      * @return\r
 236      */\r
 237     public static SyncTypicalTemplatesToInstances syncSingleInstance(Set<Resource> selectedRules, Resource instance) {\r
 238         return new SyncTypicalTemplatesToInstances(selectedRules, null, new Resource[] { instance }, ALL, null);\r
 239     }\r
 240 \r
 241     /**\r
 242      * @param templates typical diagram templates to synchronize with their instances\r
 243      * @param instances typical diagram instances to synchronize with their templates\r
 244      * @param changedElementsByDiagram see {@link #changedElementsByDiagram}\r
 245      */\r
 246     private SyncTypicalTemplatesToInstances(Set<Resource> selectedRules, Resource[] templates, Resource[] instances, MapSet<Resource, Resource> changedElementsByDiagram, IProgressMonitor monitor) {\r
 247         this.selectedRules = selectedRules;\r
 248         this.templates = templates;\r
 249         this.instances = instances;\r
 250         this.changedElementsByDiagram = changedElementsByDiagram;\r
 251         this.monitor = monitor;\r
 252     }\r
 253 \r
 254     public SyncTypicalTemplatesToInstances logging(boolean writeLog) {\r
 255         this.writeLog = writeLog;\r
 256         return this;\r
 257     }\r
 258 \r
 259     private Resource getDiagramNameResource(ReadGraph graph, Resource diagram) throws DatabaseException {\r
 260         Resource composite = graph.getPossibleObject(diagram, MOD.DiagramToComposite);\r
 261         if(composite != null) return composite;\r
 262         else return diagram;\r
 263     }\r
 264     \r
 265     private Resource getElementNameResource(ReadGraph graph, Resource element) throws DatabaseException {\r
 266         Resource corr = ModelingUtils.getPossibleElementCorrespondendence(graph, element);\r
 267         if(corr != null) return corr;\r
 268         else return element;\r
 269     }\r
 270     \r
 271     private List<String> getLog(ReadGraph graph, Resource diagram) throws DatabaseException {\r
 272         Resource indexRoot = graph.syncRequest(new PossibleIndexRoot(diagram));\r
 273         if(indexRoot == null) throw new DatabaseException("FATAL: Diagram is not under any index root.");\r
 274         List<String> log = messageLogs.get(indexRoot);\r
 275         if(log == null) {\r
 276                 log = new ArrayList<String>();\r
 277                 messageLogs.put(indexRoot, log);\r
 278         }\r
 279         return log;\r
 280     }\r
 281     \r
 282     private String elementName(ReadGraph graph, Resource element) throws DatabaseException {\r
 283         \r
 284         StringBuilder b = new StringBuilder();\r
 285         b.append(safeNameAndType(graph, element));\r
 286 \r
 287         int spaces = 60-b.length();\r
 288                 for(int i=0;i<spaces;i++) b.append(" ");\r
 289 \r
 290         Resource corr = ModelingUtils.getPossibleElementCorrespondendence(graph, element);\r
 291         if(corr != null) {\r
 292                 b.append(safeNameAndType(graph, corr));\r
 293         } else {\r
 294                 b.append("-");\r
 295         }\r
 296         \r
 297         return b.toString();\r
 298         \r
 299     }\r
 300 \r
 301     @Override\r
 302     public void perform(WriteGraph graph) throws DatabaseException {\r
 303         this.L0 = Layer0.getInstance(graph);\r
 304         this.STR = StructuralResource2.getInstance(graph);\r
 305         this.DIA = DiagramResource.getInstance(graph);\r
 306         this.MOD = ModelingResources.getInstance(graph);\r
 307 \r
 308         this.syncCtx = GraphSynchronizationContext.getWriteInstance( graph, new CollectingModificationQueue() );\r
 309         this.syncCtx.set(ModelingSynchronizationHints.MODELING_RESOURCE, ModelingResources.getInstance(graph));\r
 310 \r
 311         this.metadata = new TypicalSynchronizationMetadata();\r
 312         this.metadata.synchronizedTypicals = new ArrayList<Resource>();\r
 313 \r
 314         this.temporaryDiagram = Diagram.spawnNew(DiagramClass.DEFAULT);\r
 315         this.temporaryDiagram.setHint(SynchronizationHints.CONTEXT, syncCtx);\r
 316 \r
 317         this.cu = new ConnectionUtil(graph);\r
 318 \r
 319         if (templates != null) {\r
 320             // Look for typical template instances from the currently active models only.\r
 321             Collection<Resource> activeModels = graph.syncRequest(new ActiveModels(Simantics.getProjectResource()));\r
 322             if (!activeModels.isEmpty()) {\r
 323                 for (Resource template : templates) {\r
 324                     syncTemplate(graph, template, activeModels);\r
 325                 }\r
 326             }\r
 327         }\r
 328         if (instances != null) {\r
 329             for (Resource instance : instances) {\r
 330                 syncInstance(graph, instance);\r
 331             }\r
 332         }\r
 333 \r
 334         if (writeLog) {\r
 335             for(Map.Entry<Resource, List<String>> entry : messageLogs.entrySet()) {\r
 336 \r
 337                 Resource indexRoot = entry.getKey();\r
 338                 List<String> messageLog = entry.getValue();\r
 339 \r
 340                 Layer0 L0 = Layer0.getInstance(graph);\r
 341                 DocumentResource DOC = DocumentResource.getInstance(graph);\r
 342 \r
 343                 Collection<Resource> libs = graph.syncRequest(new ObjectsWithType(indexRoot, L0.ConsistsOf, DOC.DocumentLibrary));\r
 344                 if(libs.isEmpty()) continue;\r
 345 \r
 346                 List<NamedResource> nrs = new ArrayList<NamedResource>();\r
 347                 for(Resource lib : libs) nrs.add(new NamedResource(NameUtils.getSafeName(graph, lib), lib));\r
 348                 Collections.sort(nrs, AlphanumComparator.CASE_INSENSITIVE_COMPARATOR);\r
 349                 Resource library = nrs.iterator().next().getResource();\r
 350 \r
 351                 CommonDBUtils.selectClusterSet(graph, library);\r
 352 \r
 353                 String text = "--- Created: " + new Date().toString() + " ---\n";\r
 354                 text += EString.implode(messageLog);\r
 355 \r
 356                 Resource log = graph.newResource();\r
 357                 graph.claim(log, L0.InstanceOf, null, DOC.PlainTextDocument);\r
 358                 graph.claimLiteral(log, L0.HasName, L0.String, "Typical Sync " + new Date().toString());\r
 359                 graph.claim(library, L0.ConsistsOf, L0.PartOf, log);\r
 360                 graph.claimLiteral(log, DOC.PlainTextDocument_text, L0.String, text);\r
 361                 logs.add(log);\r
 362 \r
 363             }\r
 364         }\r
 365 \r
 366         if (!metadata.getTypicals().isEmpty()) {\r
 367             graph.addMetadata(metadata);\r
 368 \r
 369             // Add comment to change set.\r
 370             CommentMetadata cm = graph.getMetadata(CommentMetadata.class);\r
 371             graph.addMetadata( cm.add("Synchronized " + metadata.getTypicals().size() + " typical diagram instances (" + metadata.getTypicals() + ") with their templates.") );\r
 372         }\r
 373 \r
 374         temporaryDiagram = null;\r
 375         syncCtx = null;\r
 376     }\r
 377 \r
 378     private Collection<Resource> findInstances(ReadGraph graph, Resource ofType, Collection<Resource> indexRoots) throws DatabaseException {\r
 379         Instances index = graph.adapt(ofType, Instances.class);\r
 380         Set<Resource> instances = new HashSet<>();\r
 381         for (Resource indexRoot : indexRoots)\r
 382             instances.addAll( index.find(graph, indexRoot) );\r
 383         return instances;\r
 384     }\r
 385 \r
 386     private void syncTemplate(WriteGraph graph, Resource template, Collection<Resource> indexRoots) throws DatabaseException {\r
 387         Resource templateType = graph.getPossibleType(template, DIA.Diagram);\r
 388         if (templateType == null)\r
 389             return;\r
 390 \r
 391         Collection<Resource> instances = findInstances(graph, templateType, indexRoots);\r
 392         // Do not include the template itself as it is also an instance of templateType\r
 393         instances.remove(template);\r
 394         if (instances.isEmpty())\r
 395             return;\r
 396 \r
 397         Set<Resource> templateElements = new THashSet<Resource>( graph.syncRequest(\r
 398                 new ObjectsWithType(template, L0.ConsistsOf, DIA.Element) ) );\r
 399 \r
 400         try {\r
 401             for (Resource instance : instances) {\r
 402                 this.temporaryDiagram.setHint(DiagramModelHints.KEY_DIAGRAM_RESOURCE, instance);\r
 403                 syncInstance(graph, template, instance, templateElements);\r
 404             }\r
 405         } catch (Exception e) {\r
 406                 Logger.defaultLogError(e);\r
 407                 e.printStackTrace();\r
 408         } finally {\r
 409             this.temporaryDiagram.removeHint(DiagramModelHints.KEY_DIAGRAM_RESOURCE);\r
 410         }\r
 411     }\r
 412 \r
 413     private void syncInstance(WriteGraph graph, Resource instance) throws DatabaseException {\r
 414         Resource template = graph.getPossibleObject(instance, MOD.HasDiagramSource);\r
 415         if (template == null)\r
 416             return;\r
 417 \r
 418         Set<Resource> templateElements = new THashSet<Resource>( graph.syncRequest(\r
 419                 new ObjectsWithType(template, L0.ConsistsOf, DIA.Element) ) );\r
 420 \r
 421         try {\r
 422             this.temporaryDiagram.setHint(DiagramModelHints.KEY_DIAGRAM_RESOURCE, instance);\r
 423             syncInstance(graph, template, instance, templateElements);\r
 424         } finally {\r
 425             this.temporaryDiagram.removeHint(DiagramModelHints.KEY_DIAGRAM_RESOURCE);\r
 426         }\r
 427     }\r
 428     \r
 429     private Resource findInstanceCounterpart(ReadGraph graph, Resource instanceDiagram, Resource templateElement) throws DatabaseException {\r
 430         Map<String,Resource> children = graph.syncRequest(new UnescapedChildMapOfResource(instanceDiagram));\r
 431         for(Resource child : children.values()) {\r
 432                 if(graph.hasStatement(child, MOD.HasElementSource, templateElement)) return child;\r
 433         }\r
 434         return null;\r
 435     }\r
 436     \r
 437     private boolean isSynchronizedConnector(ReadGraph graph, Resource templateConnection, Resource instanceConnector) throws DatabaseException {\r
 438         DiagramResource DIA = DiagramResource.getInstance(graph);\r
 439         Resource instanceConnection = graph.getPossibleObject(instanceConnector, DIA.IsConnectorOf);\r
 440         return graph.hasStatement(instanceConnection, MOD.HasElementSource, templateConnection)\r
 441                         // If the master connection has been removed, this is all that's left\r
 442                         // to identify a connection that at least was originally synchronized\r
 443                         // from the typical master to this instance.\r
 444                         || graph.hasStatement(instanceConnection, MOD.IsTemplatized);\r
 445     }\r
 446 \r
 447     /**\r
 448      * Perform the following synchronization steps for the instance diagram:\r
 449      * <ol>\r
 450      * <li>remove such templatized elements from the instance diagram whose\r
 451      * template counterpart no longer exists</li>\r
 452      * <li>add elements to the instance diagram that are only in the template</li>\r
 453      * <li>synchronize elements of the instance diagram that have been deemed\r
 454      * changed</li>\r
 455      * </ol>\r
 456      * \r
 457      * @param graph database write access\r
 458      * @param template the synchronization source diagram\r
 459      * @param instance the synchronization target diagram\r
 460      * @param currentTemplateElements the set of all elements currently in the\r
 461      *        template diagram\r
 462      * @throws DatabaseException if anything goes wrong\r
 463      */\r
 464     private void syncInstance(WriteGraph graph, Resource template, Resource instance, Set<Resource> currentTemplateElements) throws DatabaseException {\r
 465 \r
 466         List<String> messageLog = getLog(graph, instance);\r
 467         \r
 468         messageLog.add("Synchronization of changed typical template: " + SyncTypicalTemplatesToInstances.safeNameAndType(graph, getDiagramNameResource(graph, template)));\r
 469         messageLog.add("----\n\ttypical instance: " + safeNameAndType(graph, getDiagramNameResource(graph, instance)));\r
 470 \r
 471         CommonDBUtils.selectClusterSet(graph, instance);\r
 472         \r
 473         // Form instance element <-> template element bijection\r
 474         TypicalInfoBean typicalInfoBean = graph.syncRequest(\r
 475                 new ReadTypicalInfo(instance),\r
 476                 TransientCacheListener.<TypicalInfoBean> instance());\r
 477         // Must be able to modify the typicalInfo structure,\r
 478         // therefore clone the query result.\r
 479         typicalInfoBean = (TypicalInfoBean) typicalInfoBean.clone();\r
 480         typicalInfoBean.templateElements = currentTemplateElements;\r
 481         typicalInfoBean.auxiliary = new HashMap<Object, Object>(1);\r
 482 \r
 483         TypicalInfo info = new TypicalInfo();\r
 484         info.monitor = monitor;\r
 485         info.messageLog = messageLog;\r
 486         info.bean = typicalInfoBean;\r
 487         \r
 488         // Resolve naming function for this typical instance.\r
 489         Resource compositeInstance = graph.getPossibleObject(instance, MOD.DiagramToComposite);\r
 490         if (compositeInstance != null) {\r
 491                 Function4<ReadGraph, Resource, Resource, String, String> namingFunction = TypicalUtil.getTypicalNamingFunction(graph, compositeInstance);\r
 492             if (namingFunction != null)\r
 493                 typicalInfoBean.auxiliary.put(AuxKeys.KEY_TYPICAL_NAMING_FUNCTION, namingFunction);\r
 494         }\r
 495 \r
 496         int dSizeAbs = Math.abs(typicalInfoBean.instanceElements.size() - currentTemplateElements.size());\r
 497 \r
 498         if(DEBUG)\r
 499                 System.out.println("typical <-> template mapping: " + typicalInfoBean.instanceToTemplate);\r
 500 \r
 501         // Find elements to be removed from instance by looking for all\r
 502         // instance elements that do not have a MOD.HasElementSource\r
 503         // relation but have a MOD.IsTemplatized tag.\r
 504         Set<Resource> instanceElementsRemovedFromTemplate = findInstanceElementsRemovedFromTemplate(\r
 505                 graph, info, new THashSet<Resource>(dSizeAbs));\r
 506 \r
 507         // Find elements in template that do not yet exist in the instance\r
 508         Set<Resource> templateElementsAddedToTemplate = findTemplateElementsMissingFromInstance(\r
 509                 graph, currentTemplateElements, info,\r
 510                 new THashSet<Resource>(dSizeAbs));\r
 511 \r
 512         Set<Resource> changedTemplateElements = changedElementsByDiagram.removeValues(template);\r
 513 \r
 514         if(DEBUG)\r
 515                 System.out.println("ADDED: " + templateElementsAddedToTemplate.size() + ", REMOVED: " + instanceElementsRemovedFromTemplate.size() + ", CHANGED: " + changedTemplateElements.size());\r
 516         \r
 517         // Validate\r
 518         for(Resource templateElement : graph.getObjects(template, L0.ConsistsOf)) {\r
 519                 if(graph.isInstanceOf(templateElement, DIA.RouteGraphConnection)) {\r
 520                         for(Resource connector : graph.getObjects(templateElement, DIA.HasConnector)) {\r
 521                                 for(Statement elementStm : graph.getStatements(connector, STR.Connects)) {\r
 522                                         Resource otherElement = elementStm.getObject(); \r
 523                                         if(!otherElement.equals(templateElement)) {\r
 524                                 Resource counterPartElement = findInstanceCounterpart(graph, instance, otherElement);\r
 525                                 if(counterPartElement != null) {\r
 526                                                 Resource diagramConnectionPoint = graph.getInverse(elementStm.getPredicate());\r
 527                                                 Resource connectionPoint = graph.getPossibleObject(diagramConnectionPoint, MOD.DiagramConnectionRelationToConnectionRelation);\r
 528                                                 if(connectionPoint != null) {\r
 529                                                         Statement stm = graph.getPossibleStatement(counterPartElement, diagramConnectionPoint);\r
 530                                         if(stm != null) {\r
 531                                                 if(graph.isInstanceOf(connectionPoint, L0.FunctionalRelation)) {\r
 532                                                         if(!isSynchronizedConnector(graph, templateElement, stm.getObject())) {\r
 533                                                                 messageLog.add("\t\tABORTED: tried to connect to an already connected terminal " + NameUtils.getSafeName(graph, counterPartElement) + " " + NameUtils.getSafeName(graph, connectionPoint));\r
 534                                                                 return;\r
 535                                                         }\r
 536                                                 }\r
 537                                                 }\r
 538                                                 }\r
 539                                 }\r
 540                                         }\r
 541                                 }\r
 542                         }\r
 543                 }\r
 544         }\r
 545         \r
 546         // Perform changes\r
 547         boolean changed = false;\r
 548         changed |= removeElements(graph, info, instanceElementsRemovedFromTemplate);\r
 549         changed |= addMissingElements(graph, info, template, instance, templateElementsAddedToTemplate);\r
 550         changed |= synchronizeChangedElements(graph, info, template, instance, changedTemplateElements, templateElementsAddedToTemplate, changedElementsByDiagram == ALL);\r
 551 \r
 552         if (changed)\r
 553             metadata.addTypical(instance);\r
 554     }\r
 555 \r
 556     /**\r
 557      * Add elements from template that do not yet exist in the instance.\r
 558      * \r
 559      * @param graph\r
 560      * @param template\r
 561      * @param instance\r
 562      * @param elementsAddedToTemplate\r
 563      * @return <code>true</code> if changes were made to the instance\r
 564      * @throws DatabaseException\r
 565      */\r
 566     private boolean addMissingElements(WriteGraph graph, TypicalInfo typicalInfo, Resource template,\r
 567             Resource instance, Set<Resource> elementsAddedToTemplate)\r
 568                     throws DatabaseException {\r
 569         if (elementsAddedToTemplate.isEmpty())\r
 570             return false;\r
 571 \r
 572         CopyAdvisor copyAdvisor = graph.syncRequest(new Adapter<CopyAdvisor>(instance, CopyAdvisor.class));\r
 573         this.temporaryDiagram.setHint(SynchronizationHints.COPY_ADVISOR, copyAdvisor);\r
 574 \r
 575         ElementObjectAssortment assortment = new ElementObjectAssortment(graph, elementsAddedToTemplate);\r
 576         if (copyMap == null)\r
 577             copyMap = new THashMap<Object, Object>();\r
 578         else\r
 579             copyMap.clear();\r
 580 \r
 581         if (DEBUG)\r
 582             System.out.println("ADD MISSING ELEMENTS: " + assortment);\r
 583 \r
 584         // initialCopyMap argument is needed for copying just connections\r
 585         // when their end-points are not copied at the same time.\r
 586 \r
 587         PasteOperation pasteOp = new PasteOperation(Commands.COPY,\r
 588                 (ICanvasContext) null, template, instance, temporaryDiagram,\r
 589                 assortment, false, new Point2D.Double(0, 0),\r
 590                 typicalInfo.bean.templateToInstance, copyMap)\r
 591         .options(PasteOperation.ForceCopyReferences.INSTANCE);\r
 592 \r
 593         new Paster(graph.getSession(), pasteOp).perform(graph);\r
 594 \r
 595         boolean changed = false;\r
 596 \r
 597         if(!elementsAddedToTemplate.isEmpty())\r
 598                 typicalInfo.messageLog.add("\tadded elements");\r
 599         \r
 600         for (Resource addedElement : elementsAddedToTemplate) {\r
 601             Resource copyElement = (Resource) copyMap.get(addedElement);\r
 602             if (copyElement != null) {\r
 603                 graph.claim(copyElement, MOD.IsTemplatized, MOD.IsTemplatized, copyElement);\r
 604                 graph.claim(copyElement, MOD.HasElementSource, MOD.ElementHasInstance, addedElement);\r
 605 \r
 606                 typicalInfo.bean.instanceElements.add(copyElement);\r
 607                 typicalInfo.bean.instanceToTemplate.put(copyElement, addedElement);\r
 608                 typicalInfo.bean.templateToInstance.put(addedElement, copyElement);\r
 609 \r
 610                 typicalInfo.messageLog.add("\t\t" + safeNameAndType(graph, copyElement));\r
 611 \r
 612                 changed = true;\r
 613             }\r
 614         }\r
 615 \r
 616         ModelingResources MOD = ModelingResources.getInstance(graph);\r
 617         Resource instanceComposite = graph.getPossibleObject(instance, MOD.DiagramToComposite);\r
 618         List<Resource> instanceComponents = new ArrayList<Resource>(elementsAddedToTemplate.size());\r
 619 \r
 620         // Post-process added elements after typicalInfo has been updated and\r
 621         // template mapping statements are in place.\r
 622         for (Resource addedElement : elementsAddedToTemplate) {\r
 623             Resource copyElement = (Resource) copyMap.get(addedElement);\r
 624             if (copyElement != null) {\r
 625                 postProcessAddedElement(graph, addedElement, copyElement, typicalInfo);\r
 626 \r
 627                 if (instanceComponents != null) {\r
 628                     // Gather all instance typical components for applying naming\r
 629                     // strategy on them.\r
 630                     Resource component = graph.getPossibleObject(copyElement, MOD.ElementToComponent);\r
 631                     if (component != null)\r
 632                         instanceComponents.add(component);\r
 633                 }\r
 634             }\r
 635         }\r
 636 \r
 637         if (instanceComposite != null)\r
 638             TypicalUtil.applySelectedModuleNames(graph, instanceComposite, instanceComponents);\r
 639 \r
 640         return changed;\r
 641     }\r
 642 \r
 643     private void postProcessAddedElement(WriteGraph graph,\r
 644             Resource addedTemplateElement, Resource addedInstanceElement,\r
 645             TypicalInfo typicalInfo) throws DatabaseException {\r
 646         if (graph.isInstanceOf(addedInstanceElement, DIA.Monitor)) {\r
 647             postProcessAddedMonitor(graph, addedTemplateElement, addedInstanceElement, typicalInfo);\r
 648         }\r
 649     }\r
 650 \r
 651     private void postProcessAddedMonitor(WriteGraph graph,\r
 652             Resource addedTemplateMonitor, Resource addedInstanceMonitor,\r
 653             TypicalInfo typicalInfo) throws DatabaseException {\r
 654         Resource monitor = addedInstanceMonitor;\r
 655         Resource monitoredComponent = graph.getPossibleObject(monitor, DIA.HasMonitorComponent);\r
 656         if (monitoredComponent != null) {\r
 657             Resource monitoredTemplateElement = graph.getPossibleObject(monitoredComponent, MOD.ComponentToElement);\r
 658             if (monitoredTemplateElement != null) {\r
 659                 Resource monitoredInstanceElement = typicalInfo.bean.templateToInstance.get(monitoredTemplateElement);\r
 660                 if (monitoredInstanceElement != null) {\r
 661                     Resource monitoredInstanceComponent = graph.getPossibleObject(monitoredInstanceElement, MOD.ElementToComponent);\r
 662                     if (monitoredInstanceComponent != null) {\r
 663                         // Ok, the monitor refers to a component within the\r
 664                         // template composite. Change it to refer to the\r
 665                         // instance composite.\r
 666                         graph.deny(monitor, DIA.HasMonitorComponent);\r
 667                         graph.claim(monitor, DIA.HasMonitorComponent, monitoredInstanceComponent);\r
 668                     }\r
 669                 }\r
 670             }\r
 671         }\r
 672     }\r
 673 \r
 674     private boolean removeElements(WriteGraph graph, TypicalInfo typicalInfo, Set<Resource> elementsRemovedFromTemplate) throws DatabaseException {\r
 675         if (elementsRemovedFromTemplate.isEmpty())\r
 676             return false;\r
 677 \r
 678         // Remove mapped elements from instance that are removed from the template.\r
 679         boolean changed = false;\r
 680         \r
 681         if(!elementsRemovedFromTemplate.isEmpty())\r
 682                 typicalInfo.messageLog.add("\tremoved elements");\r
 683         \r
 684         for (Resource removedElement : elementsRemovedFromTemplate) {\r
 685                 typicalInfo.messageLog.add("\t\t" + safeNameAndType(graph, removedElement));\r
 686 \r
 687             RemoverUtil.remove(graph, removedElement);\r
 688 \r
 689             typicalInfo.bean.instanceElements.remove(removedElement);\r
 690             Resource template = typicalInfo.bean.instanceToTemplate.remove(removedElement);\r
 691             if (template != null)\r
 692                 typicalInfo.bean.templateToInstance.remove(template);\r
 693 \r
 694             changed = true;\r
 695         }\r
 696         return changed;\r
 697     }\r
 698 \r
 699     private Set<Resource> findTemplateElementsMissingFromInstance(\r
 700             WriteGraph graph, Collection<Resource> currentTemplateElements,\r
 701             TypicalInfo typicalInfo, THashSet<Resource> result)\r
 702                   throws DatabaseException {\r
 703         for (Resource templateElement : currentTemplateElements) {\r
 704             Resource instanceElement = typicalInfo.bean.templateToInstance.get(templateElement);\r
 705             if (instanceElement == null) {\r
 706                 if(DEBUG)\r
 707                         System.out.println("No instance correspondence for template element " + NameUtils.getSafeName(graph, templateElement, true) + " => add");\r
 708                 result.add(templateElement);\r
 709             }\r
 710         }\r
 711         return result;\r
 712     }\r
 713 \r
 714     public Set<Resource> findInstanceElementsRemovedFromTemplate(\r
 715             ReadGraph graph, TypicalInfo typicalInfo,\r
 716             THashSet<Resource> result) throws DatabaseException {\r
 717         for (Resource instanceElement : typicalInfo.bean.instanceElements) {\r
 718             if (!typicalInfo.bean.instanceToTemplate.containsKey(instanceElement)) {\r
 719                 if (typicalInfo.bean.isTemplatized.contains(instanceElement)) {\r
 720                         if(DEBUG)\r
 721                                 System.out.println("Templatized typical instance element " + NameUtils.getSafeName(graph, instanceElement, true) + " has no correspondence in template => remove");\r
 722                     result.add(instanceElement);\r
 723                 }\r
 724             }\r
 725         }\r
 726         return result;\r
 727     }\r
 728 \r
 729     /**\r
 730      * Synchronize basic visual aspects of changed elements. For all elements,\r
 731      * transform and label are synchronized. Otherwise synchronization is\r
 732      * type-specific for connections, flags, monitors and svg elements.\r
 733      * \r
 734      * @param graph\r
 735      * @param typicalInfo\r
 736      * @param template\r
 737      * @param instance\r
 738      * @param changedTemplateElements\r
 739      * @param addedElements\r
 740      *            elements that have been added and thus need not be\r
 741      *            synchronized\r
 742      * @param synchronizeAllElements\r
 743      * @return\r
 744      * @throws DatabaseException\r
 745      */\r
 746     private boolean synchronizeChangedElements(WriteGraph graph,\r
 747             TypicalInfo typicalInfo, Resource template, Resource instance,\r
 748             Collection<Resource> changedTemplateElements,\r
 749             Set<Resource> addedElements,\r
 750             boolean synchronizeAllElements) throws DatabaseException {\r
 751 \r
 752         if (synchronizeAllElements) {\r
 753             // For unit testing purposes.\r
 754             changedTemplateElements = graph.syncRequest(new ObjectsWithType(template, L0.ConsistsOf, DIA.Element));\r
 755         }\r
 756 \r
 757         if (changedTemplateElements.isEmpty())\r
 758             return false;\r
 759 \r
 760         boolean changed = false;\r
 761 \r
 762         typicalInfo.messageLog.add("\telement change analysis");\r
 763         int analysisLogPosition = typicalInfo.messageLog.size();\r
 764 \r
 765         for (Resource changedTemplateElement : changedTemplateElements) {\r
 766             // Skip synchronization of elements that were just added and are\r
 767             // thus already synchronized.\r
 768             if (addedElements.contains(changedTemplateElement))\r
 769                 continue;\r
 770 \r
 771             Resource instanceElement = typicalInfo.bean.templateToInstance.get(changedTemplateElement);\r
 772             if (instanceElement == null) {\r
 773                 // There's an earlier problem in the sync process if this happens.\r
 774                 typicalInfo.messageLog.add("SKIPPING SYNC OF CHANGED TEMPLATE ELEMENT DUE TO MISSING INSTANCE: " + safeNameAndType(graph, getElementNameResource(graph, changedTemplateElement)));\r
 775                 continue;\r
 776             }\r
 777             \r
 778             typicalInfo.messageLog.add("\t\t" + elementName(graph, changedTemplateElement));\r
 779             int currentLogSize = typicalInfo.messageLog.size();\r
 780 \r
 781             changed |= InstanceOfRule.INSTANCE.synchronize(graph, changedTemplateElement, instanceElement, typicalInfo);\r
 782             changed |= NameRule.INSTANCE.synchronize(graph, changedTemplateElement, instanceElement, typicalInfo);\r
 783             changed |= TransformRule.INSTANCE.synchronize(graph, changedTemplateElement, instanceElement, typicalInfo);\r
 784             changed |= LabelRule.INSTANCE.synchronize(graph, changedTemplateElement, instanceElement, typicalInfo);\r
 785 \r
 786             Collection<Resource> types = graph.getTypes(changedTemplateElement);\r
 787             if (types.contains(DIA.RouteGraphConnection)) {\r
 788                 changed |= synchronizeConnection(graph, changedTemplateElement, instanceElement, typicalInfo);\r
 789             } else if (types.contains(DIA.Flag)) {\r
 790                 changed |= FlagRule.INSTANCE.synchronize(graph, changedTemplateElement, instanceElement, typicalInfo);\r
 791             } else if (types.contains(DIA.Monitor)) {\r
 792                 changed |= MonitorRule.INSTANCE.synchronize(graph, changedTemplateElement, instanceElement, typicalInfo);\r
 793             } else if (types.contains(DIA.SVGElement)) {\r
 794                 changed |= SVGElementRule.INSTANCE.synchronize(graph, changedTemplateElement, instanceElement, typicalInfo);\r
 795             }\r
 796 \r
 797             changed |= ProfileMonitorRule.INSTANCE.synchronize(graph, changedTemplateElement, instanceElement, typicalInfo);\r
 798             \r
 799             for (Resource rule : graph.getObjects(changedTemplateElement, MOD.HasTypicalSynchronizationRule)) {\r
 800                 if(selectedRules != null && !selectedRules.contains(rule)) continue;\r
 801                 ITypicalSynchronizationRule r = graph.getPossibleAdapter(rule, ITypicalSynchronizationRule.class);\r
 802                 if (r != null)\r
 803                     changed |= r.synchronize(graph, changedTemplateElement, instanceElement, typicalInfo);\r
 804             }\r
 805             \r
 806             // Show element only if something has happened\r
 807             if(currentLogSize == typicalInfo.messageLog.size())\r
 808                 typicalInfo.messageLog.remove(typicalInfo.messageLog.size()-1);\r
 809             \r
 810         }\r
 811 \r
 812         if (s2t != null)\r
 813             s2t.clear();\r
 814         if (t2s != null)\r
 815             t2s.clear();\r
 816 \r
 817         // Show analysis header only if something has happened\r
 818         if(analysisLogPosition == typicalInfo.messageLog.size())\r
 819                 typicalInfo.messageLog.remove(typicalInfo.messageLog.size()-1);\r
 820 \r
 821         return changed;\r
 822     }\r
 823 \r
 824     /**\r
 825      * Synchronizes two route graph connection topologies if and only if the\r
 826      * destination connection is not attached to any node elements besides\r
 827      * the ones that exist in the source. This means that connections that\r
 828      * have instance-specific connections to non-template nodes are ignored\r
 829      * here.\r
 830      * \r
 831      * @param graph\r
 832      * @param sourceConnection\r
 833      * @param targetConnection\r
 834      * @param typicalInfo\r
 835      * @return <code>true</code> if changes were made \r
 836      * @throws DatabaseException\r
 837      */\r
 838     private boolean synchronizeConnection(WriteGraph graph, Resource sourceConnection, Resource targetConnection, TypicalInfo typicalInfo)\r
 839             throws DatabaseException {\r
 840 \r
 841         if(DEBUG)\r
 842                 System.out.println("connection " + NameUtils.getSafeName(graph, sourceConnection, true) + " to target connection " + NameUtils.getSafeName(graph, targetConnection, true));\r
 843 \r
 844         boolean changed = false;\r
 845 \r
 846         // Initialize utilities and data maps\r
 847         s2t = newOrClear(s2t);\r
 848         t2s = newOrClear(t2s);\r
 849 \r
 850         if (cu == null)\r
 851             cu = new ConnectionUtil(graph);\r
 852 \r
 853         // 0.1. find mappings between source and target connection connectors\r
 854         Collection<Resource> targetConnectors = graph.getObjects(targetConnection, DIA.HasConnector);\r
 855         for (Resource targetConnector : targetConnectors) {\r
 856             Statement toNode = cu.getConnectedComponentStatement(targetConnection, targetConnector);\r
 857             if (toNode == null) {\r
 858                 // Corrupted target connection!\r
 859                 ErrorLogger.defaultLogError("Encountered corrupted typical template connection " + NameUtils.getSafeName(graph, targetConnection, true) + " with a stray DIA.Connector instance " + NameUtils.getSafeName(graph, targetConnector, true), new Exception("trace"));\r
 860                 return false;\r
 861             }\r
 862 \r
 863             // Check that the target connections does not connect to\r
 864             // non-templatized elements before syncing.\r
 865             if (!graph.hasStatement(toNode.getObject(), MOD.IsTemplatized))\r
 866                 return false;\r
 867 \r
 868             //Resource templateNode = typicalInfo.instanceToTemplate.get(toNode.getObject());\r
 869             Resource templateNode = graph.getPossibleObject(toNode.getObject(), MOD.HasElementSource);\r
 870             if (templateNode != null) {\r
 871                 Resource isConnectedTo = graph.getPossibleInverse(toNode.getPredicate());\r
 872                 if (isConnectedTo != null) {\r
 873                     Resource templateConnector = graph.getPossibleObject(templateNode, isConnectedTo);\r
 874                     if (templateConnector != null) {\r
 875                         Resource connectionOfTemplateConnector = ConnectionUtil.tryGetConnection(graph, templateConnector);\r
 876                         if (sourceConnection.equals(connectionOfTemplateConnector)) {\r
 877                             s2t.put(templateConnector, targetConnector);\r
 878                             t2s.put(targetConnector, templateConnector);\r
 879 \r
 880                             if (DEBUG)\r
 881                                 System.out.println("Mapping connector "\r
 882                                         + NameUtils.getSafeName(graph, templateConnector, true)\r
 883                                         + " to " + NameUtils.getSafeName(graph, targetConnector, true));\r
 884                         }\r
 885                     }\r
 886                 }\r
 887             }\r
 888         }\r
 889 \r
 890         // 0.2. find mapping between source and target route lines\r
 891         Collection<Resource> sourceInteriorRouteNodes = graph.getObjects(sourceConnection, DIA.HasInteriorRouteNode);\r
 892         Collection<Resource> targetInteriorRouteNodes = graph.getObjects(targetConnection, DIA.HasInteriorRouteNode);\r
 893         Map<Resource, Paster.RouteLine> sourceToRouteLine = new THashMap<Resource, Paster.RouteLine>();\r
 894         Map<Resource, Paster.RouteLine> targetToRouteLine = new THashMap<Resource, Paster.RouteLine>();\r
 895 \r
 896         for (Resource source : sourceInteriorRouteNodes)\r
 897             sourceToRouteLine.put(source, Paster.readRouteLine(graph, source));\r
 898         for (Resource target : targetInteriorRouteNodes)\r
 899             targetToRouteLine.put(target, Paster.readRouteLine(graph, target));\r
 900 \r
 901         nextSourceLine:\r
 902             for (Iterator<Map.Entry<Resource, Paster.RouteLine>> sourceIt = sourceToRouteLine.entrySet().iterator(); !targetToRouteLine.isEmpty() && sourceIt.hasNext();) {\r
 903                 Map.Entry<Resource, Paster.RouteLine> sourceEntry = sourceIt.next();\r
 904                 Paster.RouteLine sourceLine = sourceEntry.getValue();\r
 905                 for (Iterator<Map.Entry<Resource, Paster.RouteLine>> targetIt = targetToRouteLine.entrySet().iterator(); targetIt.hasNext();) {\r
 906                     Map.Entry<Resource, Paster.RouteLine> targetEntry = targetIt.next();\r
 907                     if (sourceLine.equals(targetEntry.getValue())) {\r
 908                         s2t.put(sourceEntry.getKey(), targetEntry.getKey());\r
 909                         t2s.put(targetEntry.getKey(), sourceEntry.getKey());\r
 910                         sourceIt.remove();\r
 911                         targetIt.remove();\r
 912 \r
 913                         if (DEBUG)\r
 914                             System.out.println("Mapping routeline "\r
 915                                     + NameUtils.getSafeName(graph, sourceEntry.getKey(), true)\r
 916                                     + " - " + sourceEntry.getValue()\r
 917                                     + " to " + NameUtils.getSafeName(graph, targetEntry.getKey(), true)\r
 918                                     + " - " + targetEntry.getValue());\r
 919 \r
 920                         continue nextSourceLine;\r
 921                     }\r
 922                 }\r
 923             }\r
 924 \r
 925         if (DEBUG) {\r
 926             System.out.println("Take 1: Source to target route nodes map : " + s2t);\r
 927             System.out.println("Take 1: Target to source route nodes map : " + t2s);\r
 928         }\r
 929 \r
 930         // 1.1 remove excess connectors\r
 931         for (Resource targetConnector : targetConnectors) {\r
 932             if (!t2s.containsKey(targetConnector)) {\r
 933                 typicalInfo.messageLog.add("\t\t\tremove excess connector from target connection: " + NameUtils.getSafeName(graph, targetConnector));\r
 934                 cu.removeConnectionPart(targetConnector);\r
 935                 changed = true;\r
 936             }\r
 937         }\r
 938 \r
 939         // 1.2 add missing connectors to target\r
 940         Collection<Resource> sourceConnectors = graph.getObjects(sourceConnection, DIA.HasConnector);\r
 941         for (Resource sourceConnector : sourceConnectors) {\r
 942             if (!s2t.containsKey(sourceConnector)) {\r
 943                 Statement sourceIsConnectorOf = graph.getSingleStatement(sourceConnector, DIA.IsConnectorOf);\r
 944                 Statement connects = cu.getConnectedComponentStatement(sourceConnection, sourceConnector);\r
 945                 if (connects == null) {\r
 946                     // TODO: serious error!\r
 947                     throw new DatabaseException("ERROR: connector is astray, i.e. not connected to a node element: " + safeNameAndType(graph, sourceConnector));\r
 948                 }\r
 949                 Resource connectsInstanceElement = typicalInfo.bean.templateToInstance.get(connects.getObject());\r
 950                 if (connectsInstanceElement == null) {\r
 951                     // TODO: serious error!\r
 952                     throw new DatabaseException("ERROR: could not find instance element to which template element " + safeNameAndType(graph, connects.getObject()) + " is connected to");\r
 953                 }\r
 954                 Resource hasConnector = graph.getInverse(sourceIsConnectorOf.getPredicate());\r
 955 \r
 956                 Resource newTargetConnector = cu.newConnector(targetConnection, hasConnector);\r
 957                 graph.claim(newTargetConnector, connects.getPredicate(), connectsInstanceElement);\r
 958                 changed = true;\r
 959 \r
 960                 s2t.put(sourceConnector, newTargetConnector);\r
 961                 t2s.put(newTargetConnector, sourceConnector);\r
 962 \r
 963                 typicalInfo.messageLog.add("\t\t\tadd new connector to target connection: " + NameUtils.getSafeName(graph, newTargetConnector) + " to map to source connector " + NameUtils.getSafeName(graph, sourceConnector));\r
 964             }\r
 965         }\r
 966 \r
 967         // 2. sync route lines and their connectivity:\r
 968         // 2.1. assign correspondences in target for each source route line\r
 969         //      by reusing excess routelines in target and by creating new\r
 970         //      route lines.\r
 971 \r
 972         Resource[] targetRouteLines = targetToRouteLine.keySet().toArray(Resource.NONE);\r
 973         int targetRouteLine = targetRouteLines.length - 1;\r
 974 \r
 975         for (Iterator<Map.Entry<Resource, Paster.RouteLine>> sourceIt = sourceToRouteLine.entrySet().iterator(); sourceIt.hasNext();) {\r
 976             Map.Entry<Resource, Paster.RouteLine> sourceEntry = sourceIt.next();\r
 977             Resource source = sourceEntry.getKey();\r
 978             Paster.RouteLine sourceLine = sourceEntry.getValue();\r
 979 \r
 980             typicalInfo.messageLog.add("\t\t\tassign an instance-side routeline complement for " + NameUtils.getSafeName(graph, source, true) + " - " + sourceLine);\r
 981 \r
 982             // Assign target route line for source\r
 983             Resource target = null;\r
 984             if (targetRouteLine < 0) {\r
 985                 // by creating new route lines\r
 986                 target = cu.newRouteLine(targetConnection, sourceLine.getPosition(), sourceLine.isHorizontal());\r
 987                 typicalInfo.messageLog.add("\t\t\tcreate new route line " + NameUtils.getSafeName(graph, target));\r
 988                 changed = true;\r
 989             } else {\r
 990                 // by reusing existing route line\r
 991                 target = targetRouteLines[targetRouteLine--];\r
 992                 copyRouteLine(graph, source, target);\r
 993                 cu.disconnectFromAllRouteNodes(target);\r
 994                 typicalInfo.messageLog.add("\t\t\treused existing route line " + NameUtils.getSafeName(graph, target));\r
 995                 changed = true;\r
 996             }\r
 997             s2t.put(source, target);\r
 998             t2s.put(target, source);\r
 999 \r
1000             typicalInfo.messageLog.add("\t\t\tmapped source route line " + NameUtils.getSafeName(graph, source) + " to target route line " + NameUtils.getSafeName(graph, target));\r
1001         }\r
1002 \r
1003         if (targetRouteLine >= 0) {\r
1004                 typicalInfo.messageLog.add("\t\t\tremove excess route lines (" + (targetRouteLine + 1) + ") from target connection");\r
1005             for (; targetRouteLine >= 0; targetRouteLine--) {\r
1006                 typicalInfo.messageLog.add("\t\t\t\tremove excess route line: " + NameUtils.getSafeName(graph, targetRouteLines[targetRouteLine], true));\r
1007                 cu.removeConnectionPart(targetRouteLines[targetRouteLine]);\r
1008             }\r
1009         }\r
1010 \r
1011         if (DEBUG) {\r
1012             System.out.println("Take 2: Source to target route nodes map : " + s2t);\r
1013             System.out.println("Take 2: Target to source route nodes map : " + t2s);\r
1014         }\r
1015 \r
1016         // 2.2. Synchronize target connection topology (DIA.AreConnected)\r
1017         changed |= connectRouteNodes(graph, typicalInfo, sourceInteriorRouteNodes);\r
1018         changed |= connectRouteNodes(graph, typicalInfo, sourceConnectors);\r
1019 \r
1020         // 3. remove excess routelines & connectors from target connection\r
1021         changed |= cu.removeExtraInteriorRouteNodes(targetConnection) > 0;\r
1022         changed |= cu.removeUnusedConnectors(targetConnection) > 0;\r
1023 \r
1024         return changed;\r
1025     }\r
1026 \r
1027     private boolean connectRouteNodes(WriteGraph graph, TypicalInfo typicalInfo, Collection<Resource> sourceRouteNodes) throws DatabaseException {\r
1028         boolean changed = false;\r
1029         for (Resource src : sourceRouteNodes) {\r
1030             Resource dst = s2t.get(src);\r
1031             if (dst == null) {\r
1032                 throw new DatabaseException("TARGET ROUTE NODE == NULL FOR SRC: " + NameUtils.getSafeName(graph, src));\r
1033             }\r
1034 \r
1035             Collection<Resource> connectedToSrcs = graph.getObjects(src, DIA.AreConnected);\r
1036             Collection<Resource> connectedToDsts = graph.getObjects(dst, DIA.AreConnected);\r
1037 \r
1038             // Remove excess statements\r
1039             for (Resource connectedToDst : connectedToDsts) {\r
1040                 Resource connectedToSrc = t2s.get(connectedToDst);\r
1041                 if (connectedToSrc == null) {\r
1042                     throw new DatabaseException("CONNECTED TO SRC == NULL FOR DST: " + NameUtils.getSafeName(graph, connectedToDst));\r
1043                 }\r
1044                 if (connectedToSrc == null || !graph.hasStatement(src, DIA.AreConnected, connectedToSrc)) {\r
1045                     graph.deny(dst, DIA.AreConnected, DIA.AreConnected, connectedToDst);\r
1046                     changed = true;\r
1047                     typicalInfo.messageLog.add("\t\t\tdisconnected route nodes (" + NameUtils.getSafeName(graph, dst) + ", " + NameUtils.getSafeName(graph, connectedToDst) + ")");\r
1048                 }\r
1049             }\r
1050 \r
1051             // Add necessary statements\r
1052             for (Resource connectedToSrc : connectedToSrcs) {\r
1053                 Resource connectedToDst = s2t.get(connectedToSrc);\r
1054                 if (connectedToDst == null) {\r
1055                     throw new DatabaseException("CONNECTED TO DST == NULL FOR SRC: " + NameUtils.getSafeName(graph, connectedToSrc));\r
1056                 }\r
1057                 if (!graph.hasStatement(dst, DIA.AreConnected, connectedToDst)) {\r
1058                     graph.claim(dst, DIA.AreConnected, DIA.AreConnected, connectedToDst);\r
1059                     changed = true;\r
1060                     typicalInfo.messageLog.add("\t\t\tconnected route nodes (" + NameUtils.getSafeName(graph, dst) + ", " + NameUtils.getSafeName(graph, connectedToDst) + ")");\r
1061                 }\r
1062             }\r
1063         }\r
1064         return changed;\r
1065     }\r
1066 \r
1067     private void copyRouteLine(WriteGraph graph, Resource src, Resource tgt) throws DatabaseException {\r
1068         Double pos = graph.getPossibleRelatedValue(src, DIA.HasPosition, Bindings.DOUBLE);\r
1069         Boolean hor = graph.getPossibleRelatedValue(src, DIA.IsHorizontal, Bindings.BOOLEAN);\r
1070         if (pos == null)\r
1071             pos = 0.0;\r
1072         if (hor == null)\r
1073             hor = Boolean.TRUE;\r
1074         graph.claimLiteral(tgt, DIA.HasPosition, L0.Double, pos, Bindings.DOUBLE);\r
1075         graph.claimLiteral(tgt, DIA.IsHorizontal, L0.Boolean, hor, Bindings.BOOLEAN);\r
1076     }\r
1077 \r
1078     private static String safeNameAndType(ReadGraph graph, Resource r) throws DatabaseException {\r
1079         StringBuilder sb = new StringBuilder();\r
1080         sb.append(NameUtils.getSafeName(graph, r, true));\r
1081         sb.append(" : [");\r
1082         boolean first = true;\r
1083         for (Resource type : graph.getPrincipalTypes(r)) {\r
1084             if (!first)\r
1085                 sb.append(",");\r
1086             first = false;\r
1087             sb.append(NameUtils.getSafeName(graph, type, true));\r
1088         }\r
1089         sb.append("]");\r
1090         return sb.toString();\r
1091     }\r
1092 \r
1093     private static <K, V> Map<K, V> newOrClear(Map<K, V> current) {\r
1094         if (current == null)\r
1095             return new THashMap<K, V>();\r
1096         current.clear();\r
1097         return current;\r
1098     }\r
1099 \r
1100 }