udp_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 <string>
 
namespace fly::net {
 
class NetworkConfig;
class SocketService;
 
template <IPEndpoint EndpointType>
class UdpSocket :
    public detail::BaseSocket<EndpointType>,
    public std::enable_shared_from_this<UdpSocket<EndpointType>>
{
    using BaseSocket = detail::BaseSocket<EndpointType>;
 
    using SendCompletion = std::function<void(std::size_t)>;
    using ReceiveCompletion = std::function<void(std::string)>;
 
public:
    explicit UdpSocket(std::shared_ptr<NetworkConfig> config) noexcept;
 
    UdpSocket(std::shared_ptr<NetworkConfig> config, IOMode mode) noexcept;
 
    UdpSocket(UdpSocket &&socket) noexcept;
 
    UdpSocket &operator=(UdpSocket &&socket) noexcept;
 
    std::size_t send(const EndpointType &endpoint, std::string_view message);
 
    std::size_t send(std::string_view hostname, port_type port, std::string_view message);
 
    bool
    send_async(const EndpointType &endpoint, std::string_view message, SendCompletion &&callback);
 
    bool send_async(
        std::string_view hostname,
        port_type port,
        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;
 
private:
    friend SocketService;
 
    static std::shared_ptr<UdpSocket> create_socket(
        const std::shared_ptr<SocketService> &service,
        std::shared_ptr<NetworkConfig> config);
 
    UdpSocket(
        const std::shared_ptr<SocketService> &service,
        std::shared_ptr<NetworkConfig> config) noexcept;
 
    void ready_to_send(
        const EndpointType &endpoint,
        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);
 
    UdpSocket(const UdpSocket &) = delete;
    UdpSocket &operator=(const UdpSocket &) = delete;
 
    using BaseSocket::packet_size;
    using BaseSocket::socket_service;
};
 
} // namespace fly::net