timer.hpp

Go to the documentation of this file.

/**
 * @author: Daniel Fuchs
 * @contact: fuxeysolutions@gmail.com
 *
 * distributed under the MIT License (MIT).
 * Copyright (c) Daniel Fuchs
 *
 */
#pragma once
 
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <functional>
#include <future>
#include <iostream>
#include <mutex>
#include <thread>
#include <tuple>
#include <utility>
 
enum timer_mode
{
    singleshot,
    continuous
};
 
class ITimerObserver
{
public:
    virtual ~ITimerObserver() = default;
 
    virtual void Update() = 0;
};
 
using slot = std::function<void()>;
 
class ITimerSubject
{
public:
    virtual ~ITimerSubject() = default;
 
    virtual void
    Attach(ITimerObserver* observer, timer_mode mode, std::chrono::milliseconds ms) = 0;
 
    virtual void Attach(slot functionPtr, timer_mode mode, std::chrono::milliseconds ms) = 0;
 
    virtual void Detach(ITimerObserver* observer) = 0;
};
 
class IObservable
{
public:
    virtual ~IObservable() = default;
    virtual void notify() = 0;
 
    virtual bool toDestroy() = 0;
};
 
class Timer : ITimerSubject
{
 
    class TimerObservable : public IObservable
    {
    public:
        ~TimerObservable() override{};
 
        TimerObservable(ITimerObserver* observer, timer_mode mode, std::chrono::milliseconds ms) :
            timerMode(mode), m_observable(observer), interval(ms), isFinish(false)
        {
            this->nextExecution = std::chrono::system_clock::now() + ms;
        }
 
        void
        notify() override
        {
            if (std::chrono::system_clock::now() >= this->nextExecution)
            {
                this->isFinished = std::async(std::launch::async,
                                              [this]
                                              {
                                                  if (this->m_observable != nullptr)
                                                  {
                                                      this->m_observable->Update();
                                                  }
                                              });
                if (this->timerMode == continuous)
                {
                    this->nextExecution = std::chrono::system_clock::now() + interval;
                }
                else
                {
                    // destroy object
                    this->isFinish = true;
                }
            }
        }
 
        bool
        toDestroy() override
        {
            return isFinish && this->timerMode == singleshot;
        }
 
    private:
        timer_mode timerMode;
        ITimerObserver* m_observable;
        std::chrono::milliseconds interval;
        std::chrono::time_point<std::chrono::system_clock> nextExecution;
        std::future<void> isFinished;
        bool isFinish;
    };
 
    class SlotObservable : public IObservable
    {
    public:
        ~SlotObservable() override
        {
        }
 
        SlotObservable(slot fPointer, timer_mode mode, std::chrono::milliseconds ms) :
            timerMode(mode), interval(ms), functionPointer(std::move(fPointer)), isFinish(false)
        {
 
            this->nextExecution = std::chrono::system_clock::now() + ms;
        }
 
        void
        notify() override
        {
            if (std::chrono::system_clock::now() >= this->nextExecution)
            {
                //this->isFinished = this->promise.get_future();
                auto p = std::async(std::launch::async,
                                    [this]
                                    {
                                        try
                                        {
                                            if (this->functionPointer != nullptr)
                                            {
                                                this->functionPointer();
                                                this->promise.set_value(true);
                                            }
                                            this->promise.set_value(false);
                                        }
                                        catch (std::future_error& e)
                                        {
                                            std::cout << "future already satisfied" << e.what()
                                                      << std::endl;
                                        }
                                    });
                if (this->timerMode == continuous)
                {
                    this->nextExecution = std::chrono::system_clock::now() + interval;
                }
                else
                {
                    // destroy object
                    this->isFinish = true;
                }
            }
        }
 
        bool
        toDestroy() override
        {
            return isFinish && this->timerMode == singleshot;
        }
 
        std::future<bool>&
        getFut()
        {
            return this->isFinished;
        }
 
    private:
        timer_mode timerMode;
        std::chrono::milliseconds interval;
        std::chrono::time_point<std::chrono::system_clock> nextExecution;
        std::future<bool> isFinished;
        std::promise<bool> promise;
        slot functionPointer;
        bool isFinish;
    };
 
    class FutureObservable : public IObservable
    {
    public:
        ~FutureObservable() override
        {
        }
 
        FutureObservable(slot fPointer, std::shared_future<bool> sfuture) :
            sfut(std::move(sfuture)), functionPointer(std::move(fPointer)), isFinish(false)
        {
        }
 
