OBTimer::OBTimer(OBTimerQueueManager *m, OBTimeoutHandler h, OBTimeoutData d)
{
- manager = m;
- handler = h;
- data = d;
+ _manager = m;
+ _handler = h;
+ _data = d;
- recur = timing = false;
+ _recur = _timing = false;
}
OBTimer::~OBTimer(void)
{
- if (timing) stop();
+ if (_timing) stop();
}
{
gettimeofday(&_start, 0);
- if (! timing) {
- timing = true;
- manager->addTimer(this);
+ if (! _timing) {
+ _timing = true;
+ _manager->addTimer(this);
}
}
void OBTimer::stop(void)
{
- if (timing) {
- timing = false;
+ if (_timing) {
+ _timing = false;
- manager->removeTimer(this);
+ _manager->removeTimer(this);
}
}
-void OBTimer::fireTimeout(void)
+void OBTimer::fire(void)
{
- if (handler)
- handler(data);
+ if (_handler)
+ _handler(_data);
}
-timeval OBTimer::timeRemaining(const timeval &tm) const
+timeval OBTimer::remainingTime(const timeval &tm) const
{
- timeval ret = endpoint();
+ timeval ret = endTime();
ret.tv_sec -= tm.tv_sec;
ret.tv_usec -= tm.tv_usec;
}
-timeval OBTimer::endpoint(void) const
+timeval OBTimer::endTime(void) const
{
timeval ret;
bool OBTimer::shouldFire(const timeval &tm) const
{
- timeval end = endpoint();
+ timeval end = endTime();
return ! ((tm.tv_sec < end.tv_sec) ||
(tm.tv_sec == end.tv_sec && tm.tv_usec < end.tv_usec));
class OBTimer {
private:
//! The manager which to add ourself to and remove ourself after we are done
- OBTimerQueueManager *manager;
+ OBTimerQueueManager *_manager;
//! The function to call when the time elapses
- OBTimeoutHandler handler;
+ OBTimeoutHandler _handler;
//! The data which gets passed along to the OBTimeoutHandler
- OBTimeoutData data;
+ OBTimeoutData _data;
//! Determines if the timer is currently started
- bool timing;
+ bool _timing;
//! When this is true, the timer will reset itself to fire again every time
- bool recur;
+ bool _recur;
//! The time at which the timer started
timeval _start;
virtual ~OBTimer();
//! Fires the timer, calling its OBTimeoutHandler
- void fireTimeout();
+ void fire();
//! Returns if the OBTimer is started and timing
- inline bool isTiming() const { return timing; }
+ inline bool timing() const { return _timing; }
//! Returns if the OBTimer is going to repeat
- inline bool isRecurring() const { return recur; }
+ inline bool recurring() const { return _recur; }
//! Gets the amount of time the OBTimer should last before firing
- inline const timeval &getTimeout() const { return _timeout; }
+ inline const timeval &timeout() const { return _timeout; }
//! Gets the time at which the OBTimer started
- inline const timeval &getStartTime() const { return _start; }
+ inline const timeval &startTime() const { return _start; }
//! Gets the amount of time left before the OBTimer fires
- timeval timeRemaining(const timeval &tm) const;
+ timeval remainingTime(const timeval &tm) const;
//! Returns if the OBTimer is past its timeout time, and should fire
bool shouldFire(const timeval &tm) const;
//! Gets the time at which the OBTimer will fire
- timeval endpoint() const;
+ timeval endTime() const;
//! Sets the OBTimer to repeat or not
/*!
@param b If true, the timer is set to repeat; otherwise, it will fire only
once
*/
- inline void recurring(bool b) { recur = b; }
+ inline void setRecurring(bool b) { _recur = b; }
//! Sets the amount of time for the OBTimer to last in milliseconds
/*!
@return true if this OBTimer will fire before 'other'; otherwise, false
*/
bool operator<(const OBTimer& other) const
- { return shouldFire(other.endpoint()); }
+ { return shouldFire(other.endTime()); }
};
}