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;
private static final Logger LOGGER = LoggerFactory.getLogger(ThrottledStyleBase.class);
private static final long DEFAULT_INTERVAL = 2000;
- private long lastCalculateTimestamp = 0;
+ //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();
- }
- });
+ //Simantics.getSession().asyncRequest(new ProfileUpdateIntervalRead(runtimeDiagram), new ProfileUpdateIntervalListener(runtimeDiagram, entry, item));
return super.getStyleCalculationRequest(runtimeDiagram, entry, item);
}
@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;
+// Needs fixing - this will result registration of listeners for nothing in the cache
+// 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));
}
@Override
public final void applyStyleForNode(EvaluationContext evaluationContext, INode node, Optional<Result> result) {
- if (!result.equals(Optional.empty())) {
+ if (!Optional.empty().equals(result) && result != null) {
applyThrottledStyleForNode(evaluationContext, node, result.get());
} else {
LOGGER.debug("Do not apply as results are unchanged for {} {} {}", evaluationContext, node, result);
+ // TODO: fix this duplicate method invocation with null
+ applyThrottledStyleForNode(evaluationContext, node, null);
}
}
return interval != null ? interval : DEFAULT_INTERVAL;
}
}
+
+ private class ProfileUpdateIntervalListener implements Listener<Long> {
+
+ private Resource runtimeDiagram;
+ private Resource entry;
+ private Resource item;
+
+ public ProfileUpdateIntervalListener(Resource runtimeDiagram, Resource entry, Resource item) {
+ this.runtimeDiagram = runtimeDiagram;
+ this.entry = entry;
+ this.item = item;
+ }
+
+ @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();
+ }
+
+ @Override
+ public int hashCode() {
+ final int prime = 31;
+ int result = 1;
+ result = prime * result + getEnclosingInstance().hashCode();
+ result = prime * result + ((entry == null) ? 0 : entry.hashCode());
+ result = prime * result + ((item == null) ? 0 : item.hashCode());
+ result = prime * result + ((runtimeDiagram == null) ? 0 : runtimeDiagram.hashCode());
+ return result;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj)
+ return true;
+ if (obj == null)
+ return false;
+ if (getClass() != obj.getClass())
+ return false;
+ ProfileUpdateIntervalListener other = (ProfileUpdateIntervalListener) obj;
+ if (!getEnclosingInstance().equals(other.getEnclosingInstance()))
+ return false;
+ if (entry == null) {
+ if (other.entry != null)
+ return false;
+ } else if (!entry.equals(other.entry))
+ return false;
+ if (item == null) {
+ if (other.item != null)
+ return false;
+ } else if (!item.equals(other.item))
+ return false;
+ if (runtimeDiagram == null) {
+ if (other.runtimeDiagram != null)
+ return false;
+ } else if (!runtimeDiagram.equals(other.runtimeDiagram))
+ return false;
+ return true;
+ }
+
+ private ThrottledStyleBase<Result> getEnclosingInstance() {
+ return ThrottledStyleBase.this;
+ }
+ }
+
}