udp.cppm

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
module;
 
// =============================================================================
// Global Module Fragment - Standard Library Headers
// =============================================================================
#include <atomic>
#include <chrono>
#include <functional>
#include <memory>
#include <mutex>
#include <optional>
#include <span>
#include <string>
#include <string_view>
#include <vector>
 
// Third-party headers
#include <asio.hpp>
 
export module kcenon.network:udp;
 
import :core;
 
// =============================================================================
// UDP Client
// =============================================================================
 
export namespace kcenon::network::core {
 
class messaging_udp_client {
public:
    using udp_data_callback = std::function<void(
        std::span<const uint8_t> data,
        const std::string& from_address,
        uint16_t from_port)>;
 
    explicit messaging_udp_client(std::string_view client_id);
 
    virtual ~messaging_udp_client() noexcept;
 
    // Non-copyable, movable
    messaging_udp_client(const messaging_udp_client&) = delete;
    messaging_udp_client& operator=(const messaging_udp_client&) = delete;
    messaging_udp_client(messaging_udp_client&&) noexcept;
    messaging_udp_client& operator=(messaging_udp_client&&) noexcept;
 
    bool start_client(std::string_view remote_host, uint16_t remote_port, uint16_t local_port = 0);
 
    void stop_client();
 
    bool send_packet(std::span<const uint8_t> data);
 
    bool send_packet(std::string_view data);
 
    bool send_to(std::span<const uint8_t> data, std::string_view host, uint16_t port);
 
    bool is_running() const noexcept;
 
    std::string_view client_id() const noexcept;
 
    void set_data_callback(udp_data_callback callback);
 
    void set_error_callback(error_callback callback);
 
    bool join_multicast_group(std::string_view multicast_address);
 
    bool leave_multicast_group(std::string_view multicast_address);
 
private:
    struct impl;
    std::unique_ptr<impl> pimpl_;
};
 
// =============================================================================
// UDP Server
// =============================================================================
 
class messaging_udp_server {
public:
    using udp_data_callback = std::function<void(
        std::span<const uint8_t> data,
        const std::string& from_address,
        uint16_t from_port)>;
 
    explicit messaging_udp_server(std::string_view server_id);
 
    virtual ~messaging_udp_server() noexcept;
 
    // Non-copyable, movable
    messaging_udp_server(const messaging_udp_server&) = delete;
    messaging_udp_server& operator=(const messaging_udp_server&) = delete;
    messaging_udp_server(messaging_udp_server&&) noexcept;
    messaging_udp_server& operator=(messaging_udp_server&&) noexcept;
 
    bool start_server(uint16_t port);
 
    bool start_server(std::string_view address, uint16_t port);
 
    void stop_server();
 
    bool send_to(std::span<const uint8_t> data, std::string_view host, uint16_t port);
 
    bool send_to(std::string_view data, std::string_view host, uint16_t port);
 
    bool broadcast(std::span<const uint8_t> data, uint16_t port);
 
    bool is_running() const noexcept;
 
    std::string_view server_id() const noexcept;
 
    void set_data_callback(udp_data_callback callback);
 
    void set_error_callback(error_callback callback);
 
    bool join_multicast_group(std::string_view multicast_address);
 
private:
    struct impl;
    std::unique_ptr<impl> pimpl_;
};
 
// =============================================================================
// Reliable UDP Client
// =============================================================================
 
class reliable_udp_client {
public:
    explicit reliable_udp_client(std::string_view client_id);
 
    virtual ~reliable_udp_client() noexcept;
 
    // Non-copyable, movable
    reliable_udp_client(const reliable_udp_client&) = delete;
    reliable_udp_client& operator=(const reliable_udp_client&) = delete;
    reliable_udp_client(reliable_udp_client&&) noexcept;
    reliable_udp_client& operator=(reliable_udp_client&&) noexcept;
 
    bool start_client(std::string_view remote_host, uint16_t remote_port);
 
    void stop_client();
 
    bool send_reliable(std::span<const uint8_t> data);
 
    bool send_unreliable(std::span<const uint8_t> data);
 
    bool is_connected() const noexcept;
 
    bool is_running() const noexcept;
 
    std::string_view client_id() const noexcept;
 
    void set_connection_callback(connection_callback callback);
 
    void set_disconnection_callback(disconnection_callback callback);
 
    void set_data_callback(data_callback callback);
 
    void set_error_callback(error_callback callback);
 
    void set_retransmit_timeout(std::chrono::milliseconds timeout);
 
    void set_max_retransmit_attempts(size_t max_attempts);
 
    std::chrono::milliseconds get_rtt() const noexcept;
 
    double get_packet_loss_rate() const noexcept;
 
private:
    struct impl;
    std::unique_ptr<impl> pimpl_;
};
 
} // namespace kcenon::network::core