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

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