X-Git-Url: https://mograsim.net/gitweb/?a=blobdiff_plain;f=era.mi%2Fsrc%2Fera%2Fmi%2Flogic%2Ftimeline%2FTimeline.java;h=c0100632a25f4590b9a40eefe69d5d5f2bf9e59e;hb=80bfbd8ebf0ad8a7ad98584544a0c73f43e6f3b6;hp=8107db9627d1d70034db863a4da738a4cf647a0c;hpb=373b945917f9d573e4b1bd0e97f98b02fb0d9c07;p=Mograsim.git diff --git a/era.mi/src/era/mi/logic/timeline/Timeline.java b/era.mi/src/era/mi/logic/timeline/Timeline.java index 8107db96..c0100632 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,21 +16,26 @@ 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; public Timeline(int initCapacity) { - events = new PriorityQueue(initCapacity, (a, b) -> - { - long difference = a.getTiming() - b.getTiming(); - if (difference == 0) - return 0; - return difference < 0 ? -1 : 1; - }); + 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() @@ -36,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.poll(); - currentTime = first.getTiming(); - first.run(); + InnerEvent first = events.peek(); + if (first != null) + executeUntil(laterThan(first.getTiming()), -1); } public void executeAll() @@ -50,53 +60,64 @@ 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 stopMillis the System.currentTimeMillis() when simulation definitely needs to stop. - * @return if it was possible to fulfil the goal in the given real world time. - * @author Christian Femers + * @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 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() { if (!hasNext()) return -1; - return events.peek().timing; + return events.peek().getTiming(); } public void reset() { events.clear(); - currentTime = 0; + lastTimeUpdated = 0; } public void addEventAddedListener(Consumer listener) @@ -117,16 +138,14 @@ 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, timing)); + events.add(new InnerEvent(function, event)); eventAddedListener.forEach(l -> l.accept(event)); } - private class InnerEvent + private class InnerEvent implements Runnable, Comparable { - - final long timing; private final TimelineEventHandler function; private final TimelineEvent event; @@ -136,18 +155,18 @@ public class Timeline * @param function {@link TimelineEventHandler} to be executed when the {@link InnerEvent} occurs * @param timing Point in the MI simulation {@link Timeline}, at which the {@link InnerEvent} is executed; */ - InnerEvent(TimelineEventHandler function, TimelineEvent event, long timing) + InnerEvent(TimelineEventHandler function, TimelineEvent event) { this.function = function; this.event = event; - this.timing = timing; } public long getTiming() { - return timing; + return event.getTiming(); } + @Override public void run() { function.handle(event); @@ -158,21 +177,27 @@ public class Timeline { return event.toString(); } + + @Override + public int compareTo(InnerEvent o) + { + return timeCmp(getTiming(), o.getTiming()); + } } - @Override - public String toString() + public 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