udp_client_interface.h

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.
 
#pragma once
 
#include <chrono>
#include <cstdint>
#include <functional>
#include <memory>
#include <optional>
#include <span>
#include <string>
#include <vector>
 
#include <kcenon/common/patterns/result.h>
 
namespace kcenon::common {
namespace interfaces {
 
struct udp_endpoint {
    std::string host;
 
    uint16_t port = 0;
 
    udp_endpoint() = default;
 
    udp_endpoint(std::string host_, uint16_t port_)
        : host(std::move(host_)), port(port_) {}
 
    [[nodiscard]] std::string to_string() const {
        return host + ":" + std::to_string(port);
    }
 
    bool operator==(const udp_endpoint& other) const {
        return host == other.host && port == other.port;
    }
 
    bool operator!=(const udp_endpoint& other) const {
        return !(*this == other);
    }
};
 
struct udp_send_options {
    bool dont_fragment = false;
 
    uint8_t ttl = 0;
 
    std::chrono::milliseconds timeout{0};
 
    udp_send_options() = default;
};
 
struct udp_statistics {
    uint64_t packets_sent = 0;
 
    uint64_t bytes_sent = 0;
 
    uint64_t send_failures = 0;
 
    std::optional<std::chrono::steady_clock::time_point> last_send_time;
 
    void reset() {
        packets_sent = 0;
        bytes_sent = 0;
        send_failures = 0;
        last_send_time = std::nullopt;
    }
};
 
class IUdpClient {
public:
    virtual ~IUdpClient() = default;
 
    virtual ::kcenon::common::VoidResult connect(const std::string& host, uint16_t port) = 0;
 
    virtual ::kcenon::common::VoidResult connect(const udp_endpoint& endpoint) {
        return connect(endpoint.host, endpoint.port);
    }
 
    virtual ::kcenon::common::VoidResult send(std::span<const uint8_t> data) = 0;
 
    virtual ::kcenon::common::VoidResult send(std::span<const uint8_t> data,
                            const udp_send_options& options) {
        // Default implementation ignores options
        (void)options;
        return send(data);
    }
 
    virtual ::kcenon::common::VoidResult send_to(std::span<const uint8_t> data,
                               const udp_endpoint& endpoint) = 0;
 
    [[nodiscard]] virtual bool is_connected() const = 0;
 
    [[nodiscard]] virtual std::optional<udp_endpoint> get_remote_endpoint() const {
        return std::nullopt;
    }
 
    virtual void disconnect() = 0;
 
    [[nodiscard]] virtual udp_statistics get_statistics() const {
        return {};
    }
 
    virtual void reset_statistics() {}
 
    [[nodiscard]] virtual std::string get_implementation_name() const {
        return "IUdpClient";
    }
 
    // Convenience methods for string data
 
    ::kcenon::common::VoidResult send(const std::string& data) {
        return send(std::span<const uint8_t>(
            reinterpret_cast<const uint8_t*>(data.data()),
            data.size()));
    }
 
    ::kcenon::common::VoidResult send_to(const std::string& data, const udp_endpoint& endpoint) {
        return send_to(std::span<const uint8_t>(
            reinterpret_cast<const uint8_t*>(data.data()),
            data.size()), endpoint);
    }
};
 
class null_udp_client : public IUdpClient {
public:
    ::kcenon::common::VoidResult connect(const std::string& /*host*/, uint16_t /*port*/) override {
        return ::kcenon::common::VoidResult(::kcenon::common::error_info{
            ::kcenon::common::error_codes::NOT_INITIALIZED,
            "UDP client not available",
            "null_udp_client"});
    }
 
    ::kcenon::common::VoidResult send(std::span<const uint8_t> /*data*/) override {
        return ::kcenon::common::VoidResult(::kcenon::common::error_info{
            ::kcenon::common::error_codes::NOT_INITIALIZED,
            "UDP client not available",
            "null_udp_client"});
    }
 
    ::kcenon::common::VoidResult send_to(std::span<const uint8_t> /*data*/,
                       const udp_endpoint& /*endpoint*/) override {
        return ::kcenon::common::VoidResult(::kcenon::common::error_info{
            ::kcenon::common::error_codes::NOT_INITIALIZED,
            "UDP client not available",
            "null_udp_client"});
    }
 
    [[nodiscard]] bool is_connected() const override {
        return false;
    }
 
    void disconnect() override {}
 
    [[nodiscard]] std::string get_implementation_name() const override {
        return "null_udp_client";
    }
};
 
using UdpClientFactory = std::function<std::shared_ptr<IUdpClient>()>;
 
class IUdpClientProvider {
public:
    virtual ~IUdpClientProvider() = default;
 
    virtual std::shared_ptr<IUdpClient> get_udp_client() = 0;
 
    virtual std::shared_ptr<IUdpClient> create_udp_client() = 0;
};
 
}  // namespace interfaces
}  // namespace kcenon::common