00001
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032 #ifdef _MSC_VER
00033 #pragma warning(disable:4786)
00034 #endif
00035 #include "EventHandler.h"
00036 #include "IEventOwner.h"
00037 #include "Event.h"
00038 #include "TcpSocket.h"
00039 #include "ListenSocket.h"
00040
00041
00042 #ifdef SOCKETS_NAMESPACE
00043 namespace SOCKETS_NAMESPACE {
00044 #endif
00045
00046
00047 EventHandler::EventHandler(StdLog *p) : SocketHandler(p), m_quit(false)
00048 {
00049 EnableRelease();
00050 }
00051
00052
00053 EventHandler::EventHandler(IMutex& m,StdLog *p) : SocketHandler(m, p), m_quit(false)
00054 {
00055 EnableRelease();
00056 }
00057
00058
00059 EventHandler::~EventHandler()
00060 {
00061 while (m_events.size())
00062 {
00063 std::list<Event *>::iterator it = m_events.begin();
00064 Event *e = *it;
00065 e -> GetFrom() -> SetHandlerInvalid();
00066 delete e;
00067 m_events.erase(it);
00068 }
00069 }
00070
00071
00072 bool EventHandler::GetTimeUntilNextEvent(struct timeval *tv)
00073 {
00074 if (!m_events.size())
00075 return false;
00076 std::list<Event *>::iterator it = m_events.begin();
00077 if (it != m_events.end())
00078 {
00079 EventTime now;
00080 mytime_t diff = (*it) -> GetTime() - now;
00081 if (diff < 1)
00082 {
00083 diff = 1;
00084 }
00085 tv -> tv_sec = static_cast<long>(diff / 1000000);
00086 tv -> tv_usec = static_cast<long>(diff % 1000000);
00087 return true;
00088 }
00089 return false;
00090 }
00091
00092
00093 void EventHandler::CheckEvents()
00094 {
00095 EventTime now;
00096 std::list<Event *>::iterator it = m_events.begin();
00097 while (it != m_events.end() && (*it) -> GetTime() < now)
00098 {
00099 Event *e = *it;
00100 Socket *s = dynamic_cast<Socket *>(e -> GetFrom());
00101
00102
00103
00104
00105
00106 if (!s || (s && Valid( e -> Data() )))
00107 {
00108 e -> GetFrom() -> OnEvent(e -> GetID());
00109 }
00110 for (it = m_events.begin(); it != m_events.end(); ++it)
00111 if (*it == e)
00112 {
00113 delete e;
00114 break;
00115 }
00116 if (it != m_events.end())
00117 m_events.erase(it);
00118 it = m_events.begin();
00119 }
00120 }
00121
00122
00123 long EventHandler::AddEvent(IEventOwner *from,long sec,long usec)
00124 {
00125 Socket *s = dynamic_cast<Socket *>(from);
00126 Event *e = new Event(from, sec, usec, s ? s -> UniqueIdentifier() : 0);
00127 std::list<Event *>::iterator it = m_events.begin();
00128 while (it != m_events.end() && *(*it) < *e)
00129 {
00130 ++it;
00131 }
00132 m_events.insert(it, e);
00133 Release();
00134 return e -> GetID();
00135 }
00136
00137
00138 void EventHandler::ClearEvents(IEventOwner *from)
00139 {
00140 bool repeat;
00141 do
00142 {
00143 repeat = false;
00144 for (std::list<Event *>::iterator it = m_events.begin(); it != m_events.end(); ++it)
00145 {
00146 Event *e = *it;
00147 if (e -> GetFrom() == from)
00148 {
00149 delete e;
00150 m_events.erase(it);
00151 repeat = true;
00152 break;
00153 }
00154 }
00155 } while (repeat);
00156 }
00157
00158
00159 void EventHandler::EventLoop()
00160 {
00161 while (!m_quit)
00162 {
00163 struct timeval tv;
00164 if (GetTimeUntilNextEvent(&tv))
00165 {
00166 Select(&tv);
00167 CheckEvents();
00168 }
00169 else
00170 {
00171 Select();
00172 }
00173 }
00174 }
00175
00176
00177 void EventHandler::SetQuit(bool x)
00178 {
00179 m_quit = x;
00180 }
00181
00182
00183 void EventHandler::RemoveEvent(IEventOwner *from, long eid)
00184 {
00185 for (std::list<Event *>::iterator it = m_events.begin(); it != m_events.end(); ++it)
00186 {
00187 Event *e = *it;
00188 if (from == e -> GetFrom() && eid == e -> GetID())
00189 {
00190 delete e;
00191 m_events.erase(it);
00192 break;
00193 }
00194 }
00195 }
00196
00197
00198 void EventHandler::Add(Socket *p)
00199 {
00200 SocketHandler::Add( p );
00201 }
00202
00203
00204 #ifdef SOCKETS_NAMESPACE
00205 }
00206 #endif
00207
00208
00209