Added project specific format; Default values in WireArray are now U

[Mograsim.git] / era.mi / src / era / mi / logic / timeline / Timeline.java

diff --git a/era.mi/src/era/mi/logic/timeline/Timeline.java b/era.mi/src/era/mi/logic/timeline/Timeline.java
index 7030310..63d7395 100644 (file)
--- a/era.mi/src/era/mi/logic/timeline/Timeline.java
+++ b/era.mi/src/era/mi/logic/timeline/Timeline.java
@@ -11,14 +11,17 @@ import java.util.function.Consumer;
  * @author Fabian Stemmler
  *
  */
-public class Timeline {
+public class Timeline
+{
        private PriorityQueue<InnerEvent> events;
        private long currentTime = 0;
 
        private final List<Consumer<TimelineEvent>> eventAddedListener;
 
-       public Timeline(int initCapacity) {
-               events = new PriorityQueue<InnerEvent>(initCapacity, (a, b) -> {
+       public Timeline(int initCapacity)
+       {
+               events = new PriorityQueue<InnerEvent>(initCapacity, (a, b) ->
+               {
                        long difference = a.getTiming() - b.getTiming();
                        if (difference == 0)
                                return 0;
@@ -28,17 +31,20 @@ public class Timeline {
                eventAddedListener = new ArrayList<>();
        }
 
-       public boolean hasNext() {
+       public boolean hasNext()
+       {
                return !events.isEmpty();
        }
 
-       public void executeNext() {
+       public void executeNext()
+       {
                InnerEvent first = events.poll();
                currentTime = first.getTiming();
                first.run();
        }
 
-       public void executeAll() {
+       public void executeAll()
+       {
                while (hasNext())
                        executeNext();
        }
@@ -51,14 +57,17 @@ public class Timeline {
         * @return if it was possible to fulfil the goal in the given real world time.
         * @author Christian Femers
         */
-       public ExecutionResult executeUpTo(long timestamp, long stopMillis) {
-               if (events.isEmpty()) {
+       public ExecutionResult executeUpTo(long timestamp, long stopMillis)
+       {
+               if (events.isEmpty())
+               {
                        currentTime = timestamp;
                        return ExecutionResult.NOTHING_DONE;
                }
                int checkStop = 0;
                InnerEvent first = events.peek();
-               while (first != null && first.getTiming() <= timestamp) {
+               while (first != null && first.getTiming() <= timestamp)
+               {
                        events.remove();
                        currentTime = first.getTiming();
                        first.run();
@@ -72,27 +81,32 @@ public class Timeline {
                return ExecutionResult.DONE_IN_TIME;
        }
 
-       public long getSimulationTime() {
+       public long getSimulationTime()
+       {
                return currentTime;
        }
 
-       public long nextEventTime() {
+       public long nextEventTime()
+       {
                if (!hasNext())
                        return -1;
                else
                        return events.peek().timing;
        }
 
-       public void reset() {
+       public void reset()
+       {
                events.clear();
                currentTime = 0;
        }
 
-       public void addEventAddedListener(Consumer<TimelineEvent> listener) {
+       public void addEventAddedListener(Consumer<TimelineEvent> listener)
+       {
                eventAddedListener.add(listener);
        }
 
-       public void removeEventAddedListener(Consumer<TimelineEvent> listener) {
+       public void removeEventAddedListener(Consumer<TimelineEvent> listener)
+       {
                eventAddedListener.remove(listener);
        }
 
@@ -102,14 +116,16 @@ public class Timeline {
         * @param function       The {@link TimelineEventHandler} that will be executed, when the {@link InnerEvent} occurs on the timeline.
         * @param relativeTiming The amount of MI ticks in which the {@link InnerEvent} is called, starting from the current time.
         */
-       public void addEvent(TimelineEventHandler function, int relativeTiming) {
+       public void addEvent(TimelineEventHandler function, int relativeTiming)
+       {
                long timing = currentTime + relativeTiming;
                TimelineEvent event = new TimelineEvent(timing);
                events.add(new InnerEvent(function, event, timing));
                eventAddedListener.forEach(l -> l.accept(event));
        }
 
-       private class InnerEvent {
+       private class InnerEvent
+       {
 
                private final long timing;
                private final TimelineEventHandler function;
@@ -121,36 +137,43 @@ 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, long timing)
+               {
                        this.function = function;
                        this.event = event;
                        this.timing = timing;
                }
 
-               public long getTiming() {
+               public long getTiming()
+               {
                        return timing;
                }
 
-               public void run() {
+               public void run()
+               {
                        function.handle(event);
                }
 
                @Override
-               public String toString() {
+               public String toString()
+               {
                        return event.toString();
                }
        }
 
        @Override
-       public String toString() {
+       public String toString()
+       {
                return "simulation time: " + currentTime + ", " + events.toString();
        }
 
-       public static long toNanoseconds(long ticks) {
+       public static long toNanoseconds(long ticks)
+       {
                return ticks; // TODO: Alter this when it has been determined how ticks should relate to real time.
        }
 
-       public enum ExecutionResult {
+       public enum ExecutionResult
+       {
                NOTHING_DONE, DONE_IN_TIME, RAN_OUT_OF_TIME
        }
 }
\ No newline at end of file