socket_concepts.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
 
#include <concepts>
#include <cstdint>
#include <functional>
#include <span>
#include <system_error>
#include <type_traits>
#include <vector>
 
namespace kcenon::network::concepts {
 
// ============================================================================
// Type traits for socket handler signatures
// ============================================================================
 
template <typename F>
concept AsyncCompletionHandler =
    std::invocable<F, std::error_code, std::size_t>;
 
template <typename F>
concept ErrorCompletionHandler = std::invocable<F, std::error_code>;
 
// ============================================================================
// Base Socket Concept
// ============================================================================
 
template <typename T>
concept Socket = requires(T& socket) {
    { socket.close() } -> std::same_as<void>;
    { socket.is_closed() } -> std::convertible_to<bool>;
};
 
// ============================================================================
// Stream Socket Concept (TCP, Secure TCP)
// ============================================================================
 
template <typename T>
concept StreamSocket = Socket<T> && requires(
    T& socket, std::vector<uint8_t> data,
    std::function<void(std::error_code, std::size_t)> send_handler,
    std::function<void(const std::vector<uint8_t>&)> recv_callback,
    std::function<void(std::span<const uint8_t>)> recv_view_callback,
    std::function<void(std::error_code)> error_callback) {
    // Async send operation
    { socket.async_send(std::move(data), send_handler) } -> std::same_as<void>;
 
    // Read loop control
    { socket.start_read() } -> std::same_as<void>;
    { socket.stop_read() } -> std::same_as<void>;
 
    // Callback registration
    { socket.set_receive_callback(recv_callback) } -> std::same_as<void>;
    { socket.set_receive_callback_view(recv_view_callback) } -> std::same_as<void>;
    { socket.set_error_callback(error_callback) } -> std::same_as<void>;
};
 
// ============================================================================
// Datagram Socket Concept (UDP)
// ============================================================================
 
template <typename T>
concept DatagramSocket = Socket<T> && requires(T& socket) {
    // Receive loop control
    { socket.start_receive() } -> std::same_as<void>;
    { socket.stop_receive() } -> std::same_as<void>;
 
    // Error callback registration
    {
        socket.set_error_callback(std::function<void(std::error_code)>{})
    } -> std::same_as<void>;
};
 
template <typename T, typename Endpoint>
concept DatagramSocketWithEndpoint =
    DatagramSocket<T> && requires(
        T& socket, std::vector<uint8_t> data, const Endpoint& endpoint,
        std::function<void(std::error_code, std::size_t)> handler) {
        { socket.async_send_to(std::move(data), endpoint, handler) } -> std::same_as<void>;
    };
 
// ============================================================================
// Message Socket Concept (WebSocket)
// ============================================================================
 
template <typename T>
concept MessageSocket = requires(
    T& socket, std::string text, std::vector<uint8_t> binary,
    std::function<void(std::error_code, std::size_t)> handler) {
    // Connection state
    { socket.is_open() } -> std::convertible_to<bool>;
 
    // Read control
    { socket.start_read() } -> std::same_as<void>;
 
    // Error callback
    {
        socket.set_error_callback(std::function<void(std::error_code)>{})
    } -> std::same_as<void>;
};
 
// ============================================================================
// Backpressure-Aware Socket Concept
// ============================================================================
 
template <typename T>
concept BackpressureAwareSocket = StreamSocket<T> && requires(
    T& socket, std::vector<uint8_t> data,
    std::function<void(std::error_code, std::size_t)> handler,
    std::function<void(bool)> bp_callback) {
    // Backpressure state
    { socket.pending_bytes() } -> std::convertible_to<std::size_t>;
    { socket.is_backpressure_active() } -> std::convertible_to<bool>;
 
    // Non-blocking send
    { socket.try_send(std::move(data), handler) } -> std::convertible_to<bool>;
 
    // Backpressure notification
    { socket.set_backpressure_callback(bp_callback) } -> std::same_as<void>;
};
 
// ============================================================================
// Socket Metrics Concept
// ============================================================================
 
template <typename T>
concept MetricsAwareSocket = requires(T& socket, const T& const_socket) {
    { const_socket.metrics() };
    { socket.reset_metrics() } -> std::same_as<void>;
};
 
// ============================================================================
// Secure Socket Concept
// ============================================================================
 
template <typename T>
concept SecureSocket = StreamSocket<T> && requires(T& socket) {
    // Note: The actual async_handshake requires SSL-specific types,
    // so we only check for stream socket capabilities here.
    // Type-specific handshake validation should be done at usage site.
    requires true;
};
 
// ============================================================================
// Generic Socket Utilities
// ============================================================================
 
template <StreamSocket S>
class socket_read_guard
{
public:
    explicit socket_read_guard(S& socket) : socket_(socket) {}
    ~socket_read_guard() { socket_.stop_read(); }
 
    socket_read_guard(const socket_read_guard&) = delete;
    socket_read_guard& operator=(const socket_read_guard&) = delete;
 
private:
    S& socket_;
};
 
template <DatagramSocket S>
class datagram_receive_guard
{
public:
    explicit datagram_receive_guard(S& socket) : socket_(socket) {}
    ~datagram_receive_guard() { socket_.stop_receive(); }
 
    datagram_receive_guard(const datagram_receive_guard&) = delete;
    datagram_receive_guard& operator=(const datagram_receive_guard&) = delete;
 
private:
    S& socket_;
};
 
} // namespace kcenon::network::concepts