*
**************************************************************************/
+#include "config.h"
+
#include <cerrno>
#include <ctime>
#include <limits>
#include <SDL/SDL.h>
-#include "log.hh"
+#include "debug.hh"
#include "timer.hh"
-#if HAVE_CONFIG_H
-#include "config.h"
-#endif
-
namespace moof {
-scalar timer::gNextFire = std::numeric_limits<scalar>::max();
-std::map<unsigned,timer*> timer::gTimers;
+scalar timer::next_expiration_ = std::numeric_limits<scalar>::max();
+hash<unsigned,timer*,hash_function> timer::timers_;
unsigned timer::new_identifier()
}
id_ = new_identifier();
- gTimers.insert(std::pair<unsigned,timer*>(id_, this));
+ timers_.insert(std::pair<unsigned,timer*>(id_, this));
- if (absolute_ < gNextFire) gNextFire = absolute_;
+ if (absolute_ < next_expiration_) next_expiration_ = absolute_;
}
}
{
if (mode_ != invalid)
{
- gTimers.erase(id_);
+ timers_.erase(id_);
mode_ = invalid;
- if (is_equal(absolute_, gNextFire)) gNextFire = find_next_expiration();
+ if (is_equal(absolute_, next_expiration_))
+ {
+ next_expiration_ = find_next_expiration();
+ }
}
}
if (is_equal(absolute_, t, 1.0)) absolute_ += interval_;
else absolute_ = interval_ + t;
- if (is_equal(absolute, gNextFire)) gNextFire = find_next_expiration();
+ if (is_equal(absolute, next_expiration_))
+ {
+ next_expiration_ = find_next_expiration();
+ }
}
else
{
scalar timer::find_next_expiration()
{
- std::map<unsigned,timer*>::iterator it;
- scalar nextFire = std::numeric_limits<scalar>::max();
+ scalar next_fire = std::numeric_limits<scalar>::max();
- for (it = gTimers.begin(); it != gTimers.end(); ++it)
+ hash<unsigned,timer*,hash_function>::iterator it;
+ for (it = timers_.begin(); it.valid(); ++it)
{
scalar absolute = (*it).second->absolute_;
- if (absolute < nextFire) nextFire = absolute;
+ if (absolute < next_fire) next_fire = absolute;
}
- return nextFire;
+ return next_fire;
}
void timer::fire_expired_timers(scalar t)
{
- std::map<unsigned,timer*>::iterator it;
+ if (next_expiration_ > t) return;
- if (gNextFire > t) return;
-
- for (it = gTimers.begin(); it != gTimers.end(); ++it)
+ hash<unsigned,timer*,hash_function>::iterator it;
+ for (it = timers_.begin(); it.valid(); ++it)
{
timer* timer = (*it).second;
if (timer->is_expired()) timer->fire();
+
+ if (it.end()) break;
}
}
-#if HAVE_CLOCK_GETTIME
+#if USE_CLOCK_GETTIME
// Since the monotonic clock will provide us with the time since the
// computer started, the number of seconds since that time could easily
return ts.tv_sec;
}
-static const time_t reference = set_reference();
+static const time_t reference_ = set_reference();
scalar timer::ticks()
int result = clock_gettime(CLOCK_MONOTONIC, &ts);
ASSERT(result == 0 && "cannot access clock");
- return scalar(ts.tv_sec - reference) +
+ return scalar(ts.tv_sec - reference_) +
scalar(ts.tv_nsec) / 1000000000.0;
}
}
-#else // ! HAVE_CLOCK_GETTIME
+#else // ! USE_CLOCK_GETTIME
// If we don't have posix timers, we'll have to use a different timing
// method. SDL only promises centisecond accuracy, but that's better than
-// a kick in the pants.
+// a kick in the pants.
scalar timer::ticks()
{
SDL_Delay(Uint32(clamp(int(seconds * 1000.0), 0, 1000)));
}
-#endif // HAVE_CLOCK_GETTIME
+#endif // USE_CLOCK_GETTIME
} // namespace moof