dicom_session.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/pdu_types.h"
 
#include <chrono>
#include <condition_variable>
#include <cstdint>
#include <functional>
#include <memory>
#include <mutex>
#include <string>
#include <variant>
#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 kcenon::network types
namespace kcenon::network::session {
class messaging_session;
class secure_session;
}  // namespace kcenon::network::session
 
namespace kcenon::network::interfaces {
class i_session;
}  // namespace kcenon::network::interfaces
 
// 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::integration {
 
// =============================================================================
// 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
 
// =============================================================================
// PDU Receive Result
// =============================================================================
 
struct pdu_data {
    network::pdu_type type;        
    std::vector<uint8_t> payload;  
 
    pdu_data() : type(network::pdu_type::abort) {}
    pdu_data(network::pdu_type t, std::vector<uint8_t> p)
        : type(t), payload(std::move(p)) {}
};
 
// =============================================================================
// DICOM Session Class
// =============================================================================
 
class dicom_session : public std::enable_shared_from_this<dicom_session> {
public:
    // ─────────────────────────────────────────────────────
    // Type Aliases
    // ─────────────────────────────────────────────────────
 
    using clock = std::chrono::steady_clock;
    using duration = std::chrono::milliseconds;
    using time_point = clock::time_point;
 
    static constexpr duration default_timeout{30000};  // 30 seconds
 
    static constexpr size_t pdu_header_size = 6;
 
    static constexpr size_t max_pdu_payload_size = 64 * 1024 * 1024;  // 64MB
 
    // ─────────────────────────────────────────────────────
    // Construction / Destruction
    // ─────────────────────────────────────────────────────
 
    explicit dicom_session(
        std::shared_ptr<network_system::session::messaging_session> session);
 
    explicit dicom_session(
        std::shared_ptr<network_system::session::secure_session> session);
 
    explicit dicom_session(
        std::shared_ptr<kcenon::network::interfaces::i_session> session);
 
    ~dicom_session();
 
    // Non-copyable
    dicom_session(const dicom_session&) = delete;
    dicom_session& operator=(const dicom_session&) = delete;
 
    // Movable
    dicom_session(dicom_session&& other) noexcept;
    dicom_session& operator=(dicom_session&& other) noexcept;
 
    // ─────────────────────────────────────────────────────
    // PDU Operations
    // ─────────────────────────────────────────────────────
 
    [[nodiscard]] Result<std::monostate> send_pdu(
        network::pdu_type type,
        const std::vector<uint8_t>& payload);
 
    [[nodiscard]] Result<std::monostate> send_raw(
        const std::vector<uint8_t>& data);
 
    [[nodiscard]] Result<pdu_data> receive_pdu(
        duration timeout = default_timeout);
 
    void set_pdu_callback(std::function<void(const pdu_data&)> callback);
 
    void clear_pdu_callback();
 
    // ─────────────────────────────────────────────────────
    // External Event Injection (for i_session)
    // ─────────────────────────────────────────────────────
 
    void feed_data(const std::vector<uint8_t>& data);
 
    void feed_error(std::error_code ec);
 
    // ─────────────────────────────────────────────────────
    // Connection State
    // ─────────────────────────────────────────────────────
 
    void close();
 
    [[nodiscard]] bool is_open() const noexcept;
 
    [[nodiscard]] std::string remote_address() const;
 
    [[nodiscard]] std::string session_id() const;
 
    [[nodiscard]] bool is_secure() const noexcept;
 
    // ─────────────────────────────────────────────────────
    // Error Handling
    // ─────────────────────────────────────────────────────
 
    void set_error_callback(std::function<void(std::error_code)> callback);
 
    [[nodiscard]] std::error_code last_error() const noexcept;
 
private:
    // ─────────────────────────────────────────────────────
    // Private Types
    // ─────────────────────────────────────────────────────
 
    using session_variant = std::variant<
        std::shared_ptr<network_system::session::messaging_session>,
        std::shared_ptr<network_system::session::secure_session>,
        std::shared_ptr<kcenon::network::interfaces::i_session>>;
 
    // ─────────────────────────────────────────────────────
    // Private Methods
    // ─────────────────────────────────────────────────────
 
    void on_data_received(const std::vector<uint8_t>& data);
 
    void on_error(std::error_code ec);
 
    void process_buffer();
 
    static std::vector<uint8_t> encode_pdu_header(
        network::pdu_type type, uint32_t length);
 
    static bool parse_pdu_header(
        const std::vector<uint8_t>& buffer,
        network::pdu_type& type,
        uint32_t& length);
 
    void send_data(std::vector<uint8_t>&& data);
 
    // ─────────────────────────────────────────────────────
    // Member Variables
    // ─────────────────────────────────────────────────────
 
    session_variant session_;
 
    std::vector<uint8_t> receive_buffer_;
 
    std::vector<pdu_data> received_pdus_;
 
    std::function<void(const pdu_data&)> pdu_callback_;
 
    std::function<void(std::error_code)> error_callback_;
 
    std::error_code last_error_;
 
    bool closed_ = false;
 
    mutable std::mutex mutex_;
 
    std::condition_variable receive_cv_;
};
 
}  // namespace kcenon::pacs::integration