-/*
-This file is part of libmspframework
-Copyright © 2006 Mikko Rasa, Mikkosoft Productions
-Distributed under the LGPL
-*/
+#include <algorithm>
#include "timer.h"
#include "utils.h"
namespace Msp {
namespace Time {
-Timer::Timer(const Time::TimeDelta &d):
- interval(d),
- timeout(now()+d)
-{
- MutexLock l(set_mutex);
- timers.insert(this);
- thread.nudge();
-}
-
Timer::~Timer()
{
- MutexLock l(set_mutex);
- timers.erase(this);
- thread.nudge();
-}
-
-Timer::ThreadProxy Timer::thread;
-Mutex Timer::set_mutex;
-set<Timer *> Timer::timers;
-
-Timer::Thread::Thread():
- done(false)
-{
- launch();
+ for(vector<SlotProxy>::iterator i=slots.begin(); i!=slots.end(); ++i)
+ delete i->slot;
}
-/**
-Notifies the thread that a change in the timers occurred.
-*/
-void Timer::Thread::nudge()
+Timer::Slot &Timer::add(const TimeDelta &td)
{
+ Slot *s = new Slot(td);
+ mutex.lock();
+ slots.push_back(s);
+ push_heap(slots.begin(), slots.end());
+ mutex.unlock();
sem.signal();
+ return *s;
}
-/**
-Tells the thread to finish and terminate gracefully. This function will return
-after the thread has terminated.
-*/
-void Timer::Thread::finish()
+Timer::Slot &Timer::add(const TimeStamp &ts)
{
- if(!done)
+ Slot *s = new Slot(ts);
{
- done=true;
- sem.signal();
+ MutexLock l(mutex);
+ slots.push_back(s);
+ push_heap(slots.begin(), slots.end());
}
+ sem.signal();
+ return *s;
+}
- join();
+void Timer::cancel(Slot &slot)
+{
+ MutexLock l(mutex);
+ for(vector<SlotProxy>::iterator i=slots.begin(); i!=slots.end(); ++i)
+ if(i->slot==&slot)
+ {
+ delete i->slot;
+ slots.erase(i);
+ make_heap(slots.begin(), slots.end());
+ return;
+ }
}
-void Timer::Thread::main()
+void Timer::tick(bool block)
{
- while(!done)
+ Slot *next = 0;
{
- set_mutex.lock();
- Timer *next=0;
- TimeStamp next_ts;
- for(set<Timer *>::iterator i=timers.begin(); i!=timers.end(); ++i)
+ MutexLock l(mutex);
+ while(1)
{
- const TimeStamp &ts=(*i)->get_timeout();
- if(ts<next_ts || !next)
+ if(slots.empty())
{
- next_ts=ts;
- next=*i;
+ if(block)
+ sem.wait();
+ else
+ return;
}
+
+ next = slots.begin()->slot;
+ const TimeStamp &stamp = next->get_timeout();
+ const TimeStamp t = now();
+ if(stamp<=t)
+ break;
+ else if(block)
+ sem.wait(stamp-t);
+ else
+ return;
}
- set_mutex.unlock();
- if(next)
+ pop_heap(slots.begin(), slots.end());
+ slots.pop_back();
+ }
+
+ try
+ {
+ if(next->signal_timeout.emit() && next->increment())
{
- const TimeStamp t=now();
- if(next_ts<=t || sem.wait(next_ts-t)==1)
- {
- if(next->signal_timeout.emit())
- next->timeout+=next->interval;
- else
- delete next;
- }
+ MutexLock l(mutex);
+ slots.push_back(next);
+ push_heap(slots.begin(), slots.end());
}
else
- sem.wait();
+ delete next;
}
+ catch(...)
+ {
+ delete next;
+ throw;
+ }
+}
+
+TimeStamp Timer::get_next_timeout() const
+{
+ if(slots.empty())
+ return TimeStamp();
+ return slots.begin()->slot->get_timeout();
}
-/**
-Creates the thread if it doesn't exist, otherwise nudges it.
-*/
-void Timer::ThreadProxy::nudge()
+
+Timer::Slot::Slot(const TimeDelta &td):
+ interval(td),
+ timeout(now()+interval)
+{ }
+
+Timer::Slot::Slot(const TimeStamp &ts):
+ timeout(ts)
+{ }
+
+bool Timer::Slot::increment()
{
- if(!thread)
- thread=new Thread();
- else
- thread->nudge();
+ if(!interval)
+ return false;
+ timeout += interval;
+ return true;
}
-Timer::ThreadProxy::~ThreadProxy()
+
+Timer::SlotProxy::SlotProxy(Slot *s):
+ slot(s)
+{ }
+
+bool Timer::SlotProxy::operator<(const SlotProxy &sp) const
{
- if(thread)
- {
- thread->finish();
- delete thread;
- }
+ return slot->get_timeout()>sp.slot->get_timeout();
}
} // namespace Time