simgear/structure/event_mgr.cxx

   1 #ifdef HAVE_CONFIG_H
   2 #  include <simgear_config.h>
   3 #endif
   4
   5 #include "event_mgr.hxx"
   6
   7 #include <simgear/debug/logstream.hxx>
   8
   9 void SGEventMgr::add(const std::string& name, SGCallback* cb,
  10                      double interval, double delay,
  11                      bool repeat, bool simtime)
  12 {
  13     // Clamp the delay value to 1 usec, so that user code can use
  14     // "zero" as a synonym for "next frame".
  15     if(delay <= 0) delay = 1e-6;
  16     if(interval <= 0) interval = 1e-6; // No timer endless loops please...
  17
  18     SGTimer* t = new SGTimer;
  19     t->interval = interval;
  20     t->callback = cb;
  21     t->repeat = repeat;
  22     t->name = name;
  23     t->running = false;
  24
  25     SGTimerQueue* q = simtime ? &_simQueue : &_rtQueue;
  26
  27     q->insert(t, delay);
  28 }
  29
  30 SGTimer::~SGTimer()
  31 {
  32     delete callback;
  33     callback = NULL;
  34 }
  35
  36 void SGTimer::run()
  37 {
  38     (*callback)();
  39 }
  40
  41 SGEventMgr::SGEventMgr()
  42 {
  43
  44 }
  45
  46 SGEventMgr::~SGEventMgr()
  47 {
  48
  49 }
  50
  51 void SGEventMgr::unbind()
  52 {
  53     _freezeProp.clear();
  54     _rtProp.clear();
  55 }
  56
  57 void SGEventMgr::shutdown()
  58 {
  59     _simQueue.clear();
  60     _rtQueue.clear();
  61 }
  62
  63 void SGEventMgr::update(double delta_time_sec)
  64 {
  65     _simQueue.update(delta_time_sec);
  66
  67     double rt = _rtProp ? _rtProp->getDoubleValue() : 0;
  68     _rtQueue.update(rt);
  69 }
  70
  71 void SGEventMgr::removeTask(const std::string& name)
  72 {
  73   SGTimer* t = _simQueue.findByName(name);
  74   if (t) {
  75     _simQueue.remove(t);
  76   } else if ((t = _rtQueue.findByName(name))) {
  77     _rtQueue.remove(t);
  78   } else {
  79     SG_LOG(SG_GENERAL, SG_WARN, "removeTask: no task found with name:" << name);
  80     return;
  81   }
  82   if (t->running) {
  83     // mark as not repeating so that the SGTimerQueue::update()
  84     // will clean it up
  85     t->repeat = false;
  86   } else {
  87     delete t;
  88   }
  89 }
  90
  91 ////////////////////////////////////////////////////////////////////////
  92 // SGTimerQueue
  93 // This is the priority queue implementation:
  94 ////////////////////////////////////////////////////////////////////////
  95
  96 SGTimerQueue::SGTimerQueue(int size)
  97 {
  98     _now = 0;
  99     _numEntries = 0;
 100     _tableSize = 1;
 101     while(size > _tableSize)
 102         _tableSize = ((_tableSize + 1)<<1) - 1;
 103
 104     _table = new HeapEntry[_tableSize];
 105     for(int i=0; i<_tableSize; i++) {
 106             _table[i].pri = 0;
 107         _table[i].timer = 0;
 108     }
 109 }
 110
 111
 112 SGTimerQueue::~SGTimerQueue()
 113 {
 114     clear();
 115     delete[] _table;
 116 }
 117
 118 void SGTimerQueue::clear()
 119 {
 120     // delete entries
 121     for(int i=0; i<_numEntries; i++) {
 122         delete _table[i].timer;
 123     }
 124
 125     _numEntries = 0;
 126
 127     // clear entire table to empty
 128     for(int i=0; i<_tableSize; i++) {
 129             _table[i].pri = 0;
 130         _table[i].timer = 0;
 131     }
 132 }
 133
 134 void SGTimerQueue::update(double deltaSecs)
 135 {
 136     _now += deltaSecs;
 137     while(_numEntries && nextTime() <= _now) {
 138         SGTimer* t = remove();
 139         if(t->repeat)
 140             insert(t, t->interval);
 141         // warning: this is not thread safe
 142         // but the entire timer queue isn't either
 143         t->running = true;
 144         t->run();
 145         t->running = false;
 146         if (!t->repeat)
 147             delete t;
 148     }
 149 }
 150
 151 void SGTimerQueue::insert(SGTimer* timer, double time)
 152 {
 153     if(_numEntries >= _tableSize)
 154         growArray();
 155
 156     _numEntries++;
 157     _table[_numEntries-1].pri = -(_now + time);
 158     _table[_numEntries-1].timer = timer;
 159
 160     siftUp(_numEntries-1);
 161 }
 162
 163 SGTimer* SGTimerQueue::remove(SGTimer* t)
 164 {
 165     int entry;
 166     for(entry=0; entry<_numEntries; entry++)
 167         if(_table[entry].timer == t)
 168             break;
 169     if(entry == _numEntries)
 170         return 0;
 171
 172     // Swap in the last item in the table, and sift down
 173     swap(entry, _numEntries-1);
 174     _numEntries--;
 175     siftDown(entry);
 176
 177     return t;
 178 }
 179
 180 SGTimer* SGTimerQueue::remove()
 181 {
 182     if(_numEntries == 0) {
 183         return 0;
 184     } else if(_numEntries == 1) {
 185         _numEntries = 0;
 186         return _table[0].timer;
 187     }
 188
 189     SGTimer *result = _table[0].timer;
 190     _table[0] = _table[_numEntries - 1];
 191     _numEntries--;
 192     siftDown(0);
 193     return result;
 194 }
 195
 196 void SGTimerQueue::siftDown(int n)
 197 {
 198     // While we have children bigger than us, swap us with the biggest
 199     // child.
 200     while(lchild(n) < _numEntries) {
 201         int bigc = lchild(n);
 202         if(rchild(n) < _numEntries && pri(rchild(n)) > pri(bigc))
 203             bigc = rchild(n);
 204         if(pri(bigc) <= pri(n))
 205             break;
 206         swap(n, bigc);
 207         n = bigc;
 208     }
 209 }
 210
 211 void SGTimerQueue::siftUp(int n)
 212 {
 213     while((n != 0) && (_table[n].pri > _table[parent(n)].pri)) {
 214         swap(n, parent(n));
 215         n = parent(n);
 216     }
 217     siftDown(n);
 218 }
 219
 220 void SGTimerQueue::growArray()
 221 {
 222     _tableSize = ((_tableSize+1)<<1) - 1;
 223     HeapEntry *newTable = new HeapEntry[_tableSize];
 224     for(int i=0; i<_numEntries; i++) {
 225         newTable[i].pri  = _table[i].pri;
 226         newTable[i].timer = _table[i].timer;
 227     }
 228     delete[] _table;
 229     _table = newTable;
 230 }
 231
 232 SGTimer* SGTimerQueue::findByName(const std::string& name) const
 233 {
 234   for (int i=0; i < _numEntries; ++i) {
 235     if (_table[i].timer->name == name) {
 236       return _table[i].timer;
 237     }
 238   }
 239
 240   return NULL;
 241 }