Logo
~Sockets~
~Examples~
~Contact~


EventHandler Class Reference
[EventTimer event handling]

SocketHandler implementing the IEventHandler interface. More...

#include <EventHandler.h>

Inheritance diagram for EventHandler:

Inheritance graph
[legend]
Collaboration diagram for EventHandler:

Collaboration graph
[legend]
List of all members.

Public Member Functions

 EventHandler (StdLog *=NULL)
 EventHandler (Mutex &, StdLog *=NULL)
 ~EventHandler ()
bool GetTimeUntilNextEvent (struct timeval *tv)
 Return time left until next event.
void CheckEvents ()
 Will fire events whose time has come.
long AddEvent (IEventOwner *from, long sec, long usec)
 Schedule and event for an owner.
void ClearEvents (IEventOwner *from)
 Clear all events for a specific owner.
void RemoveEvent (IEventOwner *from, long eid)
 Remove one specific event for an event owner.
void EventLoop ()
 SocketHandler while() loop implemented with event functionality.
void SetQuit (bool=true)
 Stop event loop.
void Add (Socket *)
 Add socket instance to socket map.

Private Member Functions

 EventHandler (const EventHandler &)
EventHandleroperator= (const EventHandler &)

Private Attributes

std::list< Event * > m_events
bool m_quit
TcpSocketm_socket
port_t m_port

Detailed Description

SocketHandler implementing the IEventHandler interface.

Definition at line 49 of file EventHandler.h.


Constructor & Destructor Documentation

EventHandler::EventHandler ( StdLog = NULL  ) 

Definition at line 46 of file EventHandler.cpp.

00046                                     : SocketHandler(p), m_quit(false), m_socket(NULL)
00047 {
00048 }

EventHandler::EventHandler ( Mutex ,
StdLog = NULL 
)

Definition at line 51 of file EventHandler.cpp.

00051                                              : SocketHandler(m, p), m_quit(false), m_socket(NULL)
00052 {
00053 }

EventHandler::~EventHandler (  ) 

Definition at line 56 of file EventHandler.cpp.

References m_events.

00057 {
00058         while (m_events.size())
00059         {
00060                 std::list<Event *>::iterator it = m_events.begin();
00061                 Event *e = *it;
00062                 e -> GetFrom() -> SetHandlerInvalid();
00063                 delete e;
00064                 m_events.erase(it);
00065         }
00066 }

EventHandler::EventHandler ( const EventHandler  )  [inline, private]

Definition at line 70 of file EventHandler.h.

00070 {} // copy constructor


Member Function Documentation

bool EventHandler::GetTimeUntilNextEvent ( struct timeval *   )  [virtual]

Return time left until next event.

Parameters:
tv Time struct that will be filled by method
Returns:
true if time is set for next event

Implements IEventHandler.

Definition at line 69 of file EventHandler.cpp.

References m_events.

Referenced by EventLoop().

00070 {
00071         if (!m_events.size())
00072                 return false;
00073         std::list<Event *>::iterator it = m_events.begin();
00074         if (it != m_events.end())
00075         {
00076                 EventTime now;
00077                 mytime_t diff = (*it) -> GetTime() - now;
00078                 if (diff < 1)
00079                 {
00080                         diff = 1;
00081                 }
00082                 tv -> tv_sec = static_cast<long>(diff / 1000000);
00083                 tv -> tv_usec = static_cast<long>(diff % 1000000);
00084                 return true;
00085         }
00086         return false;
00087 }

void EventHandler::CheckEvents (  )  [virtual]

Will fire events whose time has come.

Implements IEventHandler.

Definition at line 90 of file EventHandler.cpp.

References m_events, and SocketHandler::Valid().

Referenced by EventLoop().

00091 {
00092         EventTime now;
00093         std::list<Event *>::iterator it = m_events.begin();
00094         while (it != m_events.end() && (*it) -> GetTime() < now)
00095         {
00096                 Event *e = *it;
00097                 Socket *s = dynamic_cast<Socket *>(e -> GetFrom());
00098                 /*
00099                 s == NULL    This is another object implementing 'IEventOwner' and not a socket.
00100                 s != NULL    This is a Socket implementing IEventOwner, and we can check that the
00101                              object instance still is valid using SocketHandler::Valid.
00102                 */
00103                 if (!s || (s && Valid(s)))
00104                 {
00105                         e -> GetFrom() -> OnEvent(e -> GetID());
00106                         e -> GetFrom() -> Decrease();
00107                 }
00108                 delete e;
00109                 m_events.erase(it);
00110                 it = m_events.begin();
00111         }
00112 }

