[common-sln]: base增加单定时器组件

很简单的实现，也开了个线程来做

实现:

#ifndef COMMON_BASE_TIMER_H
#define COMMON_BASE_TIMER_H


#include "base_common.h"
#include "base_uncopy.h"
#include "base_thread.h"

NAMESPACE_COMMON_BEGIN

class BaseTimer;

class YRK_EXPORT_DLL ITimerSink
{
public:
    virtual ~ITimerSink();

public:
    virtual void on_timer() = 0;
};

class YRK_EXPORT_DLL BaseTimer : BaseUncopy
{
public:
    BaseTimer();
    ~BaseTimer();

public:
    bool init(ITimerSink * sink, size_t period);
    void exit();

public:
    static void run(BaseTimer * timer);

private:
    bool running() const;

private:
    ITimerSink         * m_sink;
    size_t               m_period;
    bool                 m_running;
    BaseThread           m_thread;
};

NAMESPACE_COMMON_END


#endif // COMMON_BASE_TIMER_H

#include "base_timer.h"
#include "base_time.h"

NAMESPACE_COMMON_BEGIN

static YRK_THR_FUNC_RET_T YRK_STDCALL timer_run(void * argument)
{
    BaseTimer * timer = reinterpret_cast<BaseTimer *>(argument);
    if (nullptr != timer)
    {
        BaseTimer::run(timer);
    }
    return(THREAD_DEFAULT_RET);
}

ITimerSink::~ITimerSink()
{

}

BaseTimer::BaseTimer()
    : m_sink(nullptr)
    , m_period(0)
    , m_running(false)
    , m_thread()
{
    m_thread.set_thread_args(timer_run, this, "base timer");
}

BaseTimer::~BaseTimer()
{
    exit();
}

bool BaseTimer::init(ITimerSink * sink, size_t period)
{
    exit();

    if (nullptr == sink)
    {
        return(false);
    }

    m_sink = sink;
    m_period = period;
    m_running = true;

    if (!m_thread.acquire())
    {
        m_sink = nullptr;
        m_period = 0;
        m_running = false;
    }

    return(m_running);
}

void BaseTimer::exit()
{
    if (m_running)
    {
        m_running = false;
        m_thread.release();
        m_sink = nullptr;
        m_period = 0;
    }
}

bool BaseTimer::running() const
{
    return(m_running);
}

void BaseTimer::run(BaseTimer * timer)
{
    if (nullptr == timer)
    {
        return;
    }

    while (timer->running())
    {
        timer->m_sink->on_timer();
        base_millisecond_sleep(timer->m_period);
    }
}

NAMESPACE_COMMON_END

测试:

#include <iostream>

#include "test_base.h"
#include "base_time.h"
#include "base_timer.h"

USING_NAMESPACE_COMMON

class TimerSink : public ITimerSink
{
public:
    TimerSink();

public:
    virtual void on_timer();

private:
    int         m_counter;
    BaseTimer   m_timer;
};

TimerSink::TimerSink()
    : m_counter(0)
    , m_timer()
{
    m_timer.init(this, 100);
}

void TimerSink::on_timer()
{
    std::cout << "index: " << m_counter++ << std::endl;
}

int main(int argc, char * argv[])
{
    std::cout << "sleep 1000ms begin..." << std::endl;
    {
        TimerSink sink;
        base_millisecond_sleep(1000);
    }
    std::cout << "sleep 1000ms end..." << std::endl;
    return(0);
}

效果:

sleep 1000ms begin...
index: 0
index: 1
index: 2
index: 3
index: 4
index: 5
index: 6
index: 7
index: 8
index: 9
sleep 1000ms end...