Allow simulation stop handling in Simantics/Sequences
[simantics/platform.git] / bundles / org.simantics.simulation.sequences / src / org / simantics / simulation / sequences / action / AbstractActionContext.java
1 package org.simantics.simulation.sequences.action;
2
3 import java.util.ArrayList;
4 import java.util.Collections;
5 import java.util.List;
6 import java.util.PriorityQueue;
7
8 import org.simantics.scl.runtime.SCLContext;
9 import org.simantics.scl.runtime.function.Function1;
10 import org.simantics.scl.runtime.tuple.Tuple0;
11
12 public abstract class AbstractActionContext implements ActionContext {
13     public static final double TIME_TOLERANCE = 1e-6;
14     
15     double currentTime;
16     volatile boolean stopped;
17     ArrayList<Function1<Tuple0, Object>> scheduledNow = new ArrayList<>();
18     ArrayList<Function1<Tuple0, Object>> scheduledNextStep = new ArrayList<>();
19     ArrayList<Function1<StopReason, Object>> scheduledWhenStopped = new ArrayList<>();
20     PriorityQueue<Task> scheduledAt = new PriorityQueue<>();
21
22         public List<Exception> exceptions; 
23     
24     private static class Task implements Comparable<Task> {
25         final double time;
26         final Function1<Tuple0, Object> continuation;
27         
28         public Task(double time, Function1<Tuple0, Object> continuation) {
29             this.time = time;
30             this.continuation = continuation;
31         }
32
33         @Override
34         public int compareTo(Task o) {
35             return Double.compare(time, o.time);
36         }
37     }
38     
39     @Override
40     public double time() {
41         return currentTime;
42     }
43     
44     @Override
45     public void scheduleNow(Function1<Tuple0, Object> continuation) {
46         scheduledNow.add(continuation);
47     }
48     
49     @Override
50     public void scheduleNextStep(Function1<Tuple0, Object> continuation) {
51         scheduledNextStep.add(continuation);
52     }
53     
54     @Override
55     public void scheduleAt(double time, Function1<Tuple0, Object> continuation) {
56         if(time <= currentTime)
57             scheduleNow(continuation);
58         else
59             scheduledAt.add(new Task(time, continuation));
60     }
61
62     @Override
63     public void scheduleWhenStopped(Function1<StopReason, Object> continuation) {
64         scheduledWhenStopped.add(continuation);
65     }
66
67     @Override
68     public void stop() {
69         stop(StopReason.STOPPED);
70     }
71
72     public void stop(StopReason reason) {
73         stopped = true;
74         handleStop(reason);
75     }
76
77     public boolean isStopped() {
78         synchronized (this) {
79                 return stopped || (scheduledNextStep.isEmpty() && scheduledAt.isEmpty());
80         }
81     }
82     
83     public double handleStep(double currentTime) {
84         synchronized (this) {
85                 this.currentTime = currentTime;
86                 {
87                     ArrayList<Function1<Tuple0, Object>> temp = scheduledNow;
88                     scheduledNow = scheduledNextStep;
89                     scheduledNextStep = temp;
90                     Collections.reverse(scheduledNow);
91                 }
92                         
93                 SCLContext context = SCLContext.getCurrent();
94                 Object oldActionContext = context.put("sequenceAction", this);
95                 try {
96                     Task firstTask = scheduledAt.peek();
97                     while(true) {
98                         while(!scheduledNow.isEmpty()) {
99                                 try {
100                                         Function1<Tuple0, Object> currentContinuation = scheduledNow.remove(scheduledNow.size()-1);
101                                     currentContinuation.apply(Tuple0.INSTANCE);
102                                         currentContinuation = null;
103                                 } catch (Exception e) {
104                                         if (this.exceptions == null)
105                                                 this.exceptions = new ArrayList<>();
106                                         this.exceptions.add(new RuntimeException("Action failure at " + currentTime + ": " + e.getMessage(), e));
107                                 }
108                         }
109                         if(firstTask == null)
110                             return Double.POSITIVE_INFINITY;
111                         else if(firstTask.time > currentTime+TIME_TOLERANCE)
112                             return firstTask.time;
113                         else {
114                             firstTask.continuation.apply(Tuple0.INSTANCE);
115                                 synchronized (this) {
116                                         scheduledAt.remove();
117                                 }
118                             firstTask = scheduledAt.peek();
119                         }
120                     }
121                 } finally {
122                     context.put("sequenceAction", oldActionContext);
123                 }
124         }
125     }
126
127     private void handleStop(StopReason reason) {
128         synchronized (this) {
129             List<Function1<StopReason, Object>> stopFunctions = new ArrayList<>(scheduledWhenStopped);
130             scheduledWhenStopped.clear();
131
132             SCLContext context = SCLContext.getCurrent();
133             Object oldActionContext = context.put("sequenceAction", this);
134             try {
135                 stopFunctions.forEach(f -> {
136                     try {
137                         f.apply(reason);
138                     } catch (Exception e) {
139                         if (this.exceptions == null)
140                             this.exceptions = new ArrayList<>();
141                         this.exceptions.add(new RuntimeException("Stop action failure at " + currentTime + ": " + e.getMessage(), e));
142                     }
143                 });
144             } finally {
145                 context.put("sequenceAction", oldActionContext);
146             }
147         }
148     }
149 }