Timer.cpp

Go to the documentation of this file.

// -*- C++ -*-
#include <coil/Listener.h>
#include <coil/Timer.h>
#include <coil/Time.h>
namespace coil
{
  Timer::Timer(TimeValue& interval)
    : m_interval(interval), m_running(false)
  {
  }
  
  Timer::~Timer()
  {
    stop();
    wait();
  }
  
  int Timer::open(void *args)
  {
    activate();
    return 0;
  }
  
  int Timer::svc(void)
  {
    TimeValue t_curr, t_pre, tm;;
    while (m_running)
      {
        invoke();
        coil::sleep(m_interval);
      }
    return 0;
  }
  
  //============================================================
  // public functions
  //============================================================
  void Timer::start()
  {
    Guard guard(m_runningMutex);
    if (!m_running) 
      {
        m_running = true;
        open(0);
      }
  }
  
  void Timer::stop()
  {
    Guard guard(m_runningMutex);
    m_running = false;
  }
  
  void Timer::invoke()
  {
    Guard guard(m_taskMutex);
    for (size_t i(0), len(m_tasks.size()); i < len; ++i)
      {
        m_tasks[i].remains = m_tasks[i].remains - m_interval;
        if (m_tasks[i].remains.sign() <= 0)
          {
            m_tasks[i].listener->invoke();
            m_tasks[i].remains = m_tasks[i].period;
          }
      }
  }
  
  ListenerId Timer::registerListener(ListenerBase* listener, TimeValue tm)
  {
    Guard guard(m_taskMutex);
    
    for (size_t i(0), len(m_tasks.size()); i < len; ++i)
      {
        if (m_tasks[i].listener == listener)
          {
            m_tasks[i].period = tm;
            m_tasks[i].remains = tm;
            return listener;
          }
      }
    m_tasks.push_back(Task(listener, tm));
    return listener;
  }
  
  bool Timer::unregisterListener(ListenerId id)
  {
    Guard guard(m_taskMutex);
    std::vector<Task>::iterator it;
    it = m_tasks.begin();
    
    for (size_t i(0), len(m_tasks.size()); i < len; ++i, ++it)
      {
        if (m_tasks[i].listener == id)
          {
            m_tasks.erase(it);
            return true;
          }
      }
    return false;
  }
}; // namespace RTC