PollerFd.hpp

// SPDX-FileCopyrightText: 2026 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 "Callback.hpp"
#include "Events.hpp"
#include <dfx-utilities/BorrowedFd.hpp>
#include <dfx-utilities/CopyMoveControl.hpp>
#include <dfx-utilities/OwnedFd.hpp>
 
namespace dfx::FdWatch
{
class Poller;

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

    explicit PollerFd(Utils::OwnedFd fd) noexcept;

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

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

    PollerFd(PollerFd && other) noexcept;

    DFX_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==(Utils::BorrowedFd const & fd) const noexcept { return _fd.get() == fd.get(); }
 
    void swap(PollerFd & other) noexcept;

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

    bool isRegistered() const noexcept { return _isRegistered; }

    int get() const noexcept           { return _fd.get(); }

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

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

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

    void updateEvents(EventInterests events);

    void deregister() noexcept;

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

[[nodiscard]] inline PollerFd makePollerFd(Poller & poller, Utils::OwnedFd fd, EventInterests events, FdCallback cb)
{ 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); }
};