tcp.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 <future>
#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:tcp;
 
import :core;
 
// =============================================================================
// TCP Client
// =============================================================================
 
export namespace kcenon::network::core {
 
class messaging_client {
public:
    explicit messaging_client(std::string_view client_id);
 
    virtual ~messaging_client() noexcept;
 
    // Non-copyable, movable
    messaging_client(const messaging_client&) = delete;
    messaging_client& operator=(const messaging_client&) = delete;
    messaging_client(messaging_client&&) noexcept;
    messaging_client& operator=(messaging_client&&) noexcept;
 
    bool start_client(std::string_view host, uint16_t port);
 
    void stop_client();
 
    bool wait_for_stop(std::chrono::milliseconds timeout = std::chrono::milliseconds(5000));
 
    bool send_packet(std::span<const uint8_t> data);
 
    bool send_packet(std::string_view data);
 
    bool is_connected() const noexcept;
 
    bool is_running() const noexcept;
 
    connection_state get_state() 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_error_callback(error_callback callback);
 
    void set_data_callback(data_callback callback);
 
    void set_auto_reconnect(bool enable, std::chrono::seconds delay = std::chrono::seconds(5));
 
    void set_heartbeat(bool enable, std::chrono::seconds interval = std::chrono::seconds(30));
 
private:
    struct impl;
    std::unique_ptr<impl> pimpl_;
};
 
// =============================================================================
// TCP Server
// =============================================================================
 
class messaging_server {
public:
    using client_connected_callback = std::function<void(const std::string& session_id)>;
 
    using client_disconnected_callback = std::function<void(const std::string& session_id)>;
 
    using client_data_callback = std::function<void(
        const std::string& session_id,
        std::span<const uint8_t> data)>;
 
    explicit messaging_server(std::string_view server_id);
 
    virtual ~messaging_server() noexcept;
 
    // Non-copyable, movable
    messaging_server(const messaging_server&) = delete;
    messaging_server& operator=(const messaging_server&) = delete;
    messaging_server(messaging_server&&) noexcept;
    messaging_server& operator=(messaging_server&&) noexcept;
 
    bool start_server(uint16_t port, int backlog = 128);
 
    bool start_server(std::string_view address, uint16_t port, int backlog = 128);
 
    void stop_server();
 
    bool wait_for_stop(std::chrono::milliseconds timeout = std::chrono::milliseconds(5000));
 
    bool send_to(std::string_view session_id, std::span<const uint8_t> data);
 
    bool send_to(std::string_view session_id, std::string_view data);
 
    void broadcast(std::span<const uint8_t> data);
 
    void broadcast(std::string_view data);
 
    void disconnect(std::string_view session_id);
 
    bool is_running() const noexcept;
 
    size_t client_count() const noexcept;
 
    std::string_view server_id() const noexcept;
 
    void set_client_connected_callback(client_connected_callback callback);
 
    void set_client_disconnected_callback(client_disconnected_callback callback);
 
    void set_client_data_callback(client_data_callback callback);
 
    void set_error_callback(error_callback callback);
 
private:
    struct impl;
    std::unique_ptr<impl> pimpl_;
};
 
// =============================================================================
// Messaging Session
// =============================================================================
 
class messaging_session : public std::enable_shared_from_this<messaging_session> {
public:
    explicit messaging_session(std::string session_id);
 
    virtual ~messaging_session() noexcept;
 
    const std::string& session_id() const noexcept;
 
    bool is_active() const noexcept;
 
    std::string remote_address() const;
 
    uint16_t remote_port() const;
 
    bool send(std::span<const uint8_t> data);
 
    void close();
 
private:
    struct impl;
    std::unique_ptr<impl> pimpl_;
};
 
} // namespace kcenon::network::core