socket_service.hpp

#pragma once
 
#include "fly/net/socket/concepts.hpp"
#include "fly/net/socket/types.hpp"
 
#include <functional>
#include <memory>
#include <vector>
 
namespace fly::task {
class SequencedTaskRunner;
} // namespace fly::task
 
namespace fly::net {
 
class NetworkConfig;
 
class SocketService : public std::enable_shared_from_this<SocketService>
{
public:
    ~SocketService() noexcept;
 
    static std::shared_ptr<SocketService> create(
        std::shared_ptr<fly::task::SequencedTaskRunner> task_runner,
        std::shared_ptr<NetworkConfig> config);
 
    template <Socket SocketType>
    std::shared_ptr<SocketType> create_socket();
 
    void remove_socket(socket_type handle);
 
    template <Socket SocketType, SocketNotification<SocketType> Callback>
    void notify_when_writable(const std::shared_ptr<SocketType> &socket, Callback &&callback);
 
    template <Socket SocketType, SocketNotification<SocketType> Callback>
    void notify_when_readable(const std::shared_ptr<SocketType> &socket, Callback &&callback);
 
private:
    using Notification = std::function<void()>;
 
    struct Request
    {
        Request(socket_type handle, Notification callback) noexcept;
 
        socket_type m_handle;
        Notification m_callback;
    };
 
    SocketService(
        std::shared_ptr<fly::task::SequencedTaskRunner> task_runner,
        std::shared_ptr<NetworkConfig> config) noexcept;
 
    void notify_when_writable(socket_type handle, Notification &&callback);
 
    void notify_when_readable(socket_type handle, Notification &&callback);
 
    template <Socket SocketType, SocketNotification<SocketType> Callback>
    Notification wrap_callback(const std::shared_ptr<SocketType> &socket, Callback &&callback);
 
    void poll();
 
    std::shared_ptr<fly::task::SequencedTaskRunner> m_task_runner;
 
    std::shared_ptr<NetworkConfig> m_config;
 
    std::vector<Request> m_write_requests;
    std::vector<Request> m_read_requests;
};
 
//==================================================================================================
template <Socket SocketType>
std::shared_ptr<SocketType> SocketService::create_socket()
{
    return SocketType::create_socket(shared_from_this(), m_config);
}
 
//==================================================================================================
template <Socket SocketType, SocketNotification<SocketType> Callback>
void SocketService::notify_when_writable(
    const std::shared_ptr<SocketType> &socket,
    Callback &&callback)
{
    notify_when_writable(socket->handle(), wrap_callback(socket, std::forward<Callback>(callback)));
}
 
//==================================================================================================
template <Socket SocketType, SocketNotification<SocketType> Callback>
void SocketService::notify_when_readable(
    const std::shared_ptr<SocketType> &socket,
    Callback &&callback)
{
    notify_when_readable(socket->handle(), wrap_callback(socket, std::forward<Callback>(callback)));
}
 
//==================================================================================================
template <Socket SocketType, SocketNotification<SocketType> Callback>
auto SocketService::wrap_callback(const std::shared_ptr<SocketType> &socket, Callback &&callback)
    -> Notification
{
    // Further wrap the callback in a structure to allow perfect forwarding into the lambda below.
    struct CallbackHolder
    {
        Callback m_callback;
    };
 
    std::weak_ptr<SocketType> weak_socket = socket;
    CallbackHolder holder {std::forward<Callback>(callback)};
 
    return [weak_socket = std::move(weak_socket), holder = std::move(holder)]() mutable {
        if (std::shared_ptr<SocketType> strong_socket = weak_socket.lock(); strong_socket)
        {
            std::invoke(std::move(holder.m_callback), std::move(strong_socket));
        }
    };
}
 
} // namespace fly::net