--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2007, 2019 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
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Semantum Oy - initial API and implementation
+ *******************************************************************************/
+package org.simantics.district.network.profile;
+
+import java.util.Optional;
+import java.util.concurrent.atomic.AtomicLong;
+
+import org.simantics.Simantics;
+import org.simantics.databoard.Bindings;
+import org.simantics.db.ReadGraph;
+import org.simantics.db.Resource;
+import org.simantics.db.common.request.UnaryRead;
+import org.simantics.db.exception.DatabaseException;
+import org.simantics.db.procedure.Listener;
+import org.simantics.db.request.Read;
+import org.simantics.diagram.profile.StyleBase;
+import org.simantics.diagram.stubs.DiagramResource;
+import org.simantics.district.network.ontology.DistrictNetworkResource;
+import org.simantics.scenegraph.INode;
+import org.simantics.scenegraph.profile.EvaluationContext;
+import org.simantics.scenegraph.profile.Group;
+import org.simantics.scenegraph.profile.Observer;
+import org.simantics.scenegraph.profile.common.ObserverGroupListener;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public abstract class ThrottledStyleBase<Result> extends StyleBase<Optional<Result>> {
+
+ private static final Logger LOGGER = LoggerFactory.getLogger(ThrottledStyleBase.class);
+ private static final long DEFAULT_INTERVAL = 2000;
+
+ private long lastCalculateTimestamp = 0;
+ private AtomicLong interval = new AtomicLong(DEFAULT_INTERVAL);
+ private Listener<Optional<Result>> resultListener;
+
+ @Override
+ protected Read<Optional<Result>> getStyleCalculationRequest(Resource runtimeDiagram, Resource entry, Resource item) {
+ Simantics.getSession().asyncRequest(new ProfileUpdateIntervalRead(runtimeDiagram), new Listener<Long>() {
+
+ @Override
+ public void execute(Long result) {
+ interval.set(result);
+ }
+
+ @Override
+ public void exception(Throwable t) {
+ LOGGER.error("Could not listen interval from runtime diagram {}", runtimeDiagram, t);
+ }
+
+ @Override
+ public boolean isDisposed() {
+ return resultListener.isDisposed();
+ }
+ });
+ return super.getStyleCalculationRequest(runtimeDiagram, entry, item);
+ }
+
+ @Override
+ protected Listener<Optional<Result>> getStyleResultListener(ObserverGroupListener groupListener, Resource item,
+ Group group, Observer observer, Resource runtimeDiagram) {
+ resultListener = super.getStyleResultListener(groupListener, item, group, observer, runtimeDiagram);
+ return resultListener;
+ }
+
+ @Override
+ public final Optional<Result> calculateStyle(ReadGraph graph, Resource runtimeDiagram, Resource entry,
+ Resource groupItem) throws DatabaseException {
+ long currentTimestamp = System.currentTimeMillis();
+ if (lastCalculateTimestamp > (currentTimestamp - interval.get())) {
+ LOGGER.debug("Throttling result calculation for {} {} {} {}", runtimeDiagram, entry, groupItem, interval.get());
+ return Optional.empty();
+ }
+ lastCalculateTimestamp = currentTimestamp;
+ // let's calculate
+ return Optional.ofNullable(calculateThrottledStyle(graph, runtimeDiagram, entry, groupItem));
+ }
+
+ public abstract Result calculateThrottledStyle(ReadGraph graph, Resource runtimeDiagram, Resource entry, Resource groupItem) throws DatabaseException;
+
+ @Override
+ public final void applyStyleForNode(EvaluationContext evaluationContext, INode node, Optional<Result> result) {
+ if (!result.equals(Optional.empty())) {
+ applyThrottledStyleForNode(evaluationContext, node, result.get());
+ } else {
+ LOGGER.debug("Do not apply as results are unchanged for {} {} {}", evaluationContext, node, result);
+ }
+ }
+
+ public abstract void applyThrottledStyleForNode(EvaluationContext evaluationContext, INode node, Result result);
+
+ private static class ProfileUpdateIntervalRead extends UnaryRead<Resource, Long> {
+
+ public ProfileUpdateIntervalRead(Resource parameter) {
+ super(parameter);
+ }
+
+ @Override
+ public Long perform(ReadGraph graph) throws DatabaseException {
+ Resource configuration = graph.getPossibleObject(parameter, DiagramResource.getInstance(graph).RuntimeDiagram_HasConfiguration);
+ DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph);
+ Long interval = DEFAULT_INTERVAL;
+ if (configuration != null) {
+ interval = graph.getPossibleRelatedValue(configuration, DN.Diagram_profileUpdateInterval, Bindings.LONG);
+ }
+ return interval != null ? interval : DEFAULT_INTERVAL;
+ }
+ }
+}