long EventHandler::AddEvent ( IEventOwner ,
long  sec,
long  usec 
) [virtual]

Schedule and event for an owner.

Parameters:
from Event owner
sec Seconds until event
usec Microseconds until event

Implements IEventHandler.

Definition at line 115 of file EventHandler.cpp.

References m_events, and m_socket.

00116 {
00117         Event *e = new Event(from, sec, usec);
00118         std::list<Event *>::iterator it = m_events.begin();
00119         while (it != m_events.end() && *(*it) < *e)
00120         {
00121                 it++;
00122         }
00123         m_events.insert(it, e);
00124         if (m_socket)
00125         {
00126                 m_socket -> Send("\n");
00127         }
00128         from -> Increase();
00129         return e -> GetID();
00130 }

void EventHandler::ClearEvents ( IEventOwner  )  [virtual]

Clear all events for a specific owner.

Implements IEventHandler.

Definition at line 133 of file EventHandler.cpp.

References m_events.

00134 {
00135         bool repeat;
00136         do
00137         {
00138                 repeat = false;
00139                 for (std::list<Event *>::iterator it = m_events.begin(); it != m_events.end(); it++)
00140                 {
00141                         Event *e = *it;
00142                         if (e -> GetFrom() == from)
00143                         {
00144                                 delete e;
00145                                 m_events.erase(it);
00146                                 repeat = true;
00147                                 from -> Decrease();
00148                                 break;
00149                         }
00150                 }
00151         } while (repeat);
00152 }

void EventHandler::RemoveEvent ( IEventOwner ,
long   
) [virtual]

Remove one specific event for an event owner.

Implements IEventHandler.

Definition at line 179 of file EventHandler.cpp.

References m_events.

00180 {
00181         for (std::list<Event *>::iterator it = m_events.begin(); it != m_events.end(); it++)
00182         {
00183                 Event *e = *it;
00184                 if (from == e -> GetFrom() && eid == e -> GetID())
00185                 {
00186                         delete e;
00187                         m_events.erase(it);
00188                         break;
00189                 }
00190         }
00191 }

void EventHandler::EventLoop (  ) 

SocketHandler while() loop implemented with event functionality.

Definition at line 155 of file EventHandler.cpp.

References CheckEvents(), GetTimeUntilNextEvent(), m_quit, and SocketHandler::Select().

00156 {
00157         while (!m_quit)
00158         {
00159                 struct timeval tv;
00160                 if (GetTimeUntilNextEvent(&tv))
00161                 {
00162                         Select(&tv);
00163                         CheckEvents();
00164                 }
00165                 else
00166                 {
00167                         Select();
00168                 }
00169         }
00170 }

void EventHandler::SetQuit ( bool  = true  ) 

Stop event loop.

Definition at line 173 of file EventHandler.cpp.

References m_quit.

00174 {
00175         m_quit = x;
00176 }

void EventHandler::Add ( Socket  )  [virtual]

Add socket instance to socket map.

Removal is always automatic.

Reimplemented from SocketHandler.

Definition at line 194 of file EventHandler.cpp.

References SocketHandler::Add(), m_port, and m_socket.

00195 {
00196         if (!m_socket)
00197         {
00198                 ListenSocket<TcpSocket> *l = new ListenSocket<TcpSocket>(*this);
00199                 l -> SetDeleteByHandler();
00200                 l -> Bind("127.0.0.1", 0);
00201                 m_port = l -> GetPort();
00202                 SocketHandler::Add(l);
00203                 m_socket = new TcpSocket( *this );
00204                 m_socket -> SetDeleteByHandler();
00205                 m_socket -> SetConnectTimeout(5);
00206                 m_socket -> SetConnectionRetry(-1);
00207 #ifdef ENABLE_RECONNECT
00208                 m_socket -> SetReconnect(true);
00209 #endif
00210                 m_socket -> Open("127.0.0.1", m_port);
00211                 SocketHandler::Add(m_socket);
00212         }
00213         SocketHandler::Add( p );
00214 }

EventHandler& EventHandler::operator= ( const EventHandler  )  [inline, private]

Definition at line 71 of file EventHandler.h.

00071 { return *this; } // assignment operator


Member Data Documentation

bool EventHandler::m_quit [private]

Definition at line 73 of file EventHandler.h.

Referenced by EventLoop(), and SetQuit().

Definition at line 74 of file EventHandler.h.

Referenced by Add(), and AddEvent().

Definition at line 75 of file EventHandler.h.

Referenced by Add().


The documentation for this class was generated from the following files:
Page, code, and content Copyright (C) 2007 by Anders Hedström
Generated for C++ Sockets by  doxygen 1.4.4