transport.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 <concepts>
#include <cstdint>
#include <span>
#include <string>
#include <type_traits>
 
namespace kcenon::common {
 
// Forward declarations
namespace interfaces {
struct http_request;
struct http_response;
struct udp_endpoint;
}  // namespace interfaces
 
namespace concepts {
 
template <typename T>
concept HttpSender = requires(T t, const interfaces::http_request& request) {
    { t.send(request) };
};
 
template <typename T>
concept HttpAvailabilityChecker = requires(const T t) {
    { t.is_available() } -> std::convertible_to<bool>;
};
 
template <typename T>
concept HttpClientLike = HttpSender<T> && HttpAvailabilityChecker<T>;
 
template <typename T>
concept HttpClientProviderLike = requires(T t) {
    { t.get_http_client() };
    { t.create_http_client() };
};
 
template <typename T>
concept UdpConnectable = requires(T t,
                                  const std::string& host,
                                  uint16_t port) {
    { t.connect(host, port) };
    { t.disconnect() } -> std::same_as<void>;
};
 
template <typename T>
concept UdpSender = requires(T t,
                             std::span<const uint8_t> data,
                             const interfaces::udp_endpoint& endpoint) {
    { t.send(data) };
    { t.send_to(data, endpoint) };
};
 
template <typename T>
concept UdpConnectionStatus = requires(const T t) {
    { t.is_connected() } -> std::convertible_to<bool>;
};
 
template <typename T>
concept UdpClientLike = UdpConnectable<T> &&
                        UdpSender<T> &&
                        UdpConnectionStatus<T>;
 
template <typename T>
concept UdpClientProviderLike = requires(T t) {
    { t.get_udp_client() };
    { t.create_udp_client() };
};
 
template <typename T>
concept TransportClient = HttpClientLike<T> || UdpClientLike<T>;
 
}  // namespace concepts
}  // namespace kcenon::common