Poller.hxx

#pragma once
 
// C++
#include <chrono>
#include <optional>
#include <vector>
 
// Linux
#include <sys/epoll.h>
 
// cosmos
#include <cosmos/BitMask.hxx>
#include <cosmos/fs/FileDescriptor.hxx>
#include <cosmos/time/types.hxx>
 
namespace cosmos {
 
 
class COSMOS_API Poller {
public: // types
 
        enum class MonitorFlag : uint32_t {
                INPUT          = EPOLLIN,
                OUTPUT         = EPOLLOUT,
                SOCKET_HANGUP  = EPOLLRDHUP,
                EXCEPTIONS     = EPOLLPRI,
                EDGE_TRIGGERED = EPOLLET,
                ONESHOT        = EPOLLONESHOT,
                STAY_AWAKE     = EPOLLWAKEUP
        };
 
        using MonitorFlags = BitMask<MonitorFlag>;
 
        enum class Event : uint32_t {
                INPUT_READY       = EPOLLIN,
                OUTPUT_READY      = EPOLLOUT,
                SOCKET_HANGUP     = EPOLLRDHUP,
                EXCEPTION_OCCURED = EPOLLPRI,
                ERROR_OCCURED     = EPOLLERR,
                HANGUP_OCCURED    = EPOLLHUP
        };
 
        using EventMask = BitMask<Event>;
 
        struct PollEvent : protected epoll_event {
                friend class Poller;
        public:
 
                FileDescriptor fd() const { return FileDescriptor{FileNum{(this->data).fd}}; }
 
                auto getEvents() const { return EventMask{static_cast<std::underlying_type<Event>::type>(this->events)}; }
        };
 
public: // functions
 
        Poller() {}
 
 
        explicit Poller(size_t max_events) {
                create(max_events);
        }
 
        ~Poller();
 
        Poller(const Poller&) = delete;
        Poller& operator=(const Poller&) = delete;
 
 
        void create(size_t max_events = 16);
 
 
        void close();
 
        bool valid() const { return m_poll_fd.valid(); }
 
 
        void addFD(const FileDescriptor fd, const MonitorFlags flags);
 
 
        void modFD(const FileDescriptor fd, const MonitorFlags flags);
 
 
        void delFD(const FileDescriptor fd);
 
 
        std::vector<PollEvent> wait(const std::optional<IntervalTime> timeout = {});
 
protected: // functions
 
        int rawPollFD() const;
 
protected: // data
 
        FileDescriptor m_poll_fd;
        std::vector<PollEvent> m_events;
};
 
} // end ns