network_adapter.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/pacs/network/server_config.h"
 
#include <chrono>
#include <cstdint>
#include <filesystem>
#include <functional>
#include <memory>
#include <string>
#include <string_view>
#include <vector>
 
// KCENON_HAS_COMMON_SYSTEM is defined by CMake when common_system is available
#ifndef KCENON_HAS_COMMON_SYSTEM
#define KCENON_HAS_COMMON_SYSTEM 0
#endif
 
#if KCENON_HAS_COMMON_SYSTEM
#include <kcenon/common/patterns/result.h>
#endif
 
// Forward declarations for public network_system interfaces
namespace kcenon::network::interfaces {
class i_session;
class i_protocol_client;
}  // namespace kcenon::network::interfaces
 
// Forward declarations for legacy session types (used by wrap_session overloads)
namespace kcenon::network::session {
class messaging_session;
class secure_session;
}  // namespace kcenon::network::session
 
// Legacy namespace aliases for backward compatibility
namespace network_system::session {
using messaging_session = kcenon::network::session::messaging_session;
using secure_session = kcenon::network::session::secure_session;
}  // namespace network_system::session
 
namespace kcenon::pacs::network {
class dicom_server;
}  // namespace kcenon::pacs::network
 
namespace kcenon::pacs::integration {
 
// Forward declarations
class dicom_session;
 
// =============================================================================
// Result Type and Error Info
// =============================================================================
 
#if KCENON_HAS_COMMON_SYSTEM
template <typename T>
using Result = kcenon::common::Result<T>;
 
using error_info = kcenon::common::error_info;
#else
struct error_info {
    int code = -1;
    std::string message;
    std::string module;
 
    error_info() = default;
    error_info(const std::string& msg) : message(msg) {}
    error_info(int c, const std::string& msg, const std::string& mod = "")
        : code(c), message(msg), module(mod) {}
};
 
template <typename T>
class Result {
public:
    Result(T value) : data_(std::move(value)), has_value_(true) {}
    Result(const error_info& err) : error_(err), has_value_(false) {}
 
    [[nodiscard]] bool is_ok() const noexcept { return has_value_; }
    [[nodiscard]] bool is_err() const noexcept { return !has_value_; }
    [[nodiscard]] T& value() & { return data_; }
    [[nodiscard]] const T& value() const& { return data_; }
    [[nodiscard]] T&& value() && { return std::move(data_); }
    [[nodiscard]] const error_info& error() const { return error_; }
 
private:
    T data_{};
    error_info error_;
    bool has_value_;
};
#endif
 
// =============================================================================
// TLS Configuration
// =============================================================================
 
struct tls_config {
    bool enabled = false;
 
    std::filesystem::path cert_path;
 
    std::filesystem::path key_path;
 
    std::filesystem::path ca_path;
 
    bool verify_peer = true;
 
    enum class tls_version { v1_2, v1_3 } min_version = tls_version::v1_2;
 
    [[nodiscard]] bool is_valid() const noexcept {
        if (!enabled) return true;
        return !cert_path.empty() && !key_path.empty();
    }
};
 
// =============================================================================
// Connection Configuration
// =============================================================================
 
struct connection_config {
    std::string host;
 
    uint16_t port = 104;  // Standard DICOM port
 
    std::chrono::milliseconds timeout{30000};
 
    tls_config tls;
 
    connection_config() = default;
    connection_config(std::string h, uint16_t p)
        : host(std::move(h)), port(p) {}
};
 
// =============================================================================
// Network Adapter Class
// =============================================================================
 
class network_adapter {
public:
    // ─────────────────────────────────────────────────────
    // Type Aliases
    // ─────────────────────────────────────────────────────
 
    using session_ptr = std::shared_ptr<dicom_session>;
 
    using connection_callback = std::function<void(session_ptr)>;
 
    using disconnection_callback = std::function<void(const std::string&)>;
 
    using error_callback = std::function<void(session_ptr, std::error_code)>;
 
    // ─────────────────────────────────────────────────────
    // Server Creation
    // ─────────────────────────────────────────────────────
 
    [[nodiscard]] static std::unique_ptr<network::dicom_server>
        create_server(const network::server_config& config,
                      const tls_config& tls_cfg = {});
 
    // ─────────────────────────────────────────────────────
    // Client Connection
    // ─────────────────────────────────────────────────────
 
    [[nodiscard]] static Result<session_ptr> connect(
        const connection_config& config);
 
    [[nodiscard]] static Result<session_ptr> connect(
        const std::string& host,
        uint16_t port,
        std::chrono::milliseconds timeout = std::chrono::seconds{30});
 
    // ─────────────────────────────────────────────────────
    // TLS Configuration
    // ─────────────────────────────────────────────────────
 
    [[nodiscard]] static Result<std::monostate> configure_tls(
        const tls_config& config);
 
    // ─────────────────────────────────────────────────────
    // Session Wrapping
    // ─────────────────────────────────────────────────────
 
    [[nodiscard]] static session_ptr wrap_session(
        std::shared_ptr<network_system::session::messaging_session> session);
 
    [[nodiscard]] static session_ptr wrap_session(
        std::shared_ptr<network_system::session::secure_session> session);
 
    [[nodiscard]] static session_ptr wrap_session(
        std::shared_ptr<kcenon::network::interfaces::i_session> session);
 
private:
    // Prevent instantiation
    network_adapter() = delete;
    ~network_adapter() = delete;
    network_adapter(const network_adapter&) = delete;
    network_adapter& operator=(const network_adapter&) = delete;
};
 
}  // namespace kcenon::pacs::integration