timer.hpp

Go to the documentation of this file.

 
#ifndef JOIN_CORE_TIMER_HPP
#define JOIN_CORE_TIMER_HPP
 
// libjoin.
#include <join/reactor.hpp>
#include <join/clock.hpp>
 
// C++.
#include <functional>
#include <stdexcept>
#include <chrono>
 
// C.
#include <sys/timerfd.h>
#include <unistd.h>
 
namespace join
{
    template <class ClockPolicy>
    class BasicTimer : protected EventHandler
    {
    public:
        explicit BasicTimer (Reactor* reactor = nullptr)
        : _handle (timerfd_create (ClockPolicy::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;
 
        ~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 noexcept
        {
            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;
        }
 
        static constexpr int type () noexcept
        {
            return ClockPolicy::type ();
        }
 
    private:
        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 constexpr itimerspec toTimerSpec (std::chrono::nanoseconds ns, bool periodic = false) noexcept
        {
            itimerspec ts{};
            ts.it_value.tv_sec = ns.count () / _nsPerSec;
            ts.it_value.tv_nsec = ns.count () % _nsPerSec;
            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;
        }
 
        static constexpr uint64_t _nsPerSec = 1000000000ULL;
 
        std::function<void ()> _callback;
 
        std::chrono::nanoseconds _ns{};
 
        bool _oneShot = true;
 
        int _handle = -1;
 
        Reactor* _reactor;
    };
}
 
#endif