Gammon Forum

#include <string>
#include <functional>
#include <queue>
#include <vector>
#include <iostream>


//  events.h 

#ifdef WIN32
  #include <windows.h>    // for timeGetTime
#else
  #include <sys/time.h>   // for gettimeofday
  #include <unistd.h>     // for sleep
#endif

using namespace std;  

// thanks to Ksilyan for this routine :)
long GetMillisecondsTime (void)
  {
#ifdef WIN32
  #pragma comment( lib, "winmm.lib" ) // this is the library it is in
   return timeGetTime();
#else
  struct timeval resultTimeval;
  gettimeofday( &resultTimeval, NULL );
  resultTimeval.tv_sec -= 946080000; // 30 years
  return resultTimeval.tv_sec * 1000 + resultTimeval.tv_usec / 1000;
#endif
  }  // end of GetMillisecondsTime

// event object
class CEvent
  {

  public:

  CEvent (const long iMilliseconds = 1000,    // default, 1 second
          const bool bRepeat = false,         // default, no repeat
          const long iSequence = 0)  :        // default, unsequenced
      m_iInterval (iMilliseconds),            // time interval
      m_bRepeat (bRepeat),                    // whether to keep doing it
      m_iWhen (GetMillisecondsTime ()),       // set last fired time to now
      m_iInstance (0),
      m_iSequence (iSequence)
      { 
      Reschedule ();  // calculate when it first fires
      };

  virtual ~CEvent () {};  // important - see Scott Meyers

  // operator< (for sorting)
  inline bool operator< (const CEvent & rhs) const
    {
    // we compare > because the sooner events have the
    // higher priority
    if  (m_iWhen == rhs.m_iWhen)
      return  m_iSequence > rhs.m_iSequence;  // sequence order if times same
    else
      return  m_iWhen > rhs.m_iWhen;          // time order
    };

  // call to reschedule it - add interval to last fired time
  // so as to avoid event creep
  inline void Reschedule (void) 
    { 
    m_iWhen += m_iInterval; 
    };

  inline void Fired (void)
    {
    m_iInstance++;
    };

  // get values
  inline long GetTime     (void) const { return m_iWhen; };
  inline long GetInterval (void) const { return m_iInterval; };
  inline bool Repeat      (void) const { return m_bRepeat; };
  inline long GetInstance (void) const { return m_iInstance; };

  // derive a class and override this to actually do something
  virtual void OnEvent (void) = 0;

  protected:

  long  m_iInterval;  // seconds until next one
  bool  m_bRepeat;    // true if we are to re-enter in queue

  private:

  long  m_iWhen;      // when event fires
  long  m_iInstance;  // how many times it fired
  long  m_iSequence;  // what order to sequence events with the same fire time

  };  // end of class CEvent

// for adding events to a priority_queue
struct event_less : binary_function<CEvent*, CEvent*, bool> 
  {
  inline bool operator() (const CEvent* X, const CEvent* Y) const
    {
    return (*X < *Y); 
    }
  };

typedef priority_queue<CEvent*, vector<CEvent*>, event_less > tEvents;

// event handler
void ProcessEvents (tEvents & EventQueue);


//  events.cpp 

// my own iterator can be used for inserting into the event queue
class event_queue_back_inserter : public iterator <output_iterator_tag, CEvent*>
  {
  public:   

    event_queue_back_inserter (tEvents & events) : m_events (events) {};

    // assignment is used to insert into the queue
    event_queue_back_inserter & operator= (CEvent* & e)
      { 
      m_events.push (e);
      return *this;
      };

    // dereference and increments are no-ops that return 
    // the iterator itself
    event_queue_back_inserter & operator* () { return *this; };
    event_queue_back_inserter & operator++ () { return *this; };
    event_queue_back_inserter & operator++ (int) { return *this; };

  private:

  tEvents & m_events;


  };  // end of class event_queue_back_inserter

// 1. pull out events from the event queue
// 2. keep going until one is due in the future
// 3, if rescheduling wanted keep in temporary vector until all are done

void ProcessEvents (tEvents & EventQueue)
  {
  long now = GetMillisecondsTime ();
  vector<CEvent*> repeated_events;

  // pull out event that need doing
  while (!EventQueue.empty ())
    {
    CEvent * e = EventQueue.top ();

    if (e->GetTime () > now)
      break;  // not yet

    EventQueue.pop ();  // remove from queue

    e->Fired ();    // note it fired
    e->OnEvent ();  // do the event (derived class)

    // if repeating it wanted, recalculate and keep in separate list
    if (e->Repeat ())
      {
      e->Reschedule ();
      repeated_events.push_back (e);
      }
    else
      delete e;   // otherwise pointer not needed any more

    }  // end of event loop

  // put any event we rescheduled back into the queue
  // we do it now so we don'now get into a loop if the event is due to
  // fire immediately
  copy (repeated_events.begin (),
        repeated_events.end (),
        event_queue_back_inserter (EventQueue));

  } // end of ProcessEvents 


//  main.cpp


// an instance of an event queue
tEvents EventQueue;

// helper routine to add an event
void AddEvent (CEvent * e)
  {
  if (e)    // being cautious here :)
    EventQueue.push (e);
  } // end of AddEvent

int main (void)
  {

  class myevent_A : public CEvent
    {
    public:

    myevent_A (const int iTime, 
             const string sMsg, 
             const bool bRepeat = false,
             const long iSequence = 0)
      : CEvent (iTime, bRepeat, iSequence), 
        m_sMsg (sMsg)
          { };

    virtual void OnEvent (void)
      {
      cout << m_sMsg << " instance " << GetInstance () << endl;
      };

    private:

    const string m_sMsg;

    };  // end of class myevent_A 

  class myevent_B : public CEvent
    {
    public:

    myevent_B () : CEvent (0, true) { };

    virtual void OnEvent (void)
      {
      cout << "myevent_B, instance " << GetInstance () << endl;
      };

    };  // end of class myevent_B

  AddEvent (new myevent_A (10000, "after 10 secs"));
  AddEvent (new myevent_A (5000, "after 5 secs", false, 1));
  AddEvent (new myevent_A (5000, "another after 5 secs", false, 2));
  AddEvent (new myevent_A (7000, "after 7 secs"));

  AddEvent (new myevent_A (2000, "You hear rustling sounds", true));

  AddEvent (new myevent_B ());

  // main program loop
  while (true)
    {
    ProcessEvents (EventQueue);

    // sleep for 1 second - simulate waiting on comms or something
    #ifdef WIN32
        Sleep (1000);  
    #else
        sleep (1);
    #endif

    }

  return 0;
  } // end of main

Start     : Adding events - deque
Time taken: Adding events - deque     = 0.049950 seconds.
Start     : Adding events - vector
Time taken: Adding events - vector    = 0.047447 seconds.
Start     : Processing events - deque
Time taken: Processing events - deque = 14.692457 seconds.
Start     : Processing events - vector
Time taken: Processing events - vector = 5.265106 seconds.
Total events fired = 2000000

Start     : Adding events - deque
Time taken: Adding events - deque     = 0.011699 seconds.
Start     : Adding events - vector
Time taken: Adding events - vector    = 0.011204 seconds.
Start     : Processing events - deque
Time taken: Processing events - deque = 4.720998 seconds.
Start     : Processing events - vector
Time taken: Processing events - vector = 1.044776 seconds.
Total events fired = 2000000