timer.hpp

Go to the documentation of this file.

 
#ifndef __JOIN_TIMER_HPP__
#define __JOIN_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 ()
        : _handle (timerfd_create (_policy.type (), TFD_NONBLOCK))
        {
            Reactor::instance ()->addHandler (this);
        }
 
        BasicTimer (const BasicTimer& other) = delete;
 
        BasicTimer& operator= (const BasicTimer& other) = delete;
 
        BasicTimer (BasicTimer&& other) noexcept
        : _callback (std::move (other._callback))
        , _ns (other._ns)
        , _oneShot (other._oneShot)
        , _handle (other._handle)
        {
            Reactor::instance ()->delHandler (&other);
 
            other._callback = nullptr;
            other._ns = std::chrono::nanoseconds::zero ();
            other._oneShot = true;
            other._handle = -1;
 
            Reactor::instance ()->addHandler (this);
        }
 
        BasicTimer& operator= (BasicTimer&& other) noexcept
        {
            Reactor::instance ()->delHandler (this);
            cancel ();
            if (_handle != -1)
            {
                close (_handle);
            }
 
            _callback = std::move (other._callback);
            _ns = other._ns;
            _oneShot = other._oneShot;
            _handle = other._handle;
 
            Reactor::instance ()->delHandler (&other);
 
            other._callback = nullptr;
            other._ns = std::chrono::nanoseconds::zero ();
            other._oneShot = true;
            other._handle = -1;
 
            Reactor::instance ()->addHandler (this);
 
            return *this;
        }
 
        virtual ~BasicTimer ()
        {
            Reactor::instance ()->delHandler (this);
            cancel ();
            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 ()
        {
            _callback = nullptr;
            _oneShot = true;
            _ns = std::chrono::nanoseconds::zero ();
 
            struct itimerspec ts {};
            timerfd_settime (_handle, 0, &ts, nullptr);
        }
 
        bool active () const
        {
            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 () 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
        {
            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;
        }
 
        virtual int handle () const noexcept override
        {
            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;
    };
 
    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