compile c++ gcc online

Language: Layout:

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

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{

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())
            Mark();
        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>
#include<cassert>
using namespace std;

struct Wakeup
{
    Wakeup(const bool remark=true)
        :remark(remark)
        ,val(0)
    {}

bool Foo()
    {
        return cout<<"wake up!\n",
            ++val, 
            remark;
    }
    bool remark;
    int val;
};
//--------------------------------------------------------------------------------------------------

int main()
{
    std::cout << "Usage of timer\n";
    
    const bool auto_reload = true;
    
    const size_t pause = 300;
    Wakeup obj(auto_reload);

cout<< '\n';

auto wakeup = ::std::bind( &Wakeup::Foo,  ::std::ref(obj) );
    
    tools::Timer tim(pause/1000.0, wakeup);

for(size_t n=0;n<3;++n)
        while( tim.TickTock() ){}

cout<<"number of alarms: "<< obj.val<<endl;
    
    const bool ERROR_INVALID_LOGIC = obj.val!=3;
    
    assert(!ERROR_INVALID_LOGIC);
}

Show compiler warnings [ + ] Compiler args [ + ] Show input
Compilation time: 0.93 sec, absolute running time: 0.94 sec, cpu time: 0.9 sec, memory peak: 3 Mb, absolute service time: 1.87 sec