Logo
~Sockets~
~Examples~
~Contact~


EventHandler Class Reference
[EventTimer event handling]

SocketHandler implementing the IEventHandler interface. More...

#include <EventHandler.h>

Inheritance diagram for EventHandler:
Collaboration diagram for EventHandler:

List of all members.


Public Member Functions

 EventHandler (StdLog *=NULL)
 EventHandler (IMutex &, 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 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

Detailed Description

SocketHandler implementing the IEventHandler interface.

Definition at line 51 of file EventHandler.h.


Constructor & Destructor Documentation

EventHandler::EventHandler ( StdLog p = NULL  ) 

Definition at line 47 of file EventHandler.cpp.

References SocketHandler::EnableRelease().

00047                                     : SocketHandler(p), m_quit(false)
00048 {
00049         EnableRelease();
00050 }

EventHandler::EventHandler ( IMutex m,
StdLog p = NULL 
)

Definition at line 53 of file EventHandler.cpp.

References SocketHandler::EnableRelease().

00053                                               : SocketHandler(m, p), m_quit(false)
00054 {
00055         EnableRelease();
00056 }

EventHandler::~EventHandler (  ) 

Definition at line 59 of file EventHandler.cpp.

References m_events.

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 }

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

Definition at line 72 of file EventHandler.h.

00072 {} // 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 72 of file EventHandler.cpp.

References m_events.

Referenced by EventLoop().

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 }

void EventHandler::CheckEvents (  )  [virtual]

Will fire events whose time has come.

Implements IEventHandler.

Definition at line 93 of file EventHandler.cpp.

References m_events, and SocketHandler::Valid().

Referenced by EventLoop().

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                 s == NULL    This is another object implementing 'IEventOwner' and not a socket.
00103                 s != NULL    This is a Socket implementing IEventOwner, and we can check that the
00104                              object instance still is valid using SocketHandler::Valid.
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 }

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

Schedule event for an owner.

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

Implements IEventHandler.

Definition at line 123 of file EventHandler.cpp.

References m_events, and SocketHandler::Release().

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 }

void EventHandler::ClearEvents ( IEventOwner  )  [virtual]

Clear all events for a specific owner.

Implements IEventHandler.

Definition at line 138 of file EventHandler.cpp.

References m_events.

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 }

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

Remove one specific event for an event owner.

Implements IEventHandler.

Definition at line 183 of file EventHandler.cpp.

References m_events.

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 }

void EventHandler::EventLoop (  ) 

SocketHandler while() loop implemented with event functionality.

Definition at line 159 of file EventHandler.cpp.

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

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 }

void EventHandler::SetQuit ( bool  x = true  ) 

Stop event loop.

Definition at line 177 of file EventHandler.cpp.

References m_quit.

00178 {
00179         m_quit = x;
00180 }

void EventHandler::Add ( Socket p  )  [virtual]

Add socket instance to socket map.

Removal is always automatic.

Reimplemented from SocketHandler.

Definition at line 198 of file EventHandler.cpp.

References SocketHandler::Add().

00199 {
00200         SocketHandler::Add( p );
00201 }

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

Definition at line 73 of file EventHandler.h.

00073 { return *this; } // assignment operator


Member Data Documentation

bool EventHandler::m_quit [private]

Definition at line 75 of file EventHandler.h.

Referenced by EventLoop(), and SetQuit().


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