X-Git-Url: https://git.dogcows.com/gitweb?p=chaz%2Fyoink;a=blobdiff_plain;f=src%2Fmoof%2Ftimer.cc;h=f16a962dfa688b032ad92da9506a92c6b24ab416;hp=e31e49fdfb23a567ff857e46c4932e483d921fe3;hb=e9a16d767785b1a903a4466ff26265a5f7dae9e5;hpb=6b0a0d0efafe34d48ab344fca3b479553bd4e62c

diff --git a/src/moof/timer.cc b/src/moof/timer.cc
index e31e49f..f16a962 100644
--- a/src/moof/timer.cc
+++ b/src/moof/timer.cc
@@ -9,6 +9,8 @@
 *
 **************************************************************************/
 
+#include "config.h"
+
 #include <cerrno>
 #include <ctime>
 #include <limits>
@@ -22,7 +24,7 @@
 namespace moof {
 
 
-scalar timer::next_expiration_ = std::numeric_limits<scalar>::max();
+scalar timer::next_event_ = std::numeric_limits<scalar>::max();
 hash<unsigned,timer*,hash_function> timer::timers_;
 
 
@@ -56,7 +58,7 @@ void timer::init(const function& function, scalar seconds, mode mode)
 		id_ = new_identifier();
 		timers_.insert(std::pair<unsigned,timer*>(id_, this));
 
-		if (absolute_ < next_expiration_) next_expiration_ = absolute_;
+		if (absolute_ < next_event_) next_event_ = absolute_;
 	}
 }
 
@@ -73,9 +75,9 @@ void timer::invalidate()
 		timers_.erase(id_);
 		mode_ = invalid;
 
-		if (is_equal(absolute_, next_expiration_))
+		if (is_equal(absolute_, next_event_))
 		{
-			next_expiration_ = find_next_expiration();
+			next_event_ = find_next_event();
 		}
 	}
 }
@@ -94,9 +96,9 @@ void timer::fire()
 		if (is_equal(absolute_, t, 1.0)) absolute_ += interval_;
 		else absolute_ = interval_ + t;
 
-		if (is_equal(absolute, next_expiration_))
+		if (is_equal(absolute, next_event_))
 		{
-			next_expiration_ = find_next_expiration();
+			next_event_ = find_next_event();
 		}
 	}
 	else
@@ -106,12 +108,12 @@ void timer::fire()
 }
 
 
-scalar timer::find_next_expiration()
+scalar timer::find_next_event()
 {
 	scalar next_fire = std::numeric_limits<scalar>::max();
 
 	hash<unsigned,timer*,hash_function>::iterator it;
-	for (it = timers_.begin(); it != timers_.end(); ++it)
+	for (it = timers_.begin(); it.valid(); ++it)
 	{
 		scalar absolute = (*it).second->absolute_;
 		if (absolute < next_fire) next_fire = absolute;
@@ -126,6 +128,11 @@ scalar timer::seconds_remaining() const
 	return absolute_ - ticks();
 }
 
+scalar timer::next_expiration() const
+{
+	return absolute_;
+}
+
 bool timer::is_expired() const
 {
 	return seconds_remaining() < 0.0;
@@ -137,25 +144,22 @@ bool timer::is_repeating() const
 }
 
 
-void timer::fire_expired_timers()
-{
-	fire_expired_timers(ticks());
-}
-
 void timer::fire_expired_timers(scalar t)
 {
-	if (next_expiration_ > t) return;
+	if (t < next_event_) return;
 
 	hash<unsigned,timer*,hash_function>::iterator it;
-	for (it = timers_.begin(); it != timers_.end(); ++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
@@ -187,46 +191,43 @@ scalar timer::ticks()
 	ASSERT(result == 0 && "cannot access clock");
 
 	return scalar(ts.tv_sec - reference_) +
-		   scalar(ts.tv_nsec) / 1000000000.0;
+		   scalar(ts.tv_nsec) * SCALAR(0.000000001);
 }
 
 void timer::sleep(scalar seconds, mode mode)
 {
-	struct timespec ts;
-	int ret;
-
 	if (mode == absolute) seconds -= ticks();
-	ts.tv_sec = time_t(seconds);
-	ts.tv_nsec = long((seconds - scalar(ts.tv_sec)) * 1000000000.0);
+	if (seconds < SCALAR(0.0)) return;
 
-	do
-	{
-		ret = nanosleep(&ts, &ts);
-	}
-	while (ret == -1 && errno == EINTR);
+	struct timespec ts;
+	ts.tv_sec = seconds;
+	ts.tv_nsec = (seconds - scalar(ts.tv_sec)) * SCALAR(1000000000.0);
+
+	int ret;
+	do ret = nanosleep(&ts, &ts); while (ret == -1 && errno == EINTR);
 }
 
 
-#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.  It could end up being just as good anyway.
 
 scalar timer::ticks()
 {
-	Uint32 ms = SDL_GetTicks();
-	return scalar(ms / 1000) + scalar(ms % 1000) / 1000.0;
+	return scalar(SDL_GetTicks()) * SCALAR(0.001);
 }
 
 void timer::sleep(scalar seconds, mode mode)
 {
 	if (mode == absolute) seconds -= ticks();
-	SDL_Delay(Uint32(clamp(int(seconds * 1000.0), 0, 1000)));
+	if (seconds < SCALAR(0.0)) return;
+	SDL_Delay(seconds * SCALAR(1000.0));
 }
 
-#endif // HAVE_CLOCK_GETTIME
+#endif // USE_CLOCK_GETTIME
 
 
 } // namespace moof