        void
        notify() override
        {
            if (this->sfut.valid())
            {
                if (this->sfut.get())
                {
                    this->isFinished = this->isFinishedPromise.get_future();
                    auto promise = std::async(std::launch::async,
                                              [this]
                                              {
                                                  if (this->functionPointer != nullptr)
                                                  {
                                                      this->functionPointer();
                                                      this->isFinish = true;
                                                      this->isFinishedPromise.set_value(true);
                                                  }
                                                  this->isFinishedPromise.set_value(false);
                                              });
                }
            }
        }
 
        bool
        toDestroy() override
        {
            return this->isFinish;
        }
 
        std::future<bool>&
        getFut()
        {
            return this->isFinished;
        }
 
    private:
        std::future<bool> isFinished;
        std::promise<bool> isFinishedPromise;
        std::shared_future<bool> sfut;
        slot functionPointer;
        bool isFinish;
    };
 
 
public:
    static std::shared_ptr<Timer>
    createTimer()
    {
        if (instance == nullptr)
        {
            instance = std::make_shared<Timer>();
        }
        return instance;
    }
 
    static std::future<bool>&
    singleShot(const slot& functionPointer, std::chrono::milliseconds ms)
    {
        return Timer::createTimer()->AttachSingleshot(functionPointer, ms);
    }
 
    static void
    periodicShot(slot functionPointer, std::chrono::milliseconds ms)
    {
        Timer::createTimer()->Attach(std::move(functionPointer), continuous, ms);
    }
 
    static std::future<bool>&
    futureWatch(const slot& functionPointer, const std::shared_future<bool>& fut)
    {
        return Timer::createTimer()->AttachFutureWatcher(functionPointer, fut);
    }
 
    ~Timer() override
    {
        for (auto it = this->v_observables.begin(); it != this->v_observables.end(); it++)
        {
            this->v_observables.erase(it--);
        }
        this->b_isRunning = false;
    }
 
    static void
    stop()
    {
        Timer::instance->b_isRunning = false;
    }
 
    static bool
    isRunning()
    {
        return Timer::instance->b_isRunning;
    }
 
    void
    start()
    {
        if (!b_isRunning)
        {
            b_isRunning = true;
            this->wait_thread->detach();
        }
    }
 
    void
    Attach(ITimerObserver* observer, timer_mode mode, std::chrono::milliseconds ms) override
    {
        this->start();
        if (this->time > ms)
        {
            this->time = ms;
        }
        this->v_observables.push_back(std::make_unique<TimerObservable>(observer, mode, ms));
    }
 
    void
    Detach(ITimerObserver* observer) override
    {
        (void)observer;
    }
 
    explicit Timer()
    {
        this->wait_thread = std::make_unique<std::thread>(&Timer::dispatcher, this);
        this->time = std::chrono::milliseconds(1000);
    }
 
private:
    std::future<bool>&
    AttachFutureWatcher(const slot& functionPointer, const std::shared_future<bool>& sfut)
    {
        this->start();
        auto o = std::make_unique<FutureObservable>(functionPointer, sfut);
        std::future<bool>& fut{o->getFut()};
        this->v_observables.push_back(std::move(o));
        return fut;
    }
 
    std::future<bool>&
    AttachSingleshot(const slot& functionPointer, std::chrono::milliseconds ms)
    {
        this->start();
        if (this->time > ms)
        {
            this->time = ms;
        }
        auto o = std::make_unique<SlotObservable>(functionPointer, singleshot, ms);
        auto& fut = o->getFut();
        this->v_observables.push_back(std::move(o));
        return fut;
    }
 
    void
    Attach(slot functionPointer, timer_mode mode, std::chrono::milliseconds ms) override
    {
        this->start();
        if (this->time > ms)
        {
            this->time = ms;
        }
        this->v_observables.push_back(std::make_unique<SlotObservable>(functionPointer, mode, ms));
    }
 
    void
    dispatcher()
    {
        do
        {
            std::unique_lock<std::mutex> lck{mtx};
            for (int i{10}; i > 0 && b_isRunning; --i)
            {
                cv.wait_for(lck, time / 10);
 
                for (auto it = this->v_observables.begin(); it != this->v_observables.end(); it++)
                {
                    (*it)->notify();
                    if ((*it)->toDestroy())
                    {
                        (*it).reset(nullptr);
                        this->v_observables.erase(it--);
                    }
                }
            }
 
 
        } while (this->b_isRunning);
        for (auto it = this->v_observables.begin(); it != this->v_observables.end(); it++)
        {
            this->v_observables.erase(it--);
        }
    }
 
    std::mutex mtx;
    std::condition_variable cv{};
    std::vector<std::unique_ptr<IObservable>> v_observables;
 
    std::unique_ptr<std::thread> wait_thread;
    std::atomic_bool b_isRunning{};
    std::chrono::milliseconds time{};
 
    static std::shared_ptr<Timer> instance;
};