PollerFd.hpp

// SPDX-FileCopyrightText: 2025 Vincent Leroy
// SPDX-License-Identifier: MIT
//
// This file is part of dfx.
//
// Licensed under the MIT License. See the LICENSE file in the project root
// for full license information.
 
#pragma once
 
// Standard includes
#include <format>
 
// Project includes
#include "BorrowedFd.hpp"
#include "Callback.hpp"
#include "Events.hpp"
#include "OwnedFd.hpp"
#include <dfx-utilities/CopyMoveControl.hpp>
 
namespace dfx::FdWatch
{
class Poller;

class PollerFd
{
public:
    PollerFd() noexcept = default;

    PollerFd(Poller & poller, int fd, EventInterests events, FdCallback cb);

    PollerFd(Poller & poller, OwnedFd fd, EventInterests events, FdCallback cb);

    PollerFd(PollerFd && other) noexcept;

    DISABLE_COPY(PollerFd);

    ~PollerFd();

    PollerFd & operator=(PollerFd && other) noexcept;
 
    // Comparing 2 PollerFd doesn't make sense since a PollerFd owns its fd int
    // (through a OwnedFd) so if 2 are equals it means that there is a bug somewhere
    bool operator==(PollerFd const &) const noexcept = delete;
    bool operator!=(PollerFd const &) const noexcept = delete;
 
    bool operator==(int fd) const noexcept                { return _fd.get() == fd; }
    bool operator==(BorrowedFd const & fd) const noexcept { return _fd.get() == fd.get(); }
 
    void swap(PollerFd & other) noexcept;

    [[nodiscard]] BorrowedFd borrow() const noexcept { return BorrowedFd(*this); }
 
public:
    Poller * poller() const noexcept   { return _poller; }

    bool isRegistered() const noexcept { return _isRegistered; }

    int get() const noexcept           { return _fd.get(); }
 
public:
    void attach(Poller & poller, OwnedFd fd, EventInterests events, FdCallback cb);

    void registerTo(Poller & poller, EventInterests events, FdCallback cb);

    void migrateTo(Poller & poller, EventInterests events, FdCallback cb);

    void deregister() noexcept;

    void reset() noexcept;
 
private:
    Poller * _poller = nullptr;
    OwnedFd _fd;
    bool _isRegistered = false;
};

[[nodiscard]] inline PollerFd makePollerFd(Poller & poller, OwnedFd fd, EventInterests events, FdCallback cb) noexcept
{ return PollerFd(poller, std::move(fd), events, std::move(cb)); }
 
inline void swap(PollerFd & fd1, PollerFd & fd2) noexcept { fd1.swap(fd2); }
} // !namespace dfx::FdWatch
 
inline bool operator==(int fd1, dfx::FdWatch::PollerFd const & fd2) noexcept { return fd2 == fd1; }
 
template<>
struct std::formatter<dfx::FdWatch::PollerFd> : public formatter<int>
{
    auto format(dfx::FdWatch::PollerFd const & e, format_context & ctx) const
    { return formatter<int>::format(e.get(), ctx); }
};