gerrit.simantics Code Review - simantics/platform.git/blob

   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;
  80         }
  81     }
  82
  83     public double handleStep(double currentTime) {
  84         synchronized (this) {
  85                 if (stopped)
  86                         return Double.POSITIVE_INFINITY;
  87
  88                 this.currentTime = currentTime;
  89                 {
  90                     ArrayList<Function1<Tuple0, Object>> temp = scheduledNow;
  91                     scheduledNow = scheduledNextStep;
  92                     scheduledNextStep = temp;
  93                     Collections.reverse(scheduledNow);
  94                 }
  95
  96                 SCLContext context = SCLContext.getCurrent();
  97                 Object oldActionContext = context.put("sequenceAction", this);
  98                 try {
  99                     while(true) {
 100                         while(!scheduledNow.isEmpty()) {
 101                                 try {
 102                                         Function1<Tuple0, Object> currentContinuation = scheduledNow.remove(scheduledNow.size()-1);
 103                                     currentContinuation.apply(Tuple0.INSTANCE);
 104                                         currentContinuation = null;
 105                                 } catch (Exception e) {
 106                                         if (this.exceptions == null)
 107                                                 this.exceptions = new ArrayList<>();
 108                                         this.exceptions.add(new RuntimeException("Action failure at " + currentTime + ": " + e.getMessage(), e));
 109                                 }
 110                         }
 111                         Task firstTask = scheduledAt.peek();
 112                         if(firstTask == null) {
 113                             if (scheduledNextStep.isEmpty())
 114                                 stopped = true;
 115                             return Double.POSITIVE_INFINITY;
 116                         } else if(firstTask.time > currentTime+TIME_TOLERANCE) {
 117                             return firstTask.time;
 118                         } else {
 119                             scheduledAt.remove();
 120                             firstTask.continuation.apply(Tuple0.INSTANCE);
 121                         }
 122                     }
 123                 } finally {
 124                     context.put("sequenceAction", oldActionContext);
 125                 }
 126         }
 127     }
 128
 129     private void handleStop(StopReason reason) {
 130         synchronized (this) {
 131             List<Function1<StopReason, Object>> stopFunctions = new ArrayList<>(scheduledWhenStopped);
 132             scheduledWhenStopped.clear();
 133
 134             scheduledNextStep.clear();
 135             scheduledAt.clear();
 136
 137             SCLContext context = SCLContext.getCurrent();
 138             Object oldActionContext = context.put("sequenceAction", this);
 139             try {
 140                 stopFunctions.forEach(f -> {
 141                     try {
 142                         f.apply(reason);
 143                     } catch (Exception e) {
 144                         if (this.exceptions == null)
 145                             this.exceptions = new ArrayList<>();
 146                         this.exceptions.add(new RuntimeException("Stop action failure at " + currentTime + ": " + e.getMessage(), e));
 147                     }
 148                 });
 149             } finally {
 150                 context.put("sequenceAction", oldActionContext);
 151             }
 152         }
 153     }
 154 }