network_system_bridge.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2021-2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include "kcenon/network/internal/integration/bridge_interface.h"
#include "kcenon/network/internal/integration/thread_pool_bridge.h"
#include "kcenon/network/integration/thread_integration.h"
#include "kcenon/network/internal/integration/logger_integration.h"
#include "kcenon/network/internal/integration/monitoring_integration.h"
#include <kcenon/network/config/feature_flags.h>
 
#if KCENON_WITH_COMMON_SYSTEM
#include <kcenon/common/interfaces/executor_interface.h>
#include <kcenon/common/interfaces/logger_interface.h>
#include <kcenon/common/interfaces/monitoring_interface.h>
#endif
 
#include <memory>
#include <string>
#include <map>
#include <mutex>
#include <optional>
 
namespace kcenon::network::integration {
 
struct NetworkSystemBridgeConfig {
    std::string integration_name = "network_system";
 
    bool enable_thread_pool = true;
 
    bool enable_logger = false;
 
    bool enable_monitoring = false;
 
    std::map<std::string, std::string> thread_pool_properties;
 
    std::map<std::string, std::string> logger_properties;
 
    std::map<std::string, std::string> monitoring_properties;
};
 
class NetworkSystemBridge {
public:
    NetworkSystemBridge();
 
    explicit NetworkSystemBridge(std::shared_ptr<ThreadPoolBridge> thread_pool);
 
    ~NetworkSystemBridge();
 
    // Non-copyable, movable
    NetworkSystemBridge(const NetworkSystemBridge&) = delete;
    NetworkSystemBridge& operator=(const NetworkSystemBridge&) = delete;
    NetworkSystemBridge(NetworkSystemBridge&&) noexcept;
    NetworkSystemBridge& operator=(NetworkSystemBridge&&) noexcept;
 
    VoidResult initialize(const NetworkSystemBridgeConfig& config);
 
    VoidResult shutdown();
 
    bool is_initialized() const;
 
    BridgeMetrics get_metrics() const;
 
    // Bridge Component Access
 
    std::shared_ptr<ThreadPoolBridge> get_thread_pool_bridge() const;
 
    std::shared_ptr<thread_pool_interface> get_thread_pool() const;
 
    std::shared_ptr<logger_interface> get_logger() const;
 
    std::shared_ptr<monitoring_interface> get_monitoring() const;
 
    // Configuration Methods
 
    VoidResult set_thread_pool_bridge(std::shared_ptr<ThreadPoolBridge> bridge);
 
    VoidResult set_logger(std::shared_ptr<logger_interface> logger);
 
    VoidResult set_monitoring(std::shared_ptr<monitoring_interface> monitoring);
 
    // Factory Methods
 
    static std::shared_ptr<NetworkSystemBridge> create_default();
 
    static std::shared_ptr<NetworkSystemBridge> with_thread_system(
        const std::string& pool_name = "network_pool");
 
#if KCENON_WITH_COMMON_SYSTEM
    static std::shared_ptr<NetworkSystemBridge> with_common_system(
        std::shared_ptr<::kcenon::common::interfaces::IExecutor> executor,
        std::shared_ptr<::kcenon::common::interfaces::ILogger> logger = nullptr,
        std::shared_ptr<::kcenon::common::interfaces::IMonitor> monitor = nullptr);
#endif
 
    static std::shared_ptr<NetworkSystemBridge> with_custom(
        std::shared_ptr<thread_pool_interface> thread_pool = nullptr,
        std::shared_ptr<logger_interface> logger = nullptr,
        std::shared_ptr<monitoring_interface> monitoring = nullptr);
 
private:
    class Impl;
    std::unique_ptr<Impl> pimpl_;
};
 
} // namespace kcenon::network::integration
 
// Backward compatibility namespace alias
namespace network_system {
    namespace integration = kcenon::network::integration;
}