listen_socket.hpp

#pragma once
 
#include "fly/net/socket/concepts.hpp"
#include "fly/net/socket/detail/base_socket.hpp"
 
#include <functional>
#include <memory>
#include <optional>
 
namespace fly::net {
 
class NetworkConfig;
class SocketService;
 
template <IPEndpoint EndpointType>
class TcpSocket;
 
template <IPEndpoint EndpointType>
class ListenSocket :
    public detail::BaseSocket<EndpointType>,
    public std::enable_shared_from_this<ListenSocket<EndpointType>>
{
    using BaseSocket = detail::BaseSocket<EndpointType>;
 
    using AcceptCompletion = std::function<void(std::shared_ptr<TcpSocket<EndpointType>>)>;
 
public:
    explicit ListenSocket(std::shared_ptr<NetworkConfig> config) noexcept;
 
    ListenSocket(std::shared_ptr<NetworkConfig> config, IOMode mode) noexcept;
 
    ListenSocket(ListenSocket &&socket) noexcept;
 
    ListenSocket &operator=(ListenSocket &&socket) noexcept;
 
    bool listen();
 
    bool is_listening() const;
 
    std::optional<TcpSocket<EndpointType>> accept();
 
    bool accept_async(AcceptCompletion &&callback);
 
    using BaseSocket::close;
    using BaseSocket::handle;
    using BaseSocket::io_mode;
 
private:
    friend SocketService;
 
    static std::shared_ptr<ListenSocket> create_socket(
        const std::shared_ptr<SocketService> &service,
        std::shared_ptr<NetworkConfig> config);
 
    ListenSocket(
        const std::shared_ptr<SocketService> &service,
        std::shared_ptr<NetworkConfig> config) noexcept;
 
    void ready_to_accept(AcceptCompletion &&callback);
 
    using BaseSocket::network_config;
    using BaseSocket::socket_service;
 
    bool m_is_listening {false};
};
 
} // namespace fly::net