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 }