Blinker

1) /* Blinker

2)    Copyright 2011-2014 Stefan Schuermans <stefan@blinkenarea.org>

3)    Copyleft GNU public license - http://www.gnu.org/copyleft/gpl.html
4)    a blinkenarea.org project */
5) 
6) #include <map>
7) #include <set>
8) 
9) #include "CallMgr.h"

10) #include "Io.h"
11) #include "IoCallee.h"

12) #include "Time.h"
13) #include "TimeCallee.h"
14) 
15) namespace Blinker {
16) 
17) /// constructor
18) CallMgr::CallMgr()
19) {
20) }
21) 
22) /// destructor
23) CallMgr::~CallMgr()
24) {
25) }
26) 

27) /**
28)  * @brief cancel callback at read I/O event
29)  * @param[in] callee whom not to call
30)  * @param[in] io I/O object not to monitor for readability any more
31)  */
32) void CallMgr::cancelIoReadCall(IoCallee *callee, Io *io)
33) {
34)   // remove callee for this I/O object
35)   IoCallees &callees = m_iosRead[io];
36)   callees.erase(callee);
37) 
38)   // no more callees -> remove I/O object
39)   if (callees.empty())
40)     m_iosRead.erase(io);
41) }
42) 
43) /**
44)  * @brief request callback at read I/O event
45)  * @param[in] callee whom to call
46)  * @param[in] io I/O object to monitor for readability
47)  */
48) void CallMgr::requestIoReadCall(IoCallee *callee, Io *io)
49) {
50)   m_iosRead[io].insert(callee);
51) }
52) 
53) /**
54)  * @brief cancel callback at write I/O event
55)  * @param[in] callee whom not to call
56)  * @param[in] io I/O object not to monitor for writability any more
57)  */
58) void CallMgr::cancelIoWriteCall(IoCallee *callee, Io *io)
59) {
60)   // remove callee for this I/O object
61)   IoCallees &callees = m_iosWrite[io];
62)   callees.erase(callee);
63) 
64)   // no more callees -> remove I/O object
65)   if (callees.empty())
66)     m_iosWrite.erase(io);
67) }
68) 
69) /**
70)  * @brief request callback at write I/O event
71)  * @param[in] callee whom to call
72)  * @param[in] io I/O object to monitor for writability
73)  */
74) void CallMgr::requestIoWriteCall(IoCallee *callee, Io *io)
75) {
76)   m_iosWrite[io].insert(callee);
77) }
78) 

79) /**
80)  * @brief cancel callback at certain time
81)  * @param[in] callee whom not to call
82)  */
83) void CallMgr::cancelTimeCall(TimeCallee *callee)
84) {
85)   // find time a call is registered at
86)   TimeCalleeMap::iterator itCallee;
87)   itCallee = m_timeCallees.find(callee);
88)   if (itCallee == m_timeCallees.end())
89)     return; // no call registered
90)   const Time &time = itCallee->second;
91) 
92)   // remove registered call
93)   m_times[time].erase(callee);
94)   m_timeCallees.erase(itCallee);
95) }
96) 
97) /**
98)  * @brief request callback at certain time
99)  * @param[in] callee whom to call
100)  * @param[in] time when to call
101)  *
102)  * this cancels a previous time call request from callee
103)  */
104) void CallMgr::requestTimeCall(TimeCallee *callee, const Time &time)
105) {
106)   // cancel previous call
107)   cancelTimeCall(callee);
108) 
109)   // register call at new time
110)   m_times[time].insert(callee);
111)   m_timeCallees[callee] = time;
112) }
113) 
114) /// run call manager
115) void CallMgr::run()
116) {

117)   while (!m_times.empty() || !m_iosRead.empty() || !m_iosWrite.empty()) {
118) 
119)     // get time until first call time
120)     Time timeout = m_times.begin()->first - Time::now();
121) 
122)     // time already passed or reached
123)     if (timeout <= Time::zero) {
124) 
125)       // get time callees and remove entry from time map
126)       TimeCallees timeCallees = m_times.begin()->second;
127)       m_times.erase(m_times.begin());
128) 
129)       // call time callees
130)       TimeCallees::const_iterator itTC;
131)       for (itTC = timeCallees.begin(); itTC != timeCallees.end(); ++itTC) {
132)         m_timeCallees.erase(*itTC); // first remove request from callee map
133)         (*itTC)->timeCall(); // then call callee
134)       }
135) 
136)     } // if timeout
137) 
138)     // wait for I/O events
139)     IoMap::const_iterator itM;
140)     Io::Set rd, wr;
141)     for (itM = m_iosRead.begin(); itM != m_iosRead.end(); ++itM)
142)       rd.insert(itM->first);
143)     for (itM = m_iosWrite.begin(); itM != m_iosWrite.end(); ++itM)
144)       wr.insert(itM->first);
145)     Io::wait(rd, wr, timeout);
146) 
147)     // call I/O callees with pending events
148)     Io::Set::const_iterator itS;
149)     IoCallees::const_iterator itIC;
150)     for (itS = rd.begin(); itS != rd.end(); ++itS) {
151)       const IoCallees &ioCallees = m_iosRead[*itS];
152)       for (itIC = ioCallees.begin(); itIC != ioCallees.end(); ++itIC)
153)         (*itIC)->ioReadCall(*itS);
154)     }
155)     for (itS = wr.begin(); itS != wr.end(); ++itS) {
156)       const IoCallees &ioCallees = m_iosWrite[*itS];
157)       for (itIC = ioCallees.begin(); itIC != ioCallees.end(); ++itIC)
158)         (*itIC)->ioWriteCall(*itS);

159)     }
160) 

161)   } // while m_times m_iosRead m_iosWrite