Move non-oneliner functions out of RefPtr class declaration
[libs/core.git] / source / time / timer.cpp
1 #include <algorithm>
2 #include <msp/core/raii.h>
3 #include "timer.h"
4 #include "utils.h"
5
6 using namespace std;
7
8 namespace Msp {
9 namespace Time {
10
11 Timer::Timer():
12         sem(1),
13         blocking(false)
14 { }
15
16 Timer::~Timer()
17 {
18         for(vector<SlotProxy>::iterator i=slots.begin(); i!=slots.end(); ++i)
19                 delete i->slot;
20 }
21
22 Timer::Slot &Timer::add(const TimeDelta &td)
23 {
24         Slot *s = new Slot(td);
25         MutexLock l(mutex);
26         slots.push_back(s);
27         push_heap(slots.begin(), slots.end());
28         if(blocking)
29                 sem.signal();
30         return *s;
31 }
32
33 Timer::Slot &Timer::add(const TimeStamp &ts)
34 {
35         Slot *s = new Slot(ts);
36         MutexLock l(mutex);
37         slots.push_back(s);
38         push_heap(slots.begin(), slots.end());
39         if(blocking)
40                 sem.signal();
41         return *s;
42 }
43
44 void Timer::cancel(Slot &slot)
45 {
46         MutexLock l(mutex);
47         for(vector<SlotProxy>::iterator i=slots.begin(); i!=slots.end(); ++i)
48                 if(i->slot==&slot)
49                 {
50                         delete i->slot;
51                         slots.erase(i);
52                         make_heap(slots.begin(), slots.end());
53                         return;
54                 }
55 }
56
57 void Timer::tick(bool block)
58 {
59         if(block)
60                 tick();
61         else
62                 tick(zero);
63 }
64
65 void Timer::tick()
66 {
67         do_tick(-sec);
68 }
69
70 void Timer::tick(const TimeDelta &timeout)
71 {
72         if(timeout<zero)
73                 throw invalid_argument("Timer::tick");
74
75         do_tick(timeout);
76 }
77
78 void Timer::do_tick(const TimeDelta &timeout)
79 {
80         TimeStamp deadline;
81         if(timeout>=zero)
82                 deadline = now()+timeout;
83
84         Slot *next = 0;
85         {
86                 MutexLock l(mutex);
87                 while(1)
88                 {
89                         TimeStamp stamp;
90                         TimeStamp t = now();
91                         if(!slots.empty())
92                         {
93                                 next = slots.begin()->slot;
94                                 stamp = next->get_timeout();
95                                 if(stamp<=t)
96                                         break;
97                         }
98
99                         if(timeout && (!deadline || t<deadline))
100                         {
101                                 SetFlag setf(blocking);
102                                 mutex.unlock();
103                                 if(stamp && (!deadline || stamp<deadline))
104                                         sem.wait(stamp-t);
105                                 else if(deadline)
106                                         sem.wait(deadline-t);
107                                 else
108                                         sem.wait();
109                                 mutex.lock();
110                                 // The slots may have changed while waiting so check again
111                                 continue;
112                         }
113                         else
114                                 return;
115                 }
116
117                 pop_heap(slots.begin(), slots.end());
118                 slots.pop_back();
119         }
120
121         try
122         {
123                 if(next->signal_timeout.emit() && next->increment())
124                 {
125                         MutexLock l(mutex);
126                         slots.push_back(next);
127                         push_heap(slots.begin(), slots.end());
128                 }
129                 else
130                         delete next;
131         }
132         catch(...)
133         {
134                 delete next;
135                 throw;
136         }
137 }
138
139 TimeStamp Timer::get_next_timeout() const
140 {
141         if(slots.empty())
142                 return TimeStamp();
143         return slots.begin()->slot->get_timeout();
144 }
145
146
147 Timer::Slot::Slot(const TimeDelta &td):
148         interval(td),
149         timeout(now()+interval)
150 { }
151
152 Timer::Slot::Slot(const TimeStamp &ts):
153         timeout(ts)
154 { }
155
156 bool Timer::Slot::increment()
157 {
158         if(!interval)
159                 return false;
160         timeout += interval;
161         return true;
162 }
163
164
165 Timer::SlotProxy::SlotProxy(Slot *s):
166         slot(s)
167 { }
168
169 bool Timer::SlotProxy::operator<(const SlotProxy &sp) const
170 {
171         return slot->get_timeout()>sp.slot->get_timeout();
172 }
173
174 } // namespace Time
175 } // namespace Msp