timer, C++ (vc++) - rextester

Language: Layout:

// --- timer.h
//#pragma once

#include <functional>
#include <stdint.h>
#include <chrono>

namespace tools
{
    struct Timer
    {
        //если функция-будильник вернет true, то таймер перезапустится
        typedef ::std::function<bool()> EventWakeUp;

typedef std::chrono::high_resolution_clock Clock;

typedef uint64_t    MicroSeconds;
        typedef double      Seconds;

public:
       ~Timer();

//укажите :
        // --- время, через которое должен сработать будильник,
        // --- функтор, который должен будет запуститься в момент срабатывания будильника,
        // --- числовой идентификатор таймера (если он вам нужен).
        //Имейте ввиду, если функтор будильника вернет true, то будильник снова перезапустится.  
        Timer( const Seconds      delay, const EventWakeUp& wakeup=EventWakeUp(), const int id=0 );
        Timer( const MicroSeconds delay, const EventWakeUp& wakeup=EventWakeUp(), const int id=0 );
        Timer(const int id=0);

//перезапуск будильника, с возможностью указать другой функутор
        void Restart(const Seconds delay,      const EventWakeUp& wakeup=EventWakeUp() );
        void Restart(const MicroSeconds delay, const EventWakeUp& wakeup=EventWakeUp() );

int GetID()const{ return mId;}
    public:
        //вернет промежуток времени с момента последнего запуска этого же метода
        static MicroSeconds QuantMS();
        static Seconds QuantS();

//спать все время в отдельном потоке, а потом пробудиться и вызвать функцию-будильник
        static void BackGround(const Timer::Seconds delay, const Timer::EventWakeUp& wakeup=EventWakeUp());

//усыпить текущий поток, а потом пробудиться и вызвать функцию-будильник
        static void Sleep(const Timer::Seconds delay, const Timer::EventWakeUp& wakeup=EventWakeUp());
    public:
        //засечь время.
        void Mark();

//через какое время сработает будильник
        MicroSeconds RemainingMS()const;
        Seconds RemainingS()const;

//сколько времени уже прошло с момента запуска будильника
        MicroSeconds ElapsedMS()const;
        Seconds ElapsedS()const;

//Приводит механизм будильника в действие
        //вернет true, если будильник ещё не сработал. 
        //В момент срабатывания запустит функцию-будильник
        bool TickTock();
    private:
        int mId; 
        MicroSeconds        mDelay; 
        EventWakeUp         mEvent;
        Clock::time_point   mMark; 
    };

}//namespace tools

//----------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------
//#include <tools/timer.h>
#include <thread>

namespace tools
{

namespace{

typedef Timer::EventWakeUp  EventWakeUp;
        typedef Timer::MicroSeconds MicroSeconds;
        typedef Timer::Seconds      Seconds;
        typedef Timer::Clock        Clock;
        
        typedef std::chrono::microseconds MSec;
        typedef std::chrono::seconds      Sec;

template<class T> T DeltaTime(Clock::time_point& last)
        {
            const Clock::time_point now = Clock::now();
            const auto result = std::chrono::duration_cast<T>(now - last);
            last = now;
            return result;
        }

Clock::time_point& Quant()
        {
            static Clock::time_point quant;
            return quant;
        }

void Sleeping(const MicroSeconds pause, const EventWakeUp& wakeup)
        {
            do
            {
                std::this_thread::sleep_for(std::chrono::microseconds(pause) );

}while ( wakeup && wakeup() );
        }

}//namespace

MicroSeconds Timer::QuantMS() { return DeltaTime<MSec>(Quant()).count();         }
    Seconds Timer::QuantS()       { return (Seconds)DeltaTime<Sec>(Quant()).count(); }

Timer::Timer(const int id):mId(id){}

Timer::Timer( const Seconds delay, const EventWakeUp& wakeup, const int id):mId(id)
    {
        Restart(delay,wakeup);
    }

Timer::Timer( const MicroSeconds delay, const EventWakeUp& wakeup, const int id):mId(id)
    {
        Restart(delay,wakeup);
    }

void Timer::Restart(const Seconds delay, const EventWakeUp& wakeup)
    {
        mDelay = static_cast<MicroSeconds>(delay*1000000);
        mEvent = wakeup;
        Mark();
    }
    void Timer::Restart(const MicroSeconds delay,const EventWakeUp& wakeup)
    {
        mDelay = delay;
        mEvent = wakeup;
        Mark();
    }

Timer::~Timer(){}

void Timer::Mark() { mMark = Clock::now(); }

MicroSeconds Timer::ElapsedMS()const
    {
        return std::chrono::duration_cast<MSec>(Clock::now() - mMark).count();
    }
    Seconds Timer::ElapsedS()const
    {
        return static_cast<Seconds>( ElapsedMS()/1000000.0 );
    }

MicroSeconds Timer::RemainingMS()const
    {
        if(mMark == Clock::time_point() || mDelay==0) 
            return 0;
        
        const auto elapsed = ElapsedMS(); 
        return (mDelay<=elapsed)? 0: mDelay-elapsed;
    }
    Seconds Timer::RemainingS()const
    {
        if(mMark == Clock::time_point() || mDelay==0) 
            return 0;

const auto elapsed = ElapsedMS(); 
        return (mDelay<=elapsed)? 0.0: (mDelay-elapsed)/1000000.0;
    }

bool Timer::TickTock()
    {
        if(mMark == Clock::time_point())
            return false;

if(RemainingMS()!=0)
            return true;

if(mEvent && mEvent())
            return Mark(), true;
        else
            mMark=Clock::time_point();
        
        return false;
    }

//-----------------------------------------------------------
    void Timer::BackGround(const Timer::Seconds delay, const Timer::EventWakeUp& wakeup)
    {
        const MicroSeconds pause = static_cast<MicroSeconds>(delay*1000000);
        auto lambda = [pause, wakeup ](){ Sleeping(pause, wakeup); };
        std::thread(lambda).detach();
    }

void Timer::Sleep(const Timer::Seconds delay, const Timer::EventWakeUp& wakeup)
    {
        const auto pause = static_cast<MicroSeconds>(delay*1000000);
        Sleeping(pause, wakeup);
    }
    
}//namespace tools

#include <iostream>

bool userFunction()
{
    static size_t count = 5;
    
    std::cout << "wake up!\n";
    --count;
    return count!=0;
}

int main()
{
    std::cout << "Hello, world!\n";
    
    size_t v=0;
    
    
    // создаем будильник, указывая через сколько секунд нужно сработать.
    // и функцию, которую нужно запустить при срабатывании
    // если функция вернет true,
    // то будильник автоматически перезапустится.
    const double seconds = 0.1; 
    tools::Timer timer(seconds, userFunction);

// TickTock возвращает true, если будильник ещё не сработал
    while( timer.TickTock() )
    {
        // здесь может быть любой ваш код
        
        //std::cout<<" Remaining: "<< timer.RemainingS() <<" seconds\n";
        //std::cout<<" Elapsed: "  << timer.ElapsedS()   <<" seconds\n";
    }
    std::cout << "finished" <<std::endl;
    
}

Show compiler warnings [ + ] Compiler args [ + ] Show input
Compilation time: 1,73 sec, absolute running time: 0,76 sec, absolute service time: 2,51 sec