1 files changed, 121 insertions, 28 deletions

diff --git a/src/Timer.cc b/src/Timer.cc
index f35f274..79b0939 100644
--- a/src/Timer.cc
+++ b/src/Timer.cc
@@ -19,64 +19,157 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 // DEALINGS IN THE SOFTWARE.
 
-// stupid macros needed to access some functions in version 2 of the GNU C
-// library
-#ifndef   _GNU_SOURCE
-#  define _GNU_SOURCE
+//use GNU extensions
+#ifndef  _GNU_SOURCE
+#define _GNU_SOURCE
 #endif // _GNU_SOURCE
 
-#ifdef    HAVE_CONFIG_H
-#  include "../config.h"
+#ifdef          HAVE_CONFIG_H
+#include "../config.h"
 #endif // HAVE_CONFIG_H
 
-#include "BaseDisplay.hh"
 #include "Timer.hh"
+#include <sys/types.h>
+#include <unistd.h>
+#include <cassert>
 
+//static var
+BTimer::TimerList BTimer::m_timerlist;
 
-BTimer::BTimer(BaseDisplay *d, TimeoutHandler *h) {
-  display = d;
-  handler = h;
-
-  once = timing = False;
+BTimer::BTimer(TimeoutHandler *h):
+m_handler(h),
+m_timing(false),
+m_once(false) {
 }
 
 
 BTimer::~BTimer(void) {
-  if (timing) stop();
+        if (isTiming()) stop();
 }
 
 
 void BTimer::setTimeout(long t) {
-  _timeout.tv_sec = t / 1000;
-  _timeout.tv_usec = t;
-  _timeout.tv_usec -= (_timeout.tv_sec * 1000);
-  _timeout.tv_usec *= 1000;
+        m_timeout.tv_sec = t / 1000;
+        m_timeout.tv_usec = t;
+        m_timeout.tv_usec -= (m_timeout.tv_sec * 1000);
+        m_timeout.tv_usec *= 1000;
 }
 
 
 void BTimer::setTimeout(timeval t) {
-  _timeout.tv_sec = t.tv_sec;
-  _timeout.tv_usec = t.tv_usec;
+        m_timeout.tv_sec = t.tv_sec;
+        m_timeout.tv_usec = t.tv_usec;
 }
 
 
 void BTimer::start(void) {
-  gettimeofday(&_start, 0);
+        gettimeofday(&m_start, 0);
 
-  if (! timing) {
-    timing = True;
-    display->addTimer(this);
-  }
+        if (! m_timing) {
+                m_timing = true;
+                addTimer(this); //add us to the list
+        }
 }
 
 
 void BTimer::stop(void) {
-  timing = False;
-
-  display->removeTimer(this);
+        m_timing = false;
+        removeTimer(this); //remove us from the list
 }
 
 
 void BTimer::fireTimeout(void) {
-  if (handler) handler->timeout();
+        if (m_handler) m_handler->timeout();
+}
+
+void BTimer::updateTimers(int fd) {
+        fd_set rfds;
+        timeval now, tm, *timeout = 0;
+
+        FD_ZERO(&rfds);
+        FD_SET(fd, &rfds);
+
+        if (m_timerlist.size() > 0) {
+                gettimeofday(&now, 0);
+
+                tm.tv_sec = tm.tv_usec = 0l;
+
+                BTimer *timer = m_timerlist.front();
+
+                tm.tv_sec = timer->getStartTime().tv_sec +
+                        timer->getTimeout().tv_sec - now.tv_sec;
+                tm.tv_usec = timer->getStartTime().tv_usec +
+                        timer->getTimeout().tv_usec - now.tv_usec;
+
+                while (tm.tv_usec >= 1000000) {
+                        tm.tv_sec++;
+                        tm.tv_usec -= 1000000;
+                }
+
+                while (tm.tv_usec < 0) {
+                        if (tm.tv_sec > 0) {
+                                tm.tv_sec--;
+                                tm.tv_usec += 1000000;
+                        } else {
+                                tm.tv_usec = 0;
+                                break;
+                        }
+                }
+
+                timeout = &tm;
+        }
+
+        select(fd + 1, &rfds, 0, 0, timeout);
+
+        // check for timer timeout
+        gettimeofday(&now, 0);
+
+        TimerList::iterator it = m_timerlist.begin();
+        //must check end ...the timer might remove
+        //it self from the list (should be fixed in the future)
+        for(; it != m_timerlist.end(); ++it) {
+                //This is to make sure we don't get an invalid iterator
+                //when we do fireTimeout
+                BTimer &t = *(*it);
+                tm.tv_sec = t.getStartTime().tv_sec +
+                t.getTimeout().tv_sec;
+                tm.tv_usec = t.getStartTime().tv_usec +
+                t.getTimeout().tv_usec;
+
+                if ((now.tv_sec < tm.tv_sec) ||
+                        (now.tv_sec == tm.tv_sec && now.tv_usec < tm.tv_usec))
+                        break;
+
+                t.fireTimeout();
+                // restart the current timer so that the start time is updated
+                if (! t.doOnce())
+                        t.start();
+                else {
+                        t.stop();                       
+                        it--;
+                }                                       
+        }
+}
+
+void BTimer::addTimer(BTimer *timer) {
+        assert(timer);
+
+        TimerList::iterator it = m_timerlist.begin();
+        TimerList::iterator it_end = m_timerlist.end();
+        int index = 0;
+        for (; it != it_end; ++it, ++index) {
+                if (((*it)->getTimeout().tv_sec > timer->getTimeout().tv_sec) ||
+                                (((*it)->getTimeout().tv_sec == timer->getTimeout().tv_sec) &&
+                                ((*it)->getTimeout().tv_usec >= timer->getTimeout().tv_usec))) {
+                        break;
+                }
+        }
+        m_timerlist.insert(it, timer); 
+
+}
+
+void BTimer::removeTimer(BTimer *timer) {
+        assert(timer);
+        m_timerlist.remove(timer);
 }
+