simgear/structure/event_mgr.cxx

   1 #include "event_mgr.hxx"
   2
   3 void SGEventMgr::add(SGCallback* cb,
   4                      double interval, double delay,
   5                      bool repeat, bool simtime)
   6 {
   7     // Clamp the delay value to 1 usec, so that user code can use
   8     // "zero" as a synonym for "next frame".
   9     if(delay <= 0) delay = 0.000001;
  10
  11     SGTimer* t = new SGTimer;
  12     t->interval = interval;
  13     t->callback = cb;
  14     t->mgr = this;
  15     t->repeat = repeat;
  16     t->simtime = simtime;
  17
  18     SGTimerQueue* q = simtime ? &_simQueue : &_rtQueue;
  19
  20     q->insert(t, delay);
  21 }
  22
  23 void SGTimer::run()
  24 {
  25     (*callback)();
  26
  27     if(repeat) {
  28         SGTimerQueue* q = simtime ? &mgr->_simQueue : &mgr->_rtQueue;
  29         q->insert(this, interval);
  30     } else {
  31         delete callback;
  32         delete this;
  33     }
  34 }
  35
  36 void SGEventMgr::update(double delta_time_sec)
  37 {
  38     _simQueue.update(delta_time_sec);
  39
  40     double rt = _rtProp ? _rtProp->getDoubleValue() : 0;
  41     _rtQueue.update(rt);
  42 }
  43
  44 ////////////////////////////////////////////////////////////////////////
  45 // SGTimerQueue
  46 // This is the priority queue implementation:
  47 ////////////////////////////////////////////////////////////////////////
  48
  49 SGTimerQueue::SGTimerQueue(int size)
  50 {
  51     _now = 0;
  52     _numEntries = 0;
  53     _tableSize = 1;
  54     while(size > _tableSize)
  55         _tableSize = ((_tableSize + 1)<<1) - 1;
  56
  57     _table = new HeapEntry[_tableSize];
  58     for(int i=0; i<_tableSize; i++) {
  59         _table[i].pri = 0;
  60         _table[i].timer = 0;
  61     }
  62 }
  63
  64
  65 SGTimerQueue::~SGTimerQueue()
  66 {
  67     for(int i=0; i<_numEntries; i++) {
  68         delete _table[i].timer;
  69         _table[i].timer = 0;
  70     }
  71     _numEntries = 0;
  72     delete[] _table;
  73     _table = 0;
  74     _tableSize = 0;
  75 }
  76
  77 void SGTimerQueue::update(double deltaSecs)
  78 {
  79     _now += deltaSecs;
  80     while(_numEntries && nextTime() <= _now) {
  81         SGTimer* t = remove();
  82         t->run();
  83     }
  84 }
  85
  86 void SGTimerQueue::insert(SGTimer* timer, double time)
  87 {
  88     if(_numEntries >= _tableSize)
  89         growArray();
  90
  91     _numEntries++;
  92     _table[_numEntries-1].pri = -(_now + time);
  93     _table[_numEntries-1].timer = timer;
  94
  95     siftUp(_numEntries-1);
  96 }
  97
  98 SGTimer* SGTimerQueue::remove(SGTimer* t)
  99 {
 100     int entry;
 101     for(entry=0; entry<_numEntries; entry++)
 102         if(_table[entry].timer == t)
 103             break;
 104     if(entry == _numEntries)
 105         return 0;
 106
 107     // Swap in the last item in the table, and sift down
 108     swap(entry, _numEntries-1);
 109     _numEntries--;
 110     siftDown(entry);
 111
 112     return t;
 113 }
 114
 115 SGTimer* SGTimerQueue::remove()
 116 {
 117     if(_numEntries == 0) {
 118         return 0;
 119     } else if(_numEntries == 1) {
 120         _numEntries = 0;
 121         return _table[0].timer;
 122     }
 123
 124     SGTimer *result = _table[0].timer;
 125     _table[0] = _table[_numEntries - 1];
 126     _numEntries--;
 127     siftDown(0);
 128     return result;
 129 }
 130
 131 void SGTimerQueue::siftDown(int n)
 132 {
 133     // While we have children bigger than us, swap us with the biggest
 134     // child.
 135     while(lchild(n) < _numEntries) {
 136         int bigc = lchild(n);
 137         if(rchild(n) < _numEntries && pri(rchild(n)) > pri(bigc))
 138             bigc = rchild(n);
 139         if(pri(bigc) <= pri(n))
 140             break;
 141         swap(n, bigc);
 142         n = bigc;
 143     }
 144 }
 145
 146 void SGTimerQueue::siftUp(int n)
 147 {
 148     while((n != 0) && (_table[n].pri > _table[parent(n)].pri)) {
 149         swap(n, parent(n));
 150         n = parent(n);
 151     }
 152     siftDown(n);
 153 }
 154
 155 void SGTimerQueue::growArray()
 156 {
 157     _tableSize = ((_tableSize+1)<<1) - 1;
 158     HeapEntry *newTable = new HeapEntry[_tableSize];
 159     for(int i=0; i<_numEntries; i++) {
 160         newTable[i].pri  = _table[i].pri;
 161         newTable[i].timer = _table[i].timer;
 162     }
 163     delete[] _table;
 164     _table = newTable;
 165 }