reliable_udp_client.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2024, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
// Experimental API marker - users must opt-in to use this header
#include "internal/experimental/experimental_api.h"
NETWORK_REQUIRE_EXPERIMENTAL
 
#include <cstdint>
#include <functional>
#include <memory>
#include <string>
#include <string_view>
#include <system_error>
#include <vector>
 
#include "kcenon/network/detail/utils/result_types.h"
 
namespace kcenon::network::core
{
    enum class reliability_mode
    {
        unreliable,         
        reliable_ordered,   
        reliable_unordered, 
        sequenced           
    };
 
    struct reliable_udp_stats
    {
        uint64_t packets_sent{0};          
        uint64_t packets_received{0};      
        uint64_t packets_retransmitted{0}; 
        uint64_t packets_dropped{0};       
        uint64_t acks_sent{0};             
        uint64_t acks_received{0};         
        double average_rtt_ms{0.0};        
    };
 
    class reliable_udp_client : public std::enable_shared_from_this<reliable_udp_client>
    {
    public:
        reliable_udp_client(
            std::string_view client_id,
            reliability_mode mode = reliability_mode::reliable_ordered);
 
        ~reliable_udp_client() noexcept;
 
        auto start_client(std::string_view host, uint16_t port) -> VoidResult;
 
        auto stop_client() -> VoidResult;
 
        auto send_packet(std::vector<uint8_t>&& data) -> VoidResult;
 
        auto wait_for_stop() -> void;
 
        auto set_receive_callback(
            std::function<void(const std::vector<uint8_t>&)> callback) -> void;
 
        auto set_error_callback(std::function<void(std::error_code)> callback) -> void;
 
        auto set_congestion_window(size_t packets) -> void;
 
        auto set_max_retries(size_t retries) -> void;
 
        auto set_retransmission_timeout(uint32_t timeout_ms) -> void;
 
        auto get_stats() const -> reliable_udp_stats;
 
        auto is_running() const -> bool;
 
        auto client_id() const -> const std::string&;
 
        auto mode() const -> reliability_mode;
 
    private:
        class impl;
        std::unique_ptr<impl> pimpl_; 
    };
 
} // namespace kcenon::network::core