TimedEventManager.cpp

Go to the documentation of this file.

#include "TimedEventManager.h"

namespace Support
{
    TimedEventManager::TimerTracker::TimerTracker(double periodInSeconds, ThreadTaskBase* task) : 
        _timer(periodInSeconds),
        _task(task), 
        _recurring(false)
    {
    }

    TimedEventManager::TimerTracker::TimerTracker() : 
        _timer(0),
        _task(NULL), 
        _recurring(false)
    {
    }

    bool TimedEventManager::TimerTracker::operator==(const TimerTracker& rhs)
    {
        if((_task == rhs._task) && (_timer == rhs._timer) && (_recurring == rhs._recurring))
            return true;
        else
            return false;
    }

    TimedEventManager::TimedTask::TimedTask()
    {
        //since we're managed by a pool, we don't want to be deleted
        setDelete(false);
    }

    void TimedEventManager::TimedTask::execute()
    {
        _tracker.execute();
        _manager->_taskPool.recycle(this);
    }

    TimedEventManager::TimerManager::TimerManager(TimedEventManager* manager) : _manager(manager)
    {
        _timerGrain.sec = TimedEventManagerGranularityInSeconds;
    }

    void TimedEventManager::TimerManager::execute()
    {
        while(true)
        {
            _manager->checkTimers();
            boost::thread::sleep(_timerGrain);
        }
    }

    void TimedEventManager::checkTimers()
    {
        //perform this check while locking on the timer mutex
        boost::lock_guard<boost::mutex> guard(_timerMutex);
        //iterate through the list of timers, checking if they have elapsed
        std::list<TimerTracker>::iterator it=_timers.begin();
        while(it != _timers.end())
        {
            //act on the current item only, save the next item in the loop iter
            std::list<TimerTracker>::iterator currentItem = it++;
            //only act if this is elapsed
            if(currentItem->isTimerElapsed())
            {
                //get a task from the pool, set it, and queue it
                TimedTask* task = _taskPool.getInstance();
                task->_tracker = *currentItem;
                task->_manager = this;
                queueTask(task);
                //the queued item will carry things out, from here we either renew it or let it go
                if(currentItem->isRecurring())
                    currentItem->reset();
                else
                    _timers.remove(*currentItem);
            }
        }
    }

    TimedEventManager::TimedEventManager(size_t threadCount) : ThreadPool(threadCount), _taskPool((unsigned int)threadCount)
    {
        //we reserve one worker to carry out timer management
        createWorkerThread();
        queueTask(new TimerManager(this));
    }

    TimedEventManager::~TimedEventManager()
    {
        stop();
    }

    void TimedEventManager::addTimedEvent(double periodInSeconds, ThreadTaskBase* task, bool recurring)
    {
        TimerTracker tracker(periodInSeconds, task);
        tracker.setRecurring(recurring);

        //lock when adding timer
        boost::lock_guard<boost::mutex> guard(_timerMutex);
        _timers.push_back(tracker);
    }
}