timer.hpp

Go to the documentation of this file.

 
#ifndef JOIN_CORE_TIMER_HPP
#define JOIN_CORE_TIMER_HPP
 
// libjoin.
#include <join/reactor.hpp>
 
// C++.
#include <functional>
#include <stdexcept>
#include <chrono>
 
// C.
#include <sys/timerfd.h>
#include <unistd.h>
 
namespace join
{
    class RealTime;
    class Monotonic;
 
    template <class ClockPolicy>
    class BasicTimer : protected EventHandler
    {
    public:
        BasicTimer (Reactor* reactor = nullptr)
        : _handle (timerfd_create (_policy.type (), TFD_NONBLOCK | TFD_CLOEXEC))
        , _reactor (reactor)
        {
            if (_handle == -1)
            {
                throw std::system_error (errno, std::system_category (), "timerfd_create failed");
            }
 
            if (_reactor == nullptr)
            {
                _reactor = ReactorThread::reactor ();
            }
 
            _reactor->addHandler (_handle, this);
        }
 
        BasicTimer (const BasicTimer& other) = delete;
 
        BasicTimer& operator= (const BasicTimer& other) = delete;
 
        BasicTimer (BasicTimer&& other) = delete;
 
        BasicTimer& operator= (BasicTimer&& other) = delete;
 
        virtual ~BasicTimer () noexcept
        {
            _reactor->delHandler (_handle);
            if (_handle != -1)
            {
                close (_handle);
            }
        }
 
        template <class Rep, class Period, typename Func>
        void setOneShot (std::chrono::duration<Rep, Period> duration, Func&& callback)
        {
            auto ns   = std::chrono::duration_cast<std::chrono::nanoseconds> (duration);
            _callback = std::forward<Func> (callback);
            _oneShot  = true;
            _ns       = std::chrono::nanoseconds::zero ();
 
            auto ts = toTimerSpec (ns);
            timerfd_settime (handle (), 0, &ts, nullptr);
        }
 
        template <class Clock, class Duration, typename Func>
        void setOneShot (std::chrono::time_point<Clock, Duration> timePoint, Func&& callback)
        {
            static_assert (
                (std::is_same<ClockPolicy, RealTime>::value && std::is_same<Clock, std::chrono::system_clock>::value) ||
                    (std::is_same<ClockPolicy, Monotonic>::value &&
                     std::is_same<Clock, std::chrono::steady_clock>::value),
                "Clock type mismatch timer policy");
 
            auto elapsed = timePoint.time_since_epoch ();
            auto ns      = std::chrono::duration_cast<std::chrono::nanoseconds> (elapsed);
            _callback    = std::forward<Func> (callback);
            _oneShot     = true;
            _ns          = std::chrono::nanoseconds::zero ();
 
            auto ts = toTimerSpec (ns);
            timerfd_settime (handle (), TFD_TIMER_ABSTIME, &ts, nullptr);
        }
 
        template <class Rep, class Period, typename Func>
        void setInterval (std::chrono::duration<Rep, Period> duration, Func&& callback)
        {
            auto ns   = std::chrono::duration_cast<std::chrono::nanoseconds> (duration);
            _callback = std::forward<Func> (callback);
            _oneShot  = false;
            _ns       = ns;
 
            auto ts = toTimerSpec (ns, true);
            timerfd_settime (handle (), 0, &ts, nullptr);
        }
 
        void cancel () noexcept
        {
            _callback = nullptr;
            _oneShot  = true;
            _ns       = std::chrono::nanoseconds::zero ();
 
            struct itimerspec ts = {};
            timerfd_settime (handle (), 0, &ts, nullptr);
        }
 
        bool active () const noexcept
        {
            struct itimerspec ts = {};
            timerfd_gettime (handle (), &ts);
            const bool hasValue    = (ts.it_value.tv_sec != 0 || ts.it_value.tv_nsec != 0);
            const bool hasInterval = (ts.it_interval.tv_sec != 0 || ts.it_interval.tv_nsec != 0);
            return hasValue || hasInterval;
        }
 
        std::chrono::nanoseconds remaining () const
        {
            struct itimerspec ts = {};
            timerfd_gettime (handle (), &ts);
            return std::chrono::seconds (ts.it_value.tv_sec) + std::chrono::nanoseconds (ts.it_value.tv_nsec);
        }
 
        std::chrono::nanoseconds interval () const noexcept
        {
            return _ns;
        }
 
        bool oneShot () const noexcept
        {
            return _oneShot;
        }
 
        int type () const noexcept
        {
            return _policy.type ();
        }
 
    protected:
        virtual void onReceive ([[maybe_unused]] int fd) override
        {
            uint64_t expirations;
            ssize_t result = read (handle (), &expirations, sizeof (expirations));
            if (result == sizeof (expirations) && _callback)
            {
                for (uint64_t i = 0; i < expirations; ++i)
                {
                    _callback ();
                }
            }
        }
 
        static itimerspec toTimerSpec (std::chrono::nanoseconds ns, bool periodic = false) noexcept
        {
            struct itimerspec ts = {};
            ts.it_value.tv_sec   = ns.count () / NS_PER_SEC;
            ts.it_value.tv_nsec  = ns.count () % NS_PER_SEC;
            if (periodic)
            {
                ts.it_interval.tv_sec  = ts.it_value.tv_sec;
                ts.it_interval.tv_nsec = ts.it_value.tv_nsec;
            }
            return ts;
        }
 
        int handle () const noexcept
        {
            return _handle;
        }
 
    private:
        static constexpr uint64_t NS_PER_SEC = 1000000000ULL;
 
        ClockPolicy _policy;
 
        std::function<void ()> _callback;
 
        std::chrono::nanoseconds _ns{};
 
        bool _oneShot = true;
 
        int _handle = -1;
 
        Reactor* _reactor;
    };
 
    class RealTime
    {
    public:
        using Timer = BasicTimer<RealTime>;
 
        constexpr RealTime () noexcept = default;
 
        constexpr int type () const noexcept
        {
            return CLOCK_REALTIME;
        }
    };
 
    class Monotonic
    {
    public:
        using Timer = BasicTimer<Monotonic>;
 
        constexpr Monotonic () noexcept = default;
 
        constexpr int type () const noexcept
        {
            return CLOCK_MONOTONIC;
        }
    };
}
 
#endif