Форум программистов [Powered by Invision Power Board]

Код


class CycledJobExecutor
{
public:
    /**
     * Конструктор
     * @param ioService ссылка на ио сервис
     * @param period время срабатывания таймера,
     * @param job функция, которая будет вызвана после срабатывания таймера
     * @param startAfterConstructed запуск таймера сразу после создания объекта
     * @param loop перезапуск таймера после отработки
     */
    CycledJobExecutor(  io_service& ioService,
                        time_duration period,
                        boost::function<void()> job,
                        bool startAfterConstructed = true,
                        bool loop = true);

    /**
     * Запуск таймера со временем, переданным в метод
     * Время срабатывания таймера сохраняется в объекте
     * @param period время срабатывания таймера
     */
    virtual size_t WindUp(const time_duration& period);

    /**
     * Запуск таймера со временем, сохраненным в объекте.
     */
    virtual size_t WindUp();

    /**
     * Сброс таймера
     */
    virtual size_t Cancel();

    /**
     * @return время срабатывания таймера, сохраненног ов объекте
     */
    const time_duration& GetPeriod() const;

    //! Отменяет следующую после саморазрушения итерацию задачи _job
    virtual ~CycledJobExecutor();

protected:
    struct CycledJobState
    {
        enum Val
        {
            Running     = 0,
            Cancelling  = 1,
            Stopped     = 2,
            Stopping    = 3
        };
    };

    /**
     * Обрабатывает прерывание таймера
     */
    virtual void TimerExpiredHandler(const error_code& error);    

    /**
     * Функция, которая будет вызвана при срабатывании таймера
     */
    boost::function<void()> _job;

    /**
     * текуще состояние таймера
     **/
    volatile size_t _state;

    /**
     * Флаг, показывающий нужен ли перезапуск таймера, после его срабатывания
     */
    bool _loop;

    /**
     * Время срабатывания таймера
     */
    time_duration _period;
private:    
    boost::shared_ptr<deadline_timer> _timer;
    boost::mutex _mutex;
    boost::condition_variable _cv;
    log4cxx::LoggerPtr _logger;
};

Код


CycledJobExecutor::CycledJobExecutor(io_service& ioService,
                                     time_duration period,
                                     boost::function<void()> job,
                                     bool startAfterConstructed,
                                     bool loop)
    :   _job(job),
        _state(CycledJobState::Stopped),
        _loop(loop),
        _period(period),
        _timer(new deadline_timer(ioService)),
        _mutex(),
        _cv()
{
    _loop = true;
    if (startAfterConstructed)
    {
        WindUp(_period);
    }
}

CycledJobExecutor::CycledJobExecutor(io_service& ioService,
                                     time_duration period,
                                     IJob& job,
                                     bool startAfterConstructed,
                                     bool loop)
    :   _job(boost::bind(&IJob::Do, &job)),
        _state(CycledJobState::Stopped),
        _loop(loop),
        _period(period),
        _timer(new deadline_timer(ioService)),
        _mutex(),
        _cv()
{
    if (startAfterConstructed)
    {
        WindUp(_period);
    }
}

CycledJobExecutor::~CycledJobExecutor()
{
    Cancel();
    boost::unique_lock<boost::mutex> lock(_mutex);
    while (_state != CycledJobState::Stopped)
    {
        _cv.wait(lock);
    }    
}

size_t CycledJobExecutor::WindUp(const time_duration& period)
{
    boost::unique_lock<boost::mutex> lock(_mutex);
    size_t cancelQnty = _timer->expires_from_now(_period);
    _period = period;
    if (_state != CycledJobState::Stopping)
    {
        _state = CycledJobState::Running;
        _timer->async_wait(bind(&CycledJobExecutor::TimerExpiredHandler, this, placeholders::error));
    }
    return cancelQnty;
}

size_t CycledJobExecutor::WindUp()
{
    return WindUp(_period);
}

size_t CycledJobExecutor::Cancel()
{
    boost::unique_lock<boost::mutex> lock(_mutex);
    _state = CycledJobState::Cancelling;
    size_t cancelQnty = _timer->cancel();
    if (cancelQnty == 0)
    {
        _state = CycledJobState::Stopped;
    }
    return cancelQnty;
}

const time_duration& CycledJobExecutor::GetPeriod() const
{
    return _period;
}

void CycledJobExecutor::TimerExpiredHandler(const error_code& error)
{
    
    if (error)
    {
        if (error != error::operation_aborted)
        {
            LOG4CXX_ERROR(_logger, "error code " <<  error);
        }
        else
        {
            if (_state != CycledJobState::Running)
            {
                boost::unique_lock<boost::mutex> lock(_mutex);
                _state = CycledJobState::Stopped;
            }
            _cv.notify_all();
        }        
        
    }
    else
    {
        if (_state == CycledJobState::Running)
        {
            if (_loop)
            {
                WindUp();
            }
            _job();
            if (!_loop)
            {
                {
                    boost::unique_lock<boost::mutex> lock(_mutex);
                    _state = CycledJobState::Stopped;
                }
                _cv.notify_all();
            }
        }
        else
        {
            {
                boost::unique_lock<boost::mutex> lock(_mutex);
                _state = CycledJobState::Stopped;
            }
            _cv.notify_all();
        }
    }
}