/*******************************************************************************
- * Copyright (c) 2007, 2010 Association for Decentralized Information Management
+ * Copyright (c) 2007, 2018 Association for Decentralized Information Management
* in Industry THTH ry.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
*******************************************************************************/
package org.simantics.diagram.adapter;
-import gnu.trove.map.hash.TObjectIntHashMap;
-import gnu.trove.set.hash.THashSet;
-
import java.awt.geom.AffineTransform;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayDeque;
import org.simantics.db.common.procedure.adapter.CacheListener;
import org.simantics.db.common.procedure.adapter.ListenerSupport;
import org.simantics.db.common.procedure.adapter.ProcedureAdapter;
+import org.simantics.db.common.procedure.adapter.TransientCacheAsyncListener;
import org.simantics.db.common.request.AsyncReadRequest;
import org.simantics.db.common.request.ReadRequest;
import org.simantics.db.common.session.SessionEventListenerAdapter;
import org.simantics.utils.threads.ThreadUtils;
import org.simantics.utils.threads.logger.ITask;
import org.simantics.utils.threads.logger.ThreadLogger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import gnu.trove.map.hash.TObjectIntHashMap;
+import gnu.trove.set.hash.THashSet;
/**
* This class loads a diagram contained in the graph database into the runtime
*/
public class GraphToDiagramSynchronizer extends AbstractDisposable implements IDiagramLoader, IModifiableSynchronizationContext {
+ private static final Logger LOGGER = LoggerFactory.getLogger(GraphToDiagramSynchronizer.class);
+
/**
* Controls whether the class adds hint listeners to each diagram element
* that try to perform basic sanity checks on changes happening in element
else
result.add(eh);
}
- return ElementClass.compile(result).setId(ec.getId());
+ return ElementClass.compile(result, false).setId(ec.getId());
}
}
}
} catch (InterruptedException e) {
// Shouldn't happen.
- e.printStackTrace();
+ LOGGER.error("Dispose interrupted!", e);
} finally {
detachSessionListener();
task4.finish();
// ITask task5 = ThreadLogger.getInstance().begin("DiagramContentRequest2");
ITask task42 = ThreadLogger.getInstance().begin("DiagramContentRequest2");
- DiagramContents contents = g.syncRequest(query);
+ DiagramContents contents = g.syncRequest(query, TransientCacheAsyncListener.instance());
+ //System.err.println("contents: " + contents);
task42.finish();
// task5.finish();
monitor.worked(10);
ArrayMap.keys(ProfileKeys.DIAGRAM, ProfileKeys.CANVAS, ProfileKeys.NODE_MAP).values(GraphToDiagramSynchronizer.this.diagram, canvas, dn),
new CanvasNotification(canvas));
- profileObserver.listen(g, GraphToDiagramSynchronizer.this);
+ g.getSession().asyncRequest(new AsyncReadRequest() {
+ @Override
+ public void run(AsyncReadGraph graph) {
+ ProfileObserver po = profileObserver;
+ if (po != null)
+ po.listen(graph, GraphToDiagramSynchronizer.this);
+ else
+ LOGGER.info("profileObserver has been disposed already!");
+ }
+ });
return d;
}
public void clear() {
- // Prevent DiagramContents leakage through DisposableListeners.
- lastContent = null;
- content = null;
- changes = null;
-
+ // Prevent DiagramContents leakage through DisposableListeners.
+ lastContent = null;
+ content = null;
+ changes = null;
+
this.addedElements.clear();
this.removedElements.clear();
this.addedConnectionSegments.clear();
this.removedRouteGraphConnections.clear();
}
- void processNodes(AsyncReadGraph graph) {
+ void processNodes(ReadGraph graph) throws DatabaseException {
for (Map.Entry<Resource, Change> entry : changes.elements.entrySet()) {
IElement mappedElement = getMappedElement(element);
if (mappedElement == null) {
if (DebugPolicy.DEBUG_NODE_LOAD)
- graph.asyncRequest(new ReadRequest() {
+ graph.syncRequest(new ReadRequest() {
@Override
public void run(ReadGraph graph) throws DatabaseException {
System.out.println(" EXTERNALLY ADDED ELEMENT: "
// TODO: Connection loading has no listening, changes :Connection will not be noticed by this code!
Listener<IElement> loadListener = new DisposableListener<IElement>(canvasListenerSupport) {
- @Override
- public String toString() {
- return "Connection load listener for " + element;
- }
+
+ boolean firstTime = true;
+
+ @Override
+ public String toString() {
+ return "Connection load listener for " + element;
+ }
@Override
public void execute(IElement loaded) {
// Invoked when the element has been loaded.
return;
}
+ if (firstTime) {
+
+ mapElement(element, loaded);
+ synchronized (GraphToDiagramUpdater.this) {
+ addedElements.add(loaded);
+ addedElementMap.put(element, loaded);
+ addedConnectionMap.put(element, loaded);
+ }
+
+ firstTime = false;
+
+ }
+
Object data = loaded.getHint(ElementHints.KEY_OBJECT);
// Logic for disposing listener
}
};
- graph.asyncRequest(new ConnectionRequest(canvas, diagram, element, errorHandler, loadListener), new AsyncProcedure<IElement>() {
+ graph.syncRequest(new ConnectionRequest(canvas, diagram, element, errorHandler, loadListener), new AsyncProcedure<IElement>() {
@Override
public void execute(AsyncReadGraph graph, final IElement e) {
- if (e == null)
- return;
-
- //System.out.println("ConnectionRequestProcedure " + e);
- mapElement(element, e);
- synchronized (GraphToDiagramUpdater.this) {
- addedElements.add(e);
- addedElementMap.put(element, e);
- addedConnectionMap.put(element, e);
- }
// Read connection type
graph.forSingleType(element, br.DIA.Connection, new Procedure<Resource>() {
}
}
});
+
}
@Override
} else if (content.nodeSet.contains(element)) {
Listener<IElement> loadListener = new DisposableListener<IElement>(canvasListenerSupport) {
- @Override
- public String toString() {
- return "Node load listener for " + element;
- }
+
+ boolean firstTime = true;
+
+ @Override
+ public String toString() {
+ return "Node load listener for " + element;
+ }
@Override
public void execute(IElement loaded) {
// Invoked when the element has been loaded.
return;
}
+ if (firstTime) {
+
+ // This is invoked before the element is actually loaded.
+ //System.out.println("NodeRequestProcedure " + e);
+ if (DebugPolicy.DEBUG_NODE_LOAD)
+ System.out.println("MAPPING ADDED NODE: " + element + " -> " + loaded);
+ mapElement(element, loaded);
+ synchronized (GraphToDiagramUpdater.this) {
+ addedElements.add(loaded);
+ addedElementMap.put(element, loaded);
+ }
+
+ firstTime = false;
+
+ }
+
Object data = loaded.getHint(ElementHints.KEY_OBJECT);
// Logic for disposing listener
};
//System.out.println("NODE REQUEST: " + element);
- graph.asyncRequest(new NodeRequest(canvas, diagram, element, loadListener), new AsyncProcedure<IElement>() {
+ graph.syncRequest(new NodeRequest(canvas, diagram, element, loadListener), new AsyncProcedure<IElement>() {
@Override
public void execute(AsyncReadGraph graph, IElement e) {
- if (e == null)
- return;
-
- // This is invoked before the element is actually loaded.
- //System.out.println("NodeRequestProcedure " + e);
- if (DebugPolicy.DEBUG_NODE_LOAD)
- System.out.println("MAPPING ADDED NODE: " + element + " -> " + e);
- mapElement(element, e);
- synchronized (GraphToDiagramUpdater.this) {
- addedElements.add(e);
- addedElementMap.put(element, e);
- }
}
@Override
case REMOVED: {
IElement e = getMappedElement(element);
if (DebugPolicy.DEBUG_NODE_LOAD)
- graph.asyncRequest(new ReadRequest() {
+ graph.syncRequest(new ReadRequest() {
@Override
public void run(ReadGraph graph) throws DatabaseException {
System.out.println(" EXTERNALLY REMOVED ELEMENT: "
}
break;
}
+ default:
}
}
}
}
break;
}
+ default:
}
}
}
case REMOVED: {
removedConnectionEntities.add(ce);
}
+ default:
}
}
}
}
- void processRouteGraphConnections(AsyncReadGraph graph) {
+ void processRouteGraphConnections(ReadGraph graph) throws DatabaseException {
for (Map.Entry<Resource, Change> entry : changes.routeGraphConnections.entrySet()) {
final Resource connection = entry.getKey();
continue;
Listener<IElement> loadListener = new DisposableListener<IElement>(canvasListenerSupport) {
- @Override
- public String toString() {
- return "processRouteGraphConnections " + connection;
- }
+
+ boolean firstTime = true;
+
+ @Override
+ public String toString() {
+ return "processRouteGraphConnections " + connection;
+ }
@Override
public void execute(IElement loaded) {
// Invoked when the element has been loaded.
return;
}
+ if(firstTime) {
+ if (DebugPolicy.DEBUG_NODE_LOAD)
+ System.out.println("MAPPING ADDED ROUTE GRAPH CONNECTION: " + connection + " -> " + loaded);
+ mapElement(connection, loaded);
+ synchronized (GraphToDiagramUpdater.this) {
+ addedElements.add(loaded);
+ addedElementMap.put(connection, loaded);
+ addedRouteGraphConnectionMap.put(connection, loaded);
+ }
+ firstTime = false;
+ }
+
Object data = loaded.getHint(ElementHints.KEY_OBJECT);
// Logic for disposing listener
}
};
- graph.asyncRequest(new ConnectionRequest(canvas, diagram, connection, errorHandler, loadListener), new Procedure<IElement>() {
+ graph.syncRequest(new ConnectionRequest(canvas, diagram, connection, errorHandler, loadListener), new Procedure<IElement>() {
@Override
public void execute(final IElement e) {
- if (e == null)
- return;
-
- //System.out.println("ConnectionRequestProcedure " + e);
- if (DebugPolicy.DEBUG_NODE_LOAD)
- System.out.println("MAPPING ADDED ROUTE GRAPH CONNECTION: " + connection + " -> " + e);
- mapElement(connection, e);
- synchronized (GraphToDiagramUpdater.this) {
- addedElements.add(e);
- addedElementMap.put(connection, e);
- addedRouteGraphConnectionMap.put(connection, e);
- }
}
@Override
public void exception(Throwable throwable) {
removedRouteGraphConnections.add(e);
break;
}
+ default:
}
}
}
return assertMappedConnection(connection);
}
- void processBranchPoints(AsyncReadGraph graph) {
+ void processBranchPoints(ReadGraph graph) throws DatabaseException {
for (Map.Entry<Resource, Change> entry : changes.branchPoints.entrySet()) {
final Resource element = entry.getKey();
IElement mappedElement = getMappedElement(element);
if (mappedElement == null) {
if (DebugPolicy.DEBUG_NODE_LOAD)
- graph.asyncRequest(new ReadRequest() {
+ graph.syncRequest(new ReadRequest() {
@Override
public void run(ReadGraph graph) throws DatabaseException {
System.out.println(" EXTERNALLY ADDED BRANCH POINT: "
});
Listener<IElement> loadListener = new DisposableListener<IElement>(canvasListenerSupport) {
- @Override
- public String toString() {
- return "processBranchPoints for " + element;
- }
+
+ boolean firstTime = true;
+
+ @Override
+ public String toString() {
+ return "processBranchPoints for " + element;
+ }
@Override
public void execute(IElement loaded) {
// Invoked when the element has been loaded.
return;
}
+ if (firstTime) {
+
+ mapElement(element, loaded);
+ synchronized (GraphToDiagramUpdater.this) {
+ addedBranchPoints.add(loaded);
+ addedElementMap.put(element, loaded);
+ ConnectionEntityImpl ce = getConnectionEntity(element);
+ loaded.setHint(ElementHints.KEY_CONNECTION_ENTITY, ce);
+ loaded.setHint(ElementHints.KEY_PARENT_ELEMENT, ce.getConnectionElement());
+ }
+
+ firstTime = false;
+
+ }
+
Object data = loaded.getHint(ElementHints.KEY_OBJECT);
if (addedElementMap.containsKey(data)) {
// This element was just loaded, in
}
};
- graph.asyncRequest(new NodeRequest(canvas, diagram, element, loadListener), new AsyncProcedure<IElement>() {
+ graph.syncRequest(new NodeRequest(canvas, diagram, element, loadListener), new AsyncProcedure<IElement>() {
@Override
public void execute(AsyncReadGraph graph, IElement e) {
- if (e != null) {
- mapElement(element, e);
- synchronized (GraphToDiagramUpdater.this) {
- addedBranchPoints.add(e);
- addedElementMap.put(element, e);
- ConnectionEntityImpl ce = getConnectionEntity(element);
- e.setHint(ElementHints.KEY_CONNECTION_ENTITY, ce);
- e.setHint(ElementHints.KEY_PARENT_ELEMENT, ce.getConnectionElement());
- }
- }
}
@Override
case REMOVED: {
IElement e = getMappedElement(element);
if (DebugPolicy.DEBUG_NODE_LOAD)
- graph.asyncRequest(new ReadRequest() {
+ graph.syncRequest(new ReadRequest() {
@Override
public void run(ReadGraph graph) throws DatabaseException {
System.out.println(" EXTERNALLY REMOVED BRANCH POINT: "
}
break;
}
+ default:
}
}
}
- void processConnectionSegments(AsyncReadGraph graph) {
+ void processConnectionSegments(ReadGraph graph) throws DatabaseException {
ConnectionSegmentAdapter adapter = connectionSegmentAdapter;
for (Map.Entry<EdgeResource, Change> entry : changes.connectionSegments.entrySet()) {
IElement mappedElement = getMappedElement(seg);
if (mappedElement == null) {
if (DebugPolicy.DEBUG_EDGE_LOAD)
- graph.asyncRequest(new ReadRequest() {
+ graph.syncRequest(new ReadRequest() {
@Override
public void run(ReadGraph graph) throws DatabaseException {
System.out.println(" EXTERNALLY ADDED CONNECTION SEGMENT: " + seg.toString()
}
});
- graph.asyncRequest(new EdgeRequest(canvas, errorHandler, canvasListenerSupport, diagram, adapter, seg), new AsyncProcedure<IElement>() {
+ graph.syncRequest(new EdgeRequest(canvas, errorHandler, canvasListenerSupport, diagram, adapter, seg), new AsyncProcedure<IElement>() {
@Override
public void execute(AsyncReadGraph graph, IElement e) {
if (DebugPolicy.DEBUG_EDGE_LOAD)
case REMOVED: {
final IElement e = getMappedElement(seg);
if (DebugPolicy.DEBUG_EDGE_LOAD)
- graph.asyncRequest(new ReadRequest() {
+ graph.syncRequest(new ReadRequest() {
@Override
public void run(ReadGraph graph) throws DatabaseException {
System.out.println(" EXTERNALLY REMOVED CONNECTION SEGMENT: " + seg.toString() + " - "
}
break;
}
+ default:
}
}
}
Object task = Timing.BEGIN("processNodesConnections");
//System.out.println("---- PROCESS NODES & CONNECTIONS BEGIN");
if (!changes.elements.isEmpty()) {
- graph.syncRequest(new AsyncReadRequest() {
+ graph.syncRequest(new ReadRequest() {
@Override
- public void run(AsyncReadGraph graph) {
+ public void run(ReadGraph graph) throws DatabaseException {
processNodes(graph);
}
@Override
//System.out.println("---- PROCESS BRANCH POINTS BEGIN");
if (!changes.branchPoints.isEmpty()) {
- graph.syncRequest(new AsyncReadRequest() {
+ graph.syncRequest(new ReadRequest() {
@Override
- public void run(AsyncReadGraph graph) {
+ public void run(ReadGraph graph) throws DatabaseException {
processBranchPoints(graph);
}
@Override
//System.out.println("---- PROCESS CONNECTION SEGMENTS BEGIN");
if (!changes.connectionSegments.isEmpty()) {
- graph.syncRequest(new AsyncReadRequest() {
+ graph.syncRequest(new ReadRequest() {
@Override
- public void run(AsyncReadGraph graph) {
+ public void run(ReadGraph graph) throws DatabaseException {
processConnectionSegments(graph);
}
@Override
task = Timing.BEGIN("processRouteGraphConnections");
if (!changes.routeGraphConnections.isEmpty()) {
- graph.syncRequest(new AsyncReadRequest() {
+ graph.syncRequest(new ReadRequest() {
@Override
- public void run(AsyncReadGraph graph) {
+ public void run(ReadGraph graph) throws DatabaseException {
processRouteGraphConnections(graph);
}
@Override
return "defaultConnectionSegmentAdapter";
}
}, new DisposableListener<IElement>(listenerSupport) {
-
- @Override
- public String toString() {
- return "DefaultConnectionSegmentAdapter listener for " + edge;
- }
-
+
+ @Override
+ public String toString() {
+ return "DefaultConnectionSegmentAdapter listener for " + edge;
+ }
+
@Override
public void execute(IElement loaded) {
// Invoked when the element has been loaded.
return;
}
- // NOTICE: Layer information is loaded from the connection entity resource
- // that is shared by all segments of the same connection.
- ElementFactoryUtil.loadLayersForElement(graph, layerManager, diagram, edge, info.connection,
- new AsyncProcedureAdapter<IElement>() {
+ graph.syncRequest(new AsyncReadRequest() {
@Override
- public void exception(AsyncReadGraph graph, Throwable t) {
- error("failed to load layers for connection segment", t);
+ public void run(AsyncReadGraph graph) {
+ // NOTICE: Layer information is loaded from the connection entity resource
+ // that is shared by all segments of the same connection.
+ ElementFactoryUtil.loadLayersForElement(graph, layerManager, diagram, edge, info.connection,
+ new AsyncProcedureAdapter<IElement>() {
+ @Override
+ public void exception(AsyncReadGraph graph, Throwable t) {
+ error("failed to load layers for connection segment", t);
+ }
+ });
}
});
GraphToDiagramUpdater updater = new GraphToDiagramUpdater(lastContent, content, changes);
GraphToDiagramSynchronizer.this.currentUpdater = updater;
try {
- updater.process(graph);
+ updater.process(graph);
} finally {
- GraphToDiagramSynchronizer.this.currentUpdater = null;
+ GraphToDiagramSynchronizer.this.currentUpdater = null;
}
Timing.END(task);
Resource resource = ElementUtils.adapt(ec, Resource.class);
if (resource == null) {
pass = false;
- new Exception("Attempted to add an element to the diagram that is not adaptable to Resource: " + e + ", class: " + ec).printStackTrace();
+ LOGGER.error("", new Exception("Attempted to add an element to the diagram that is not adaptable to Resource: " + e + ", class: " + ec));
}
// Sanity check connection hints
Code Review / simantics / platform.git / blobdiff