TimerFD.hxx

#pragma once
 
// Linux
#include <sys/timerfd.h>
 
// cosmos
#include <cosmos/BitMask.hxx>
#include <cosmos/fs/FDFile.hxx>
#include <cosmos/time/Clock.hxx>
 
namespace cosmos {
 
 
template <ClockType CLOCK>
class TimerFD :
                protected FDFile {
        // this is not copy/assignable
        TimerFD(const TimerFD&) = delete;
        TimerFD& operator=(const TimerFD&) = delete;
public: // types
 
        enum class CreateFlag : int {
                NONBLOCK = TFD_NONBLOCK,
                CLOEXEC  = TFD_CLOEXEC
        };
 
        using CreateFlags = BitMask<CreateFlag>;
 
        enum class StartFlag : int {
                ABSTIME       = TFD_TIMER_ABSTIME,
                CANCEL_ON_SET = TFD_TIMER_CANCEL_ON_SET
        };
 
        using StartFlags = BitMask<StartFlag>;
 
        struct TimerSpec :
                        public itimerspec {
 
                TimerSpec() {
                        initial().reset();
                        interval().reset();
                }
 
 
                TimeSpec<CLOCK>& initial() {
                        // this is a bit hacky but allows us to return the C++
                        // interface for the raw timespec value
                        return *reinterpret_cast<TimeSpec<CLOCK>*>(&(this->it_value));
                }
 
 
                TimeSpec<CLOCK>& interval() {
                        return *reinterpret_cast<TimeSpec<CLOCK>*>(&(this->it_interval));
                }
 
 
                void makeEqualInterval() {
                        interval() = initial();
                }
 
                void resetInterval() {
                        interval().reset();
                }
        };
 
        struct CreateT {};
        static CreateT defaults;
 
public:
 
        TimerFD() = default;
 
        explicit TimerFD(const CreateFlags flags) {
                create(flags);
        }
 
 
        explicit TimerFD(const CreateT) {
                create();
        }
 
        TimerFD(TimerFD &&other) noexcept {
                *this = std::move(other);
        }
 
        TimerFD& operator=(TimerFD &&other) noexcept {
                static_cast<FDFile&>(*this) = std::move(other);
                return *this;
        }
 
        using FDFile::close;
        using FileBase::fd;
        using FileBase::isOpen;
 
 
        void create(const CreateFlags flags = CreateFlags{CreateFlag::CLOEXEC});
 
 
        void close() override {
                FDFile::close();
        }
 
 
        void setTime(const TimerSpec spec, const StartFlags flags = StartFlags{});
 
 
        TimerSpec getTime() const;
 
 
        uint64_t wait();
 
 
        void disarm() {
                setTime(TimerSpec{});
        }
};
 
using RealTimeTimerFD  = TimerFD<ClockType::REALTIME>;
using MonotonicTimerFD = TimerFD<ClockType::MONOTONIC>;
using BootTimeTimerFD  = TimerFD<ClockType::BOOTTIME>;
 
extern template class COSMOS_API TimerFD<ClockType::BOOTTIME>;
extern template class COSMOS_API TimerFD<ClockType::MONOTONIC>;
extern template class COSMOS_API TimerFD<ClockType::REALTIME>;
 
} // end ns