Sockets/EventHandler.cpp

   1 /** \file EventHandler.cpp
   2  **     \date  2005-12-07
   3  **     \author grymse@alhem.net
   4 **/
   5 /*
   6 Copyright (C) 2005,2007  Anders Hedstrom
   7
   8 This library is made available under the terms of the GNU GPL.
   9
  10 If you would like to use this library in a closed-source application,
  11 a separate license agreement is available. For information about
  12 the closed-source license agreement for the C++ sockets library,
  13 please visit http://www.alhem.net/Sockets/license.html and/or
  14 email license@alhem.net.
  15
  16 This program is free software; you can redistribute it and/or
  17 modify it under the terms of the GNU General Public License
  18 as published by the Free Software Foundation; either version 2
  19 of the License, or (at your option) any later version.
  20
  21 This program is distributed in the hope that it will be useful,
  22 but WITHOUT ANY WARRANTY; without even the implied warranty of
  23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24 GNU General Public License for more details.
  25
  26 You should have received a copy of the GNU General Public License
  27 along with this program; if not, write to the Free Software
  28 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  29 */
  30 #ifdef _MSC_VER
  31 #pragma warning(disable:4786)
  32 #endif
  33 #include "EventHandler.h"
  34 #include "IEventOwner.h"
  35 #include "Event.h"
  36 #include "Socket.h"
  37 #include "TcpSocket.h"
  38 #include "ListenSocket.h"
  39
  40
  41 #ifdef SOCKETS_NAMESPACE
  42 namespace SOCKETS_NAMESPACE {
  43 #endif
  44
  45
  46 EventHandler::EventHandler(StdLog *p) : SocketHandler(p), m_quit(false), m_socket(NULL)
  47 {
  48 }
  49
  50
  51 EventHandler::EventHandler(Mutex& m,StdLog *p) : SocketHandler(m, p), m_quit(false), m_socket(NULL)
  52 {
  53 }
  54
  55
  56 EventHandler::~EventHandler()
  57 {
  58         while (m_events.size())
  59         {
  60                 std::list<Event *>::iterator it = m_events.begin();
  61                 Event *e = *it;
  62                 e -> GetFrom() -> SetHandlerInvalid();
  63                 delete e;
  64                 m_events.erase(it);
  65         }
  66 }
  67
  68
  69 bool EventHandler::GetTimeUntilNextEvent(struct timeval *tv)
  70 {
  71         if (!m_events.size())
  72                 return false;
  73         std::list<Event *>::iterator it = m_events.begin();
  74         if (it != m_events.end())
  75         {
  76                 EventTime now;
  77                 mytime_t diff = (*it) -> GetTime() - now;
  78                 if (diff < 1)
  79                 {
  80                         diff = 1;
  81                 }
  82                 tv -> tv_sec = static_cast<long>(diff / 1000000);
  83                 tv -> tv_usec = static_cast<long>(diff % 1000000);
  84                 return true;
  85         }
  86         return false;
  87 }
  88
  89
  90 void EventHandler::CheckEvents()
  91 {
  92         EventTime now;
  93         std::list<Event *>::iterator it = m_events.begin();
  94         while (it != m_events.end() && (*it) -> GetTime() < now)
  95         {
  96                 Event *e = *it;
  97                 Socket *s = dynamic_cast<Socket *>(e -> GetFrom());
  98                 /*
  99                 s == NULL    This is another object implementing 'IEventOwner' and not a socket.
 100                 s != NULL    This is a Socket implementing IEventOwner, and we can check that the
 101                              object instance still is valid using SocketHandler::Valid.
 102                 */
 103                 if (!s || (s && Valid(s)))
 104                 {
 105                         e -> GetFrom() -> OnEvent(e -> GetID());
 106                 }
 107                 for (it = m_events.begin(); it != m_events.end(); ++it)
 108                         if (*it == e)
 109                                 break;
 110                 delete e;
 111                 if (it != m_events.end())
 112                         m_events.erase(it);
 113                 it = m_events.begin();
 114         }
 115 }
 116
 117
 118 long EventHandler::AddEvent(IEventOwner *from,long sec,long usec)
 119 {
 120         Event *e = new Event(from, sec, usec);
 121         std::list<Event *>::iterator it = m_events.begin();
 122         while (it != m_events.end() && *(*it) < *e)
 123         {
 124                 it++;
 125         }
 126         m_events.insert(it, e);
 127         if (m_socket)
 128         {
 129                 m_socket -> Send("\n");
 130         }
 131         return e -> GetID();
 132 }
 133
 134
 135 void EventHandler::ClearEvents(IEventOwner *from)
 136 {
 137         bool repeat;
 138         do
 139         {
 140                 repeat = false;
 141                 for (std::list<Event *>::iterator it = m_events.begin(); it != m_events.end(); it++)
 142                 {
 143                         Event *e = *it;
 144                         if (e -> GetFrom() == from)
 145                         {
 146                                 delete e;
 147                                 m_events.erase(it);
 148                                 repeat = true;
 149                                 break;
 150                         }
 151                 }
 152         } while (repeat);
 153 }
 154
 155
 156 void EventHandler::EventLoop()
 157 {
 158         while (!m_quit)
 159         {
 160                 struct timeval tv;
 161                 if (GetTimeUntilNextEvent(&tv))
 162                 {
 163                         Select(&tv);
 164                         CheckEvents();
 165                 }
 166                 else
 167                 {
 168                         Select();
 169                 }
 170         }
 171 }
 172
 173
 174 void EventHandler::SetQuit(bool x)
 175 {
 176         m_quit = x;
 177 }
 178
 179
 180 void EventHandler::RemoveEvent(IEventOwner *from, long eid)
 181 {
 182         for (std::list<Event *>::iterator it = m_events.begin(); it != m_events.end(); it++)
 183         {
 184                 Event *e = *it;
 185                 if (from == e -> GetFrom() && eid == e -> GetID())
 186                 {
 187                         delete e;
 188                         m_events.erase(it);
 189                         break;
 190                 }
 191         }
 192 }
 193
 194
 195 void EventHandler::Add(Socket *p)
 196 {
 197         if (!m_socket)
 198         {
 199                 ListenSocket<TcpSocket> *l = new ListenSocket<TcpSocket>(*this);
 200                 l -> SetDeleteByHandler();
 201                 l -> Bind("127.0.0.1", 0);
 202                 m_port = l -> GetPort();
 203                 SocketHandler::Add(l);
 204                 m_socket = new TcpSocket( *this );
 205                 m_socket -> SetDeleteByHandler();
 206                 m_socket -> SetConnectTimeout(5);
 207                 m_socket -> SetConnectionRetry(-1);
 208 #ifdef ENABLE_RECONNECT
 209                 m_socket -> SetReconnect(true);
 210 #endif
 211                 m_socket -> Open("127.0.0.1", m_port);
 212                 SocketHandler::Add(m_socket);
 213         }
 214         SocketHandler::Add( p );
 215 }
 216
 217
 218 #ifdef SOCKETS_NAMESPACE
 219 }
 220 #endif
 221
 222
 223