Clock.cc

// Copyright 2008 Michael Marsh, University of Maryland.
//
// This file is part of pydtn.
//
// pydtn is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// pydtn is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with pydtn.  If not, see <http://www.gnu.org/licenses/>.
//
// The views and conclusions contained in the software and documentation
// are those of the authors and should not be interpreted as representing
// official policies, either expressed or implied, of the University
// of Maryland.
//
// pydtn extends and embeds the Python interpreter, which is
// Copyright 2001-2006 Python Software Foundation, All Rights Reserved,
// and is released under the PSF License Agreement.
//
// RANLUX random number generation uses the Boost library,
// Copyright 1994-2006 by various authors (details in individual files),
// which is released under the Boost Software License, Version 1.0.

#include "Clock.h"
#include "Event.h"

#include <iostream>

Time Clock::m_time;
Clock::EventList Clock::m_events;
Clock::EventList Clock::m_tentative;
bool Clock::m_running = true;

bool
EventCmp::operator()( const Event* a, const Event* b ) const
{
   if ( 0 == a )
   {
      return false;
   }
   if ( 0 == b )
   {
      return false;
   }
   return a->time() < b->time();
}

void
Clock::schedule( Event* e )
{
   if ( 0 == e )
   {
      std::cerr << "Attempted to schedule a NULL Event" << std::endl;
      return;
   }
   if ( e->time() < m_time )
   {
      std::cerr << "Cannot schedule an event for the past!\n"
                << "    current time: " << m_time << "\n"
                << "   schedule time: " << e->time() << std::endl;
      delete e;
      return;
   }
   m_events.insert(e);
}

void
Clock::tentative( Event* e )
{
   if ( 0 == e )
   {
      std::cerr << "Attempted to schedule a NULL Event" << std::endl;
      return;
   }
   if ( e->time() < m_time )
   {
      std::cerr << "Cannot schedule an event for the past!\n"
                << "    current time: " << m_time << "\n"
                << "   schedule time: " << e->time() << std::endl;
      delete e;
      return;
   }
   m_tentative.insert(e);
}

void
Clock::tick()
{
   EventList::iterator eli = m_events.begin();
   EventList::iterator teli = m_tentative.begin();

   if ( 0 == m_events.size() )
   {
      // run the earliest tentative event
      if ( 0 != m_tentative.size() )
      {
         Event* te = *teli;
         m_tentative.erase(teli);
         m_time = te->time();
         te->handle();
         delete te;
      }
      m_running = false;
      return;
   }
   if ( 0 == m_tentative.size() )
   {
         Event* e = *eli;
         m_events.erase(eli);
         m_time = e->time();
         e->handle();
         delete e;
         return;
   }
   Event* te = *teli;
   Event* e = *eli;

   // This biases towards running e
   if ( te->time() < e->time() )
   {
      m_tentative.erase(teli);
      m_time = te->time();
      te->handle();
      delete te;
   }
   else
   {
      m_events.erase(eli);
      m_time = e->time();
      e->handle();
      delete e;
   }
}

---