From 0ce7f7122a702c3d6a4b864172b8c93620c8b03b Mon Sep 17 00:00:00 2001 From: Fabian Stemmler Date: Wed, 29 May 2019 08:22:04 +0200 Subject: [PATCH] Timeline updated (executeUntil, setTimeFunction) The timeline method executeUpto(timestamp, timeout), has been changed to executeUntil(condition, timeout). The timeline method setTimeFunction was added (e.g. to allow for real-time simulation). The timeFunction is called whenever the timeline needs to find out the current simulation time. --- LogicUI/src/era/mi/gui/LogicUIStandalone.java | 2 +- .../mi/gui/components/GUIManualSwitch.java | 2 +- .../mi/gui/examples/RSLatchGUIExample.java | 1 + .../src/sampleercp/parts/LogicUIPart.java | 2 +- .../src/era/mi/logic/tests/ComponentTest.java | 37 +++++++++ era.mi/src/era/mi/logic/tests/GUITest.java | 2 +- .../src/era/mi/logic/timeline/Timeline.java | 76 ++++++++++++------- 7 files changed, 92 insertions(+), 30 deletions(-) diff --git a/LogicUI/src/era/mi/gui/LogicUIStandalone.java b/LogicUI/src/era/mi/gui/LogicUIStandalone.java index 3b3c740f..2febb5cb 100644 --- a/LogicUI/src/era/mi/gui/LogicUIStandalone.java +++ b/LogicUI/src/era/mi/gui/LogicUIStandalone.java @@ -54,7 +54,7 @@ public class LogicUIStandalone while (running.get()) { // always execute to keep timeline from "hanging behind" for too long - timeline.executeUpTo(System.currentTimeMillis(), System.currentTimeMillis() + 10); + timeline.executeUntil(timeline.laterThan(System.currentTimeMillis()), System.currentTimeMillis() + 10); long sleepTime; if (timeline.hasNext()) sleepTime = timeline.nextEventTime() - System.currentTimeMillis(); diff --git a/LogicUI/src/era/mi/gui/components/GUIManualSwitch.java b/LogicUI/src/era/mi/gui/components/GUIManualSwitch.java index 7dcb025f..fde7bbde 100644 --- a/LogicUI/src/era/mi/gui/components/GUIManualSwitch.java +++ b/LogicUI/src/era/mi/gui/components/GUIManualSwitch.java @@ -72,7 +72,7 @@ public class GUIManualSwitch extends ManualSwitch implements BasicGUIComponent @Override public boolean clicked(double x, double y) { - toggle(); + timeline.addEvent((e) -> toggle(), (int) (System.currentTimeMillis() - timeline.getSimulationTime())); return true; } diff --git a/LogicUI/src/era/mi/gui/examples/RSLatchGUIExample.java b/LogicUI/src/era/mi/gui/examples/RSLatchGUIExample.java index dc6091f6..76a10f84 100644 --- a/LogicUI/src/era/mi/gui/examples/RSLatchGUIExample.java +++ b/LogicUI/src/era/mi/gui/examples/RSLatchGUIExample.java @@ -19,6 +19,7 @@ public class RSLatchGUIExample public static void main(String[] args) { Timeline t = new Timeline(11); + t.setTimeFunction(() -> System.currentTimeMillis()); // real time simulation LogicUIStandalone ui = new LogicUIStandalone(t); addComponentsAndWires(ui.getLogicUICanvas(), t); ui.run(); diff --git a/SampleERCP/src/sampleercp/parts/LogicUIPart.java b/SampleERCP/src/sampleercp/parts/LogicUIPart.java index f725d5b6..ee1d7759 100644 --- a/SampleERCP/src/sampleercp/parts/LogicUIPart.java +++ b/SampleERCP/src/sampleercp/parts/LogicUIPart.java @@ -34,7 +34,7 @@ public class LogicUIPart while (!ui.isDisposed()) { // always execute to keep timeline from "hanging behind" for too long - timeline.executeUpTo(System.currentTimeMillis(), System.currentTimeMillis() + 10); + timeline.executeUntil(timeline.laterThan(System.currentTimeMillis()), System.currentTimeMillis() + 10); long sleepTime; if (timeline.hasNext()) sleepTime = timeline.nextEventTime() - System.currentTimeMillis(); diff --git a/era.mi/src/era/mi/logic/tests/ComponentTest.java b/era.mi/src/era/mi/logic/tests/ComponentTest.java index c52833c0..0e2b3460 100644 --- a/era.mi/src/era/mi/logic/tests/ComponentTest.java +++ b/era.mi/src/era/mi/logic/tests/ComponentTest.java @@ -1,5 +1,6 @@ package era.mi.logic.tests; +import static org.junit.Assert.assertTrue; import static org.junit.jupiter.api.Assertions.assertArrayEquals; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.fail; @@ -284,6 +285,42 @@ class ComponentTest assertEquals(-1, a.getSignedValue()); } + boolean flag = false; + + @Test + void simpleTimelineTest() + { + Timeline t = new Timeline(3); + flag = false; + t.addEvent((e) -> + { + if (!flag) + fail(); + flag = false; + }, 15); + t.addEvent((e) -> + { + if (flag) + fail(); + flag = true; + }, 10); + t.addEvent((e) -> + { + if (flag) + fail(); + flag = true; + }, 20); + t.addEvent((e) -> + { + fail("Only supposed to execute until timestamp 20, not 25"); + }, 25); + + t.executeUntil(t.laterThan(20), 100); + + if (!flag) + fail(); + } + @Test void multipleInputs() { diff --git a/era.mi/src/era/mi/logic/tests/GUITest.java b/era.mi/src/era/mi/logic/tests/GUITest.java index 78421c4f..0581812b 100644 --- a/era.mi/src/era/mi/logic/tests/GUITest.java +++ b/era.mi/src/era/mi/logic/tests/GUITest.java @@ -282,7 +282,7 @@ public class GUITest extends JPanel while (f.isVisible()) { - ExecutionResult er = gt.getTimeline().executeUpTo((lastFrame - begin) * 3, lastFrame + 14); + ExecutionResult er = gt.getTimeline().executeUntil(gt.getTimeline().laterThan((lastFrame - begin) * 3), lastFrame + 14); // if (t.hasNext()) // t.executeNext(); if (er != ExecutionResult.NOTHING_DONE) diff --git a/era.mi/src/era/mi/logic/timeline/Timeline.java b/era.mi/src/era/mi/logic/timeline/Timeline.java index c22e1a4a..20af398d 100644 --- a/era.mi/src/era/mi/logic/timeline/Timeline.java +++ b/era.mi/src/era/mi/logic/timeline/Timeline.java @@ -3,7 +3,9 @@ package era.mi.logic.timeline; import java.util.ArrayList; import java.util.List; import java.util.PriorityQueue; +import java.util.function.BooleanSupplier; import java.util.function.Consumer; +import java.util.function.LongSupplier; /** * Orders Events by the time they are due to be executed. Can execute Events individually. @@ -14,7 +16,8 @@ import java.util.function.Consumer; public class Timeline { private PriorityQueue events; - private long currentTime = 0; + private LongSupplier time; + private long lastTimeUpdated = 0; private final List> eventAddedListener; @@ -23,6 +26,16 @@ public class Timeline events = new PriorityQueue(initCapacity); eventAddedListener = new ArrayList<>(); + time = () -> lastTimeUpdated; + } + + /** + * @param timestamp exclusive + * @return true if the first event is later than the timestamp + */ + public BooleanSupplier laterThan(long timestamp) + { + return () -> timeCmp(events.peek().getTiming(), timestamp) > 0; } public boolean hasNext() @@ -30,11 +43,14 @@ public class Timeline return !events.isEmpty(); } + /** + * Executes all events at the next timestamp, at which there are any + */ public void executeNext() { InnerEvent first = events.peek(); if (first != null) - executeUpTo(first.getTiming(), -1); + executeUntil(laterThan(first.getTiming()), -1); } public void executeAll() @@ -44,40 +60,51 @@ public class Timeline } /** - * Executes all events up to a given simulation timestamp. The simulation process can be constrained by a real world timestamp. + * Executes all events until a given condition is met. The simulation process can be constrained by a real world timestamp. * - * @param timestamp the simulation timestamp up to which the events will be processed + * @param condition the condition until which the events are be processed * @param stopMillis the System.currentTimeMillis() when simulation definitely needs to stop. A value of -1 means no timeout. - * @return if it was possible to fulfill the goal in the given real world time. - * @author Christian Femers + * @return State of the event execution + * @formatter:off + * NOTHING_DONE if the {@link Timeline} was already empty + * EXEC_OUT_OF_TIME if the given maximum time was reached + * EXEC_UNTIL_CONDITION if the condition was met + * EXEC_UNTIL_EMPTY if events were executed until the {@link Timeline} was empty + * @formatter:on + * @author Christian Femers, Fabian Stemmler */ - public ExecutionResult executeUpTo(long timestamp, long stopMillis) + public ExecutionResult executeUntil(BooleanSupplier condition, long stopMillis) { if (events.isEmpty()) { - currentTime = timestamp; + lastTimeUpdated = getSimulationTime(); return ExecutionResult.NOTHING_DONE; } int checkStop = 0; InnerEvent first = events.peek(); - while (first != null && first.getTiming() <= timestamp) + while (hasNext() && !condition.getAsBoolean()) { events.remove(); - currentTime = first.getTiming(); + lastTimeUpdated = first.getTiming(); first.run(); // Don't check after every run checkStop = (checkStop + 1) % 10; if (checkStop == 0 && System.currentTimeMillis() >= stopMillis) - return ExecutionResult.RAN_OUT_OF_TIME; + return ExecutionResult.EXEC_OUT_OF_TIME; first = events.peek(); } - currentTime = timestamp; - return ExecutionResult.DONE_IN_TIME; + lastTimeUpdated = getSimulationTime(); + return hasNext() ? ExecutionResult.EXEC_UNTIL_EMPTY : ExecutionResult.EXEC_UNTIL_CONDITION; + } + + public void setTimeFunction(LongSupplier time) + { + this.time = time; } public long getSimulationTime() { - return currentTime; + return time.getAsLong(); } public long nextEventTime() @@ -90,7 +117,7 @@ public class Timeline public void reset() { events.clear(); - currentTime = 0; + lastTimeUpdated = 0; } public void addEventAddedListener(Consumer listener) @@ -111,7 +138,7 @@ public class Timeline */ public void addEvent(TimelineEventHandler function, int relativeTiming) { - long timing = currentTime + relativeTiming; + long timing = getSimulationTime() + relativeTiming; TimelineEvent event = new TimelineEvent(timing); events.add(new InnerEvent(function, event)); eventAddedListener.forEach(l -> l.accept(event)); @@ -154,26 +181,23 @@ public class Timeline @Override public int compareTo(InnerEvent o) { - long difference = getTiming() - o.getTiming(); - if (difference == 0) - return 0; - return difference < 0 ? -1 : 1; + return timeCmp(getTiming(), o.getTiming()); } } - @Override - public String toString() + private static int timeCmp(long a, long b) { - return "simulation time: " + currentTime + ", " + events.toString(); + return Long.signum(a - b); } - public static long toNanoseconds(long ticks) + @Override + public String toString() { - return ticks; // TODO: Alter this when it has been determined how ticks should relate to real time. + return String.format("Simulation time: %s, Last update: %d, Events: %s", getSimulationTime(), lastTimeUpdated, events.toString()); } public enum ExecutionResult { - NOTHING_DONE, DONE_IN_TIME, RAN_OUT_OF_TIME + NOTHING_DONE, EXEC_UNTIL_EMPTY, EXEC_UNTIL_CONDITION, EXEC_OUT_OF_TIME } } \ No newline at end of file -- 2.17.1