2 # include <simgear_config.h>
5 #include "event_mgr.hxx"
7 #include <simgear/debug/logstream.hxx>
9 void SGEventMgr::add(const std::string& name, SGCallback* cb,
10 double interval, double delay,
11 bool repeat, bool simtime)
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...
18 SGTimer* t = new SGTimer;
19 t->interval = interval;
25 SGTimerQueue* q = simtime ? &_simQueue : &_rtQueue;
41 SGEventMgr::SGEventMgr() :
47 SGEventMgr::~SGEventMgr()
52 void SGEventMgr::unbind()
58 void SGEventMgr::init()
61 SG_LOG(SG_GENERAL, SG_WARN, "duplicate init of SGEventMgr");
66 void SGEventMgr::shutdown()
74 void SGEventMgr::update(double delta_time_sec)
76 _simQueue.update(delta_time_sec);
78 double rt = _rtProp ? _rtProp->getDoubleValue() : 0;
82 void SGEventMgr::removeTask(const std::string& name)
84 // due to the ordering of the event-mgr in FG, tasks can be removed
85 // after we are shutdown (and hence, have all been cleared). Guard
86 // against this so we don't generate warnings below.
91 SGTimer* t = _simQueue.findByName(name);
94 } else if ((t = _rtQueue.findByName(name))) {
97 SG_LOG(SG_GENERAL, SG_WARN, "removeTask: no task found with name:" << name);
101 // mark as not repeating so that the SGTimerQueue::update()
109 ////////////////////////////////////////////////////////////////////////
111 // This is the priority queue implementation:
112 ////////////////////////////////////////////////////////////////////////
114 SGTimerQueue::SGTimerQueue(int size)
119 while(size > _tableSize)
120 _tableSize = ((_tableSize + 1)<<1) - 1;
122 _table = new HeapEntry[_tableSize];
123 for(int i=0; i<_tableSize; i++) {
130 SGTimerQueue::~SGTimerQueue()
136 void SGTimerQueue::clear()
139 for(int i=0; i<_numEntries; i++) {
140 delete _table[i].timer;
145 // clear entire table to empty
146 for(int i=0; i<_tableSize; i++) {
152 void SGTimerQueue::update(double deltaSecs)
155 while(_numEntries && nextTime() <= _now) {
156 SGTimer* t = remove();
158 insert(t, t->interval);
159 // warning: this is not thread safe
160 // but the entire timer queue isn't either
169 void SGTimerQueue::insert(SGTimer* timer, double time)
171 if(_numEntries >= _tableSize)
175 _table[_numEntries-1].pri = -(_now + time);
176 _table[_numEntries-1].timer = timer;
178 siftUp(_numEntries-1);
181 SGTimer* SGTimerQueue::remove(SGTimer* t)
184 for(entry=0; entry<_numEntries; entry++)
185 if(_table[entry].timer == t)
187 if(entry == _numEntries)
190 // Swap in the last item in the table, and sift down
191 swap(entry, _numEntries-1);
198 SGTimer* SGTimerQueue::remove()
200 if(_numEntries == 0) {
202 } else if(_numEntries == 1) {
204 return _table[0].timer;
207 SGTimer *result = _table[0].timer;
208 _table[0] = _table[_numEntries - 1];
214 void SGTimerQueue::siftDown(int n)
216 // While we have children bigger than us, swap us with the biggest
218 while(lchild(n) < _numEntries) {
219 int bigc = lchild(n);
220 if(rchild(n) < _numEntries && pri(rchild(n)) > pri(bigc))
222 if(pri(bigc) <= pri(n))
229 void SGTimerQueue::siftUp(int n)
231 while((n != 0) && (_table[n].pri > _table[parent(n)].pri)) {
238 void SGTimerQueue::growArray()
240 _tableSize = ((_tableSize+1)<<1) - 1;
241 HeapEntry *newTable = new HeapEntry[_tableSize];
242 for(int i=0; i<_numEntries; i++) {
243 newTable[i].pri = _table[i].pri;
244 newTable[i].timer = _table[i].timer;
250 SGTimer* SGTimerQueue::findByName(const std::string& name) const
252 for (int i=0; i < _numEntries; ++i) {
253 if (_table[i].timer->name == name) {
254 return _table[i].timer;