tcp_socket.hpp

#pragma once
 
#include "fly/net/socket/concepts.hpp"
#include "fly/net/socket/detail/base_socket.hpp"
#include "fly/net/socket/types.hpp"
 
#include <cstddef>
#include <functional>
#include <memory>
#include <optional>
#include <string>
 
namespace fly::net {
 
class NetworkConfig;
class SocketService;
 
template <IPEndpoint EndpointType>
class ListenSocket;
 
template <IPEndpoint EndpointType>
class TcpSocket :
    public detail::BaseSocket<EndpointType>,
    public std::enable_shared_from_this<TcpSocket<EndpointType>>
{
    using BaseSocket = detail::BaseSocket<EndpointType>;
 
    using ConnectCompletion = std::function<void(ConnectedState)>;
    using SendCompletion = std::function<void(std::size_t)>;
    using ReceiveCompletion = std::function<void(std::string)>;
 
public:
    explicit TcpSocket(std::shared_ptr<NetworkConfig> config) noexcept;
 
    TcpSocket(std::shared_ptr<NetworkConfig> config, IOMode mode) noexcept;
 
    TcpSocket(TcpSocket &&socket) noexcept;
 
    TcpSocket &operator=(TcpSocket &&socket) noexcept;
 
    std::optional<EndpointType> remote_endpoint() const;
 
    ConnectedState connect(const EndpointType &endpoint);
 
    ConnectedState connect(std::string_view hostname, port_type port);
 
    ConnectedState connect_async(const EndpointType &endpoint, ConnectCompletion &&callback);
 
    ConnectedState
    connect_async(std::string_view hostname, port_type port, ConnectCompletion &&callback);
 
    ConnectedState finish_connect();
 
    bool is_connecting() const;
 
    bool is_connected() const;
 
    std::size_t send(std::string_view message);
 
    bool send_async(std::string_view message, SendCompletion &&callback);
 
    std::string receive();
 
    bool receive_async(ReceiveCompletion &&callback);
 
    using BaseSocket::close;
    using BaseSocket::handle;
    using BaseSocket::hostname_to_address;
    using BaseSocket::is_open;
 
private:
    friend ListenSocket<EndpointType>;
    friend SocketService;
 
    static std::shared_ptr<TcpSocket> create_socket(
        const std::shared_ptr<SocketService> &service,
        std::shared_ptr<NetworkConfig> config);
 
    static std::shared_ptr<TcpSocket> create_socket(
        const std::shared_ptr<SocketService> &service,
        std::shared_ptr<NetworkConfig> config,
        socket_type handle);
 
    TcpSocket(
        const std::shared_ptr<SocketService> &service,
        std::shared_ptr<NetworkConfig> config) noexcept;
 
    TcpSocket(std::shared_ptr<NetworkConfig> config, socket_type handle, IOMode mode) noexcept;
 
    TcpSocket(
        const std::shared_ptr<SocketService> &service,
        std::shared_ptr<NetworkConfig> config,
        socket_type handle) noexcept;
 
    TcpSocket(const TcpSocket &) = delete;
    TcpSocket &operator=(const TcpSocket &) = delete;
 
    void ready_to_send(
        std::string_view message,
        SendCompletion &&callback,
        std::size_t bytes_sent,
        std::size_t total_bytes);
 
    void ready_to_receive(ReceiveCompletion &&callback, std::string received);
 
    using BaseSocket::packet_size;
    using BaseSocket::socket_service;
 
    std::atomic<ConnectedState> m_connected_state {ConnectedState::Disconnected};
};
 
} // namespace fly::net