--- /dev/null
+package org.simantics.structural.synchronization.base;
+
+import java.util.ArrayList;
+
+import org.simantics.databoard.binding.mutable.Variant;
+import org.simantics.structural.synchronization.utils.ComponentBase;
+import org.simantics.structural.synchronization.utils.Solver;
+
+import gnu.trove.map.hash.THashMap;
+
+public class ModuleUpdateContext<T extends ComponentBase<T>> {
+
+ private ModuleUpdaterBase<T> updater;
+ private final SynchronizationEventHandlerBase<T> handler;
+ public final T component;
+ public CommandBuilder command;
+ private ArrayList<Runnable> postUpdateActions;
+ private THashMap<String, Variant> storedProperties;
+
+ private int pendingRuleCount;
+ public boolean stateLoadedFromUndo;
+
+ public ModuleUpdateContext(SynchronizationEventHandlerBase<T> handler, ModuleUpdaterBase<T> updater, T component) {
+ assert(updater != null);
+ this.handler = handler;
+ this.updater = updater;
+ this.component = component;
+ }
+
+ public void incPendingCount() {
+ ++pendingRuleCount;
+ }
+
+ public void decPendingCount() {
+ --pendingRuleCount;
+ if(pendingRuleCount == 0) {
+ try {
+ command.apply(getSolver());
+ command = null;
+ } catch (Exception e) {
+ handler.reportProblem("Exception while issuing command.", e);
+ }
+ if(getModuleId() <= 0) {
+ setModuleId(getSolver().getId(getModuleName()));
+ component.setModuleId(getModuleId());
+ }
+ if(postUpdateActions != null) {
+ for(Runnable action : postUpdateActions)
+ try {
+ action.run();
+ } catch(Exception e) {
+ handler.reportProblem("Post update action failed.", e);
+ }
+ postUpdateActions = null;
+ }
+ handler.resolver.unmarkPending(component);
+ }
+ }
+
+ public void addPostUpdateAction(Runnable action) {
+ if(postUpdateActions == null)
+ postUpdateActions = new ArrayList<Runnable>(2);
+ postUpdateActions.add(action);
+ }
+
+ public int getModuleId() {
+ return component.getModuleId();
+ }
+
+ public SynchronizationEventHandlerBase<T> getHandler() {
+ return handler;
+ }
+
+ public void setModuleId(int moduleId) {
+ component.setModuleId(moduleId);
+ }
+
+ public Solver getSolver() {
+ return handler.solver;
+ }
+
+ public <S> S getConcreteSolver() {
+ return handler.solver.getConcreteSolver();
+ }
+
+ public String getModuleType() {
+ return updater != null ? updater.moduleType : null;
+ }
+
+ public String getModuleName() {
+ return component.solverComponentName;
+ }
+
+ public void setModuleName(String moduleName) {
+ component.solverComponentName = moduleName;
+ }
+
+ public void reportProblem(String description) {
+ handler.reportProblem(description);
+
+ }
+
+ public void reportProblem(String description, Exception e) {
+ handler.reportProblem(description, e);
+ }
+
+ public void resolveReference(String connectionPoint, ModuleCallback moduleCallback) {
+ handler.resolver.resolveReference(component, connectionPoint, moduleCallback);
+ }
+
+ public void storeProperty(String name, Variant value) {
+ if(storedProperties == null)
+ storedProperties = new THashMap<String, Variant>();
+ storedProperties.put(name, value);
+ }
+
+ public Variant getStoredProperty(String name) {
+ if(storedProperties == null)
+ return null;
+ return storedProperties.get(name);
+ }
+
+ public void addPostSynchronizationAction(Runnable action) {
+ handler.addPostSynchronizationAction(action);
+ }
+
+ @SuppressWarnings("unchecked")
+ public <C> C getConcreteCommand() {
+ return (C)command.getConcrete();
+ }
+
+ public void setDidChanges() {
+ handler.setDidChanges();
+ }
+
+ ArrayList<ResynchronizeAction> resynchronizeActions;
+
+ private class ResynchronizeAction {
+ final String connectionPoint;
+ final ModuleCallback callback;
+
+ public ResynchronizeAction(String connectionPoint,
+ ModuleCallback callback) {
+ this.connectionPoint = connectionPoint;
+ this.callback = callback;
+ }
+ }
+
+ public void resynchronize(String connectionPoint, ModuleCallback callback) {
+ if(resynchronizeActions == null) {
+ resynchronizeActions = new ArrayList<ResynchronizeAction>();
+ handler.addPostSynchronizationAction(new Runnable() {
+ @Override
+ public void run() {
+ ArrayList<ResynchronizeAction> resynchronizeActions = ModuleUpdateContext.this.resynchronizeActions;
+ ModuleUpdateContext.this.resynchronizeActions = null;
+
+ command = updater.createUpdateCommandBuilder(getModuleName());
+ for(ResynchronizeAction action : resynchronizeActions)
+ resolveReference(action.connectionPoint, action.callback);
+ try {
+ command.apply(getSolver());
+ } catch (Exception e) {
+ handler.reportProblem("Exception while issuing command.", e);
+ }
+ }
+ });
+ }
+ resynchronizeActions.add(new ResynchronizeAction(connectionPoint, callback));
+ }
+
+}