core.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 <concepts>
#include <functional>
#include <future>
#include <memory>
#include <mutex>
#include <optional>
#include <shared_mutex>
#include <span>
#include <string>
#include <string_view>
#include <thread>
#include <type_traits>
#include <vector>
 
// Third-party headers (must be in global module fragment)
#include <asio.hpp>
 
export module kcenon.network:core;
 
export import kcenon.common;
export import kcenon.thread;
 
// =============================================================================
// Forward Declarations
// =============================================================================
 
export namespace kcenon::network::core {
 
class network_context;
class connection_pool;
 
} // namespace kcenon::network::core
 
export namespace kcenon::network::integration {
 
class thread_pool_interface;
class logger_interface;
class monitoring_interface;
class io_context_thread_manager;
 
} // namespace kcenon::network::integration
 
// =============================================================================
// Thread Pool Interface
// =============================================================================
 
export namespace kcenon::network::integration {
 
class thread_pool_interface {
public:
    virtual ~thread_pool_interface() = default;
 
    virtual void submit(std::function<void()> task) = 0;
 
    virtual size_t worker_count() const = 0;
 
    virtual bool is_running() const = 0;
};
 
class logger_interface {
public:
    virtual ~logger_interface() = default;
 
    virtual void info(std::string_view message) = 0;
 
    virtual void warning(std::string_view message) = 0;
 
    virtual void error(std::string_view message) = 0;
 
    virtual void debug(std::string_view message) = 0;
};
 
class monitoring_interface {
public:
    virtual ~monitoring_interface() = default;
 
    virtual void record_counter(std::string_view name, int64_t value) = 0;
 
    virtual void record_gauge(std::string_view name, double value) = 0;
 
    virtual void record_histogram(std::string_view name, double value) = 0;
};
 
class io_context_thread_manager {
public:
    explicit io_context_thread_manager(size_t worker_count = 0);
 
    ~io_context_thread_manager();
 
    // Non-copyable, movable
    io_context_thread_manager(const io_context_thread_manager&) = delete;
    io_context_thread_manager& operator=(const io_context_thread_manager&) = delete;
    io_context_thread_manager(io_context_thread_manager&&) noexcept;
    io_context_thread_manager& operator=(io_context_thread_manager&&) noexcept;
 
    bool start();
 
    void stop();
 
    bool is_running() const noexcept;
 
    asio::io_context& get_io_context() noexcept;
 
    size_t worker_count() const noexcept;
 
private:
    std::unique_ptr<asio::io_context> io_context_;
    std::unique_ptr<asio::executor_work_guard<asio::io_context::executor_type>> work_guard_;
    std::vector<std::thread> workers_;
    std::atomic<bool> running_{false};
    size_t worker_count_;
    mutable std::mutex mutex_;
};
 
} // namespace kcenon::network::integration
 
// =============================================================================
// Network Context
// =============================================================================
 
export namespace kcenon::network::core {
 
class network_context {
public:
    static network_context& instance();
 
    void set_thread_pool(std::shared_ptr<integration::thread_pool_interface> pool);
 
    std::shared_ptr<integration::thread_pool_interface> get_thread_pool();
 
    void set_logger(std::shared_ptr<integration::logger_interface> logger);
 
    std::shared_ptr<integration::logger_interface> get_logger();
 
    void set_monitoring(std::shared_ptr<integration::monitoring_interface> monitoring);
 
    std::shared_ptr<integration::monitoring_interface> get_monitoring();
 
    integration::io_context_thread_manager& get_io_context_manager();
 
    void reset();
 
private:
    network_context();
    ~network_context() = default;
 
    // Non-copyable
    network_context(const network_context&) = delete;
    network_context& operator=(const network_context&) = delete;
 
    std::shared_ptr<integration::thread_pool_interface> thread_pool_;
    std::shared_ptr<integration::logger_interface> logger_;
    std::shared_ptr<integration::monitoring_interface> monitoring_;
    std::unique_ptr<integration::io_context_thread_manager> io_manager_;
    mutable std::shared_mutex mutex_;
};
 
class connection_pool {
public:
    explicit connection_pool(
        size_t max_connections = 10,
        std::chrono::seconds idle_timeout = std::chrono::seconds(60));
 
    ~connection_pool();
 
    // Non-copyable
    connection_pool(const connection_pool&) = delete;
    connection_pool& operator=(const connection_pool&) = delete;
 
    size_t size() const noexcept;
 
    size_t max_size() const noexcept;
 
    void clear();
 
private:
    size_t max_connections_;
    std::chrono::seconds idle_timeout_;
    mutable std::mutex mutex_;
};
 
} // namespace kcenon::network::core
 
// =============================================================================
// Base Classes for Messaging
// =============================================================================
 
export namespace kcenon::network::core {
 
enum class connection_state {
    disconnected,
    connecting,
    connected,
    disconnecting
};
 
constexpr std::string_view to_string(connection_state state) noexcept {
    switch (state) {
        case connection_state::disconnected: return "disconnected";
        case connection_state::connecting: return "connecting";
        case connection_state::connected: return "connected";
        case connection_state::disconnecting: return "disconnecting";
        default: return "unknown";
    }
}
 
using connection_callback = std::function<void()>;
using disconnection_callback = std::function<void()>;
using error_callback = std::function<void(const std::string&)>;
using data_callback = std::function<void(std::span<const uint8_t>)>;
 
} // namespace kcenon::network::core