timer.h

/*
 * Copyright (C) 2018 Microchip Technology Inc.  All rights reserved.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef EGT_TIMER_H
#define EGT_TIMER_H
 
#include <chrono>
#include <egt/asio.hpp>
#include <egt/detail/meta.h>
#include <memory>
#include <vector>
 
namespace egt
{
inline namespace v1
{
class EGT_API Timer
{
public:
 
    using TimerCallback = std::function<void()>;
 
    Timer() noexcept;
 
    explicit Timer(std::chrono::milliseconds duration) noexcept;
 
    Timer(const Timer&) = delete;
    Timer& operator=(const Timer&) = delete;
    // NOLINTNEXTLINE(hicpp-noexcept-move,performance-noexcept-move-constructor)
    Timer(Timer&&);
    // NOLINTNEXTLINE(hicpp-noexcept-move,performance-noexcept-move-constructor)
    Timer& operator=(Timer&&);
 
    virtual void start();
 
    void start(std::chrono::milliseconds duration)
    {
        m_duration = duration;
        start();
    }
 
    EGT_DEPRECATED void start_with_duration(std::chrono::milliseconds duration);
 
    void change_duration(std::chrono::milliseconds duration);
 
    void cancel();
 
    void stop() { cancel(); }
 
    void timeout();
 
    EGT_NODISCARD std::chrono::milliseconds duration() const { return m_duration; }
 
    EGT_NODISCARD bool running() const { return m_running; }
 
    using RegisterHandle = uint64_t;
 
    RegisterHandle on_timeout(TimerCallback callback);
 
    void clear_handlers();
 
    void remove_handler(RegisterHandle handle);
 
    EGT_NODISCARD const std::string& name() const { return m_name; }
 
    void name(const std::string& name) { m_name = name; }
 
    virtual ~Timer() noexcept;
 
protected:
 
    RegisterHandle m_handle_counter{0};
 
    void invoke_handlers();
 
    struct CallbackMeta
    {
        CallbackMeta(TimerCallback c,
                     RegisterHandle h) noexcept
            : callback(std::move(c)),
              handle(h)
        {}
 
        TimerCallback callback;
        RegisterHandle handle{0};
    };
 
    using CallbackArray = std::vector<CallbackMeta>;
 
    asio::steady_timer m_timer;
 
    std::chrono::milliseconds m_duration{};
 
    CallbackArray m_callbacks;
 
    bool m_running{false};
 
    std::string m_name;
 
    struct TimerImpl;
    std::unique_ptr<TimerImpl> m_impl;
 
private:
 
    void internal_timer_callback(const asio::error_code& error);
    void do_cancel();
};
 
class EGT_API PeriodicTimer : public Timer
{
public:
 
    using Timer::Timer;
    using Timer::start;
    void start() override;
 
private:
 
    void internal_timer_callback(const asio::error_code& error);
};
 
}
}
 
#endif