141 lines
3.6 KiB
C++
141 lines
3.6 KiB
C++
// -*- mode: C++; indent-tabs-mode: nil; -*-
|
|
#ifndef _BLACKBOX_Timer_hh
|
|
#define _BLACKBOX_Timer_hh
|
|
|
|
extern "C" {
|
|
#ifdef TIME_WITH_SYS_TIME
|
|
# include <sys/time.h>
|
|
# include <time.h>
|
|
#else // !TIME_WITH_SYS_TIME
|
|
# ifdef HAVE_SYS_TIME_H
|
|
# include <sys/time.h>
|
|
# else // !HAVE_SYS_TIME_H
|
|
# include <time.h>
|
|
# endif // HAVE_SYS_TIME_H
|
|
#endif // TIME_WITH_SYS_TIME
|
|
}
|
|
|
|
#include <queue>
|
|
#include <algorithm>
|
|
#include <vector>
|
|
|
|
namespace otk {
|
|
|
|
// forward declaration
|
|
class OBTimerQueueManager;
|
|
|
|
typedef void *OBTimeoutData;
|
|
typedef void (*OBTimeoutHandler)(OBTimeoutData);
|
|
|
|
class OBTimer {
|
|
private:
|
|
OBTimerQueueManager *manager;
|
|
OBTimeoutHandler handler;
|
|
OBTimeoutData data;
|
|
bool timing, recur;
|
|
|
|
timeval _start, _timeout;
|
|
|
|
OBTimer(const OBTimer&);
|
|
OBTimer& operator=(const OBTimer&);
|
|
|
|
public:
|
|
OBTimer(OBTimerQueueManager *m, OBTimeoutHandler h, OBTimeoutData d);
|
|
virtual ~OBTimer();
|
|
|
|
void fireTimeout();
|
|
|
|
inline bool isTiming() const { return timing; }
|
|
inline bool isRecurring() const { return recur; }
|
|
|
|
inline const timeval &getTimeout() const { return _timeout; }
|
|
inline const timeval &getStartTime() const { return _start; }
|
|
|
|
timeval timeRemaining(const timeval &tm) const;
|
|
bool shouldFire(const timeval &tm) const;
|
|
timeval endpoint() const;
|
|
|
|
inline void recurring(bool b) { recur = b; }
|
|
|
|
void setTimeout(long t);
|
|
void setTimeout(const timeval &t);
|
|
|
|
void start(); // manager acquires timer
|
|
void stop(); // manager releases timer
|
|
void halt(); // halts the timer
|
|
|
|
bool operator<(const OBTimer& other) const
|
|
{ return shouldFire(other.endpoint()); }
|
|
};
|
|
|
|
|
|
template <class _Tp, class _Sequence, class _Compare>
|
|
class _timer_queue: protected std::priority_queue<_Tp, _Sequence, _Compare> {
|
|
public:
|
|
typedef std::priority_queue<_Tp, _Sequence, _Compare> _Base;
|
|
|
|
_timer_queue(): _Base() {}
|
|
~_timer_queue() {}
|
|
|
|
void release(const _Tp& value) {
|
|
c.erase(std::remove(c.begin(), c.end(), value), c.end());
|
|
// after removing the item we need to make the heap again
|
|
std::make_heap(c.begin(), c.end(), comp);
|
|
}
|
|
bool empty() const { return _Base::empty(); }
|
|
size_t size() const { return _Base::size(); }
|
|
void push(const _Tp& value) { _Base::push(value); }
|
|
void pop() { _Base::pop(); }
|
|
const _Tp& top() const { return _Base::top(); }
|
|
private:
|
|
// no copying!
|
|
_timer_queue(const _timer_queue&) {}
|
|
_timer_queue& operator=(const _timer_queue&) {}
|
|
};
|
|
|
|
struct TimerLessThan {
|
|
bool operator()(const OBTimer* const l, const OBTimer* const r) const {
|
|
return *r < *l;
|
|
}
|
|
};
|
|
|
|
typedef _timer_queue<OBTimer*,
|
|
std::vector<OBTimer*>, TimerLessThan> TimerQueue;
|
|
|
|
//! Manages a queue of OBTimer objects
|
|
/*!
|
|
All OBTimer objects add themself to an OBTimerQueueManager. The manager is
|
|
what fires the timers when their time has elapsed. This is done by having the
|
|
application call the OBTimerQueueManager::fire class in its main event loop.
|
|
*/
|
|
class OBTimerQueueManager {
|
|
private:
|
|
//! A priority queue of all timers being managed by this class.
|
|
TimerQueue timerList;
|
|
public:
|
|
//! Constructs a new OBTimerQueueManager
|
|
OBTimerQueueManager() {}
|
|
//! Destroys the OBTimerQueueManager
|
|
virtual ~OBTimerQueueManager() {}
|
|
|
|
//! Will wait for and fire the next timer in the queue.
|
|
/*!
|
|
The function will stop waiting if an event is received from the X server.
|
|
*/
|
|
virtual void fire();
|
|
|
|
//! Adds a new timer to the queue
|
|
/*!
|
|
@param timer An OBTimer to add to the queue
|
|
*/
|
|
virtual void addTimer(OBTimer* timer);
|
|
//! Removes a timer from the queue
|
|
/*!
|
|
@param timer An OBTimer already in the queue to remove
|
|
*/
|
|
virtual void removeTimer(OBTimer* timer);
|
|
};
|
|
|
|
}
|
|
|
|
#endif // _BLACKBOX_Timer_hh
|