DICOM session wrapper for network_system sessions. More...

#include <dicom_session.h>

Inheritance diagram for kcenon::pacs::integration::dicom_session:

Collaboration diagram for kcenon::pacs::integration::dicom_session:

Public Types
using	clock = std::chrono::steady_clock

using	duration = std::chrono::milliseconds

using	time_point = clock::time_point

Public Member Functions
	dicom_session (std::shared_ptr< network_system::session::messaging_session > session)
	Construct a DICOM session wrapping a messaging_session.

	dicom_session (std::shared_ptr< network_system::session::secure_session > session)
	Construct a DICOM session wrapping a secure_session.

	dicom_session (std::shared_ptr< kcenon::network::interfaces::i_session > session)
	Construct a DICOM session wrapping an i_session interface.

	~dicom_session ()
	Destructor (closes session if open)

	dicom_session (const dicom_session &)=delete

dicom_session &	operator= (const dicom_session &)=delete

	dicom_session (dicom_session &&other) noexcept

dicom_session &	operator= (dicom_session &&other) noexcept

Result< std::monostate >	send_pdu (network::pdu_type type, const std::vector< uint8_t > &payload)
	Send a complete DICOM PDU.

Result< std::monostate >	send_raw (const std::vector< uint8_t > &data)
	Send raw PDU data (with header already included)

Result< pdu_data >	receive_pdu (duration timeout=default_timeout)
	Receive a complete DICOM PDU.

void	set_pdu_callback (std::function< void(const pdu_data &)> callback)
	Set callback for asynchronous PDU reception.

void	clear_pdu_callback ()
	Clear the PDU callback.

void	feed_data (const std::vector< uint8_t > &data)
	Feed received data from external source.

void	feed_error (std::error_code ec)
	Feed an error from external source.

void	close ()
	Close the session.

bool	is_open () const noexcept
	Check if the session is open.

std::string	remote_address () const
	Get the remote peer address.

std::string	session_id () const
	Get session identifier.

bool	is_secure () const noexcept
	Check if this is a secure (TLS) session.

void	set_error_callback (std::function< void(std::error_code)> callback)
	Set callback for error events.

std::error_code	last_error () const noexcept
	Get the last error code.

Static Public Attributes
static constexpr duration	default_timeout {30000}
	Default receive timeout.

static constexpr size_t	pdu_header_size = 6
	PDU header size per DICOM PS3.8.

static constexpr size_t	max_pdu_payload_size = 64 * 1024 * 1024
	Maximum PDU payload size (sanity check)

Private Types
using	session_variant
	Variant for holding session types (legacy + public interface)

Private Member Functions
void	on_data_received (const std::vector< uint8_t > &data)
	Handle incoming data from network.

void	on_error (std::error_code ec)
	Handle connection errors.

void	process_buffer ()
	Process buffered data for complete PDUs.

void	send_data (std::vector< uint8_t > &&data)
	Send data through the underlying session.

Static Private Member Functions
static std::vector< uint8_t >	encode_pdu_header (network::pdu_type type, uint32_t length)
	Encode PDU header.

static bool	parse_pdu_header (const std::vector< uint8_t > &buffer, network::pdu_type &type, uint32_t &length)
	Parse PDU header from buffer.

Private Attributes
session_variant	session_
	Underlying network session.

std::vector< uint8_t >	receive_buffer_
	Receive buffer for PDU framing.

std::vector< pdu_data >	received_pdus_
	Queue of received complete PDUs.

std::function< void(const pdu_data &)>	pdu_callback_
	PDU callback for async reception.

std::function< void(std::error_code)>	error_callback_
	Error callback.

std::error_code	last_error_
	Last error code.

bool	closed_ = false
	Session closed flag.

std::mutex	mutex_
	Mutex for thread safety.

std::condition_variable	receive_cv_
	Condition variable for synchronous receive.

Detailed Description

DICOM session wrapper for network_system sessions.

This class wraps a network_system messaging_session (or secure_session) to provide DICOM PDU-level communication. Key features include:

PDU Framing: Handles DICOM PDU header parsing (6-byte header)
PDU Send/Receive: Send and receive complete PDUs
Timeout Support: Configurable timeouts for receive operations
Connection Management: Track connection state and remote address

PDU Header Format

The DICOM PDU header is 6 bytes:

Byte 0: PDU Type (1 byte)
Byte 1: Reserved (0x00)
Bytes 2-5: PDU Length (Big Endian, 4 bytes)

Thread Safety: All public methods are thread-safe. The underlying network operations are serialized through network_system's I/O context.

Definition at line 172 of file dicom_session.h.

Member Typedef Documentation

◆ clock

using kcenon::pacs::integration::dicom_session::clock = std::chrono::steady_clock

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/dicom_session.h.

Definition at line 178 of file dicom_session.h.

◆ duration

using kcenon::pacs::integration::dicom_session::duration = std::chrono::milliseconds

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/dicom_session.h.

Definition at line 179 of file dicom_session.h.

◆ session_variant

using kcenon::pacs::integration::dicom_session::session_variant

private

Initial value:

 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>>

Variant for holding session types (legacy + public interface)

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/dicom_session.h.

Definition at line 376 of file dicom_session.h.

◆ time_point

using kcenon::pacs::integration::dicom_session::time_point = clock::time_point

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/dicom_session.h.

Definition at line 180 of file dicom_session.h.

Constructor & Destructor Documentation

◆ dicom_session() [1/5]

kcenon::pacs::integration::dicom_session::dicom_session ( std::shared_ptr< network_system::session::messaging_session > session )

explicit

Construct a DICOM session wrapping a messaging_session.

Parameters

session The network_system session to wrap

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/dicom_session.h.

Definition at line 26 of file dicom_session.cpp.

    : session_(std::move(session)) {
    if (auto* s = std::get_if<
            std::shared_ptr<network_system::session::messaging_session>>(&session_)) {
        // Set up callbacks for the underlying session
        (*s)->set_receive_callback(
            [this](const std::vector<uint8_t>& data) {
                on_data_received(data);
            });
 
        (*s)->set_error_callback(
            [this](std::error_code ec) {
                on_error(ec);
            });
    }
}

References on_data_received(), on_error(), and session_.

Here is the call graph for this function:

◆ dicom_session() [2/5]

kcenon::pacs::integration::dicom_session::dicom_session ( std::shared_ptr< network_system::session::secure_session > session )

explicit

Construct a DICOM session wrapping a secure_session.

Parameters

session The secure network_system session to wrap

Definition at line 44 of file dicom_session.cpp.

    : session_(std::move(session)) {
    if (auto* s = std::get_if<
            std::shared_ptr<network_system::session::secure_session>>(&session_)) {
        // Set up callbacks for the underlying secure session
        (*s)->set_receive_callback(
            [this](const std::vector<uint8_t>& data) {
                on_data_received(data);
            });
 
        (*s)->set_error_callback(
            [this](std::error_code ec) {
                on_error(ec);
            });
    }
}

References on_data_received(), on_error(), and session_.

Here is the call graph for this function:

◆ dicom_session() [3/5]

kcenon::pacs::integration::dicom_session::dicom_session ( std::shared_ptr< kcenon::network::interfaces::i_session > session )

explicit

Construct a DICOM session wrapping an i_session interface.

When using i_session, data must be fed externally via feed_data() since i_session does not support session-level callbacks.

Parameters

session The i_session interface to wrap

Definition at line 62 of file dicom_session.cpp.

    : session_(std::move(session)) {
    // i_session does not support session-level callbacks.
    // Data must be fed externally via feed_data() / feed_error().
}

◆ ~dicom_session()

kcenon::pacs::integration::dicom_session::~dicom_session ( )

Destructor (closes session if open)

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/dicom_session.h.

Definition at line 69 of file dicom_session.cpp.

                              {
    close();
}

References close().

Here is the call graph for this function:

◆ dicom_session() [4/5]

kcenon::pacs::integration::dicom_session::dicom_session ( const dicom_session & )

delete

◆ dicom_session() [5/5]

kcenon::pacs::integration::dicom_session::dicom_session ( dicom_session && other )

noexcept

Definition at line 73 of file dicom_session.cpp.

    : session_(std::move(other.session_))
    , receive_buffer_(std::move(other.receive_buffer_))
    , received_pdus_(std::move(other.received_pdus_))
    , pdu_callback_(std::move(other.pdu_callback_))
    , error_callback_(std::move(other.error_callback_))
    , last_error_(other.last_error_)
    , closed_(other.closed_) {
    other.closed_ = true;
}

Member Function Documentation

◆ clear_pdu_callback()

void kcenon::pacs::integration::dicom_session::clear_pdu_callback ( )

Clear the PDU callback.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/dicom_session.h.

Definition at line 192 of file dicom_session.cpp.

                                       {
    std::lock_guard<std::mutex> lock(mutex_);
    pdu_callback_ = nullptr;
}

References mutex_, and pdu_callback_.

◆ close()

void kcenon::pacs::integration::dicom_session::close ( )

Close the session.

Closes the underlying network connection. Any pending send or receive operations will be cancelled.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/dicom_session.h.

Definition at line 201 of file dicom_session.cpp.

                          {
    std::lock_guard<std::mutex> lock(mutex_);
 
    if (closed_) {
        return;
    }
 
    closed_ = true;
 
    // Stop the underlying session
    std::visit([](auto&& session) {
        if (session) {
            if constexpr (std::is_same_v<std::decay_t<decltype(session)>,
                          std::shared_ptr<kcenon::network::interfaces::i_session>>) {
                session->close();
            } else {
                session->stop_session();
            }
        }
    }, session_);
 
    // Notify waiting receivers
    receive_cv_.notify_all();
}

References closed_, mutex_, receive_cv_, and session_.

Referenced by ~dicom_session().

Here is the caller graph for this function:

◆ encode_pdu_header()

std::vector< uint8_t > kcenon::pacs::integration::dicom_session::encode_pdu_header	(	network::pdu_type	type,
		uint32_t	length )

staticprivate

Encode PDU header.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/dicom_session.h.

Definition at line 389 of file dicom_session.cpp.

                                                                      {
    std::vector<uint8_t> header(pdu_header_size);
 
    // Byte 0: PDU Type
    header[0] = static_cast<uint8_t>(type);
 
    // Byte 1: Reserved
    header[1] = 0x00;
 
    // Bytes 2-5: Length (Big Endian)
    header[2] = static_cast<uint8_t>((length >> 24) & 0xFF);
    header[3] = static_cast<uint8_t>((length >> 16) & 0xFF);
    header[4] = static_cast<uint8_t>((length >> 8) & 0xFF);
    header[5] = static_cast<uint8_t>(length & 0xFF);
 
    return header;
}

References pdu_header_size.

Referenced by send_pdu().

Here is the caller graph for this function:

◆ feed_data()

void kcenon::pacs::integration::dicom_session::feed_data ( const std::vector< uint8_t > & data )

Feed received data from external source.

Used when the session is backed by i_session, which does not support session-level callbacks. The server forwards data here.

Parameters

data	The received data bytes

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/dicom_session.h.

Definition at line 279 of file dicom_session.cpp.

                                                            {
    on_data_received(data);
}

References on_data_received().

Here is the call graph for this function:

◆ feed_error()

void kcenon::pacs::integration::dicom_session::feed_error ( std::error_code ec )

Feed an error from external source.

Used when the session is backed by i_session.

Parameters

ec	The error code

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/dicom_session.h.

Definition at line 283 of file dicom_session.cpp.

                                               {
    on_error(ec);
}

References on_error().

Here is the call graph for this function:

◆ is_open()

bool kcenon::pacs::integration::dicom_session::is_open ( ) const

nodiscardnoexcept

Check if the session is open.

Returns: true if the connection is active

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/dicom_session.h.

Definition at line 226 of file dicom_session.cpp.

                                           {
    std::lock_guard<std::mutex> lock(mutex_);
 
    if (closed_) {
        return false;
    }
 
    return std::visit([](auto&& session) -> bool {
        if (session) {
            if constexpr (std::is_same_v<std::decay_t<decltype(session)>,
                          std::shared_ptr<kcenon::network::interfaces::i_session>>) {
                return session->is_connected();
            } else {
                return !session->is_stopped();
            }
        }
        return false;
    }, session_);
}

References closed_, mutex_, and session_.

◆ is_secure()

bool kcenon::pacs::integration::dicom_session::is_secure ( ) const

nodiscardnoexcept

Check if this is a secure (TLS) session.

Returns: true if using TLS

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/dicom_session.h.

Definition at line 270 of file dicom_session.cpp.

                                             {
    return std::holds_alternative<
        std::shared_ptr<network_system::session::secure_session>>(session_);
}

References session_.

◆ last_error()

std::error_code kcenon::pacs::integration::dicom_session::last_error ( ) const

nodiscardnoexcept

Get the last error code.

Returns: Last error or success code

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/dicom_session.h.

Definition at line 297 of file dicom_session.cpp.

                                                       {
    std::lock_guard<std::mutex> lock(mutex_);
    return last_error_;
}

References last_error_, and mutex_.

◆ on_data_received()

void kcenon::pacs::integration::dicom_session::on_data_received ( const std::vector< uint8_t > & data )

private

Handle incoming data from network.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/dicom_session.h.

Definition at line 306 of file dicom_session.cpp.

                                                                   {
    std::lock_guard<std::mutex> lock(mutex_);
 
    if (closed_) {
        return;
    }
 
    // Append to receive buffer
    receive_buffer_.insert(receive_buffer_.end(), data.begin(), data.end());
 
    // Process complete PDUs
    process_buffer();
}

References closed_, mutex_, process_buffer(), and receive_buffer_.

Referenced by dicom_session(), dicom_session(), and feed_data().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_error()

void kcenon::pacs::integration::dicom_session::on_error ( std::error_code ec )

private

Handle connection errors.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/dicom_session.h.

Definition at line 320 of file dicom_session.cpp.

                                             {
    std::function<void(std::error_code)> callback;
 
    {
        std::lock_guard<std::mutex> lock(mutex_);
        last_error_ = ec;
        callback = error_callback_;
    }
 
    if (callback) {
        callback(ec);
    }
 
    // Notify waiting receivers
    receive_cv_.notify_all();
}

References error_callback_, last_error_, mutex_, and receive_cv_.

Referenced by dicom_session(), dicom_session(), and feed_error().

Here is the caller graph for this function:

◆ operator=() [1/2]

dicom_session & kcenon::pacs::integration::dicom_session::operator= ( const dicom_session & )

delete

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/dicom_session.h.

◆ operator=() [2/2]

dicom_session & kcenon::pacs::integration::dicom_session::operator= ( dicom_session && other )

noexcept

Definition at line 84 of file dicom_session.cpp.

                                                                      {
    if (this != &other) {
        close();
 
        std::lock_guard<std::mutex> lock(mutex_);
        session_ = std::move(other.session_);
        receive_buffer_ = std::move(other.receive_buffer_);
        received_pdus_ = std::move(other.received_pdus_);
        pdu_callback_ = std::move(other.pdu_callback_);
        error_callback_ = std::move(other.error_callback_);
        last_error_ = other.last_error_;
        closed_ = other.closed_;
 
        other.closed_ = true;
    }
    return *this;
}

◆ parse_pdu_header()

bool kcenon::pacs::integration::dicom_session::parse_pdu_header	(	const std::vector< uint8_t > &	buffer,
		network::pdu_type &	type,
		uint32_t &	length )

staticprivate

Parse PDU header from buffer.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/dicom_session.h.

Definition at line 407 of file dicom_session.cpp.

                                                       {
    if (buffer.size() < pdu_header_size) {
        return false;
    }
 
    // Byte 0: PDU Type
    uint8_t type_byte = buffer[0];
 
    // Validate PDU type
    if (type_byte < 0x01 || type_byte > 0x07) {
        return false;
    }
 
    type = static_cast<network::pdu_type>(type_byte);
 
    // Byte 1: Reserved (should be 0, but we don't validate)
 
    // Bytes 2-5: Length (Big Endian)
    length = (static_cast<uint32_t>(buffer[2]) << 24) |
             (static_cast<uint32_t>(buffer[3]) << 16) |
             (static_cast<uint32_t>(buffer[4]) << 8) |
             static_cast<uint32_t>(buffer[5]);
 
    return true;
}

References pdu_header_size.

Referenced by process_buffer().

Here is the caller graph for this function:

◆ process_buffer()

void kcenon::pacs::integration::dicom_session::process_buffer ( )

private

Process buffered data for complete PDUs.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/dicom_session.h.

Definition at line 337 of file dicom_session.cpp.

                                   {
    // Process all complete PDUs in the buffer
    while (receive_buffer_.size() >= pdu_header_size) {
        // Parse header
        network::pdu_type type;
        uint32_t length;
 
        if (!parse_pdu_header(receive_buffer_, type, length)) {
            // Invalid header - this is a protocol error
            last_error_ = std::make_error_code(std::errc::protocol_error);
            receive_cv_.notify_all();
            return;
        }
 
        // Sanity check on length
        if (length > max_pdu_payload_size) {
            last_error_ = std::make_error_code(std::errc::message_size);
            receive_cv_.notify_all();
            return;
        }
 
        // Check if we have the complete PDU
        size_t total_size = pdu_header_size + length;
        if (receive_buffer_.size() < total_size) {
            // Need more data
            return;
        }
 
        // Extract payload (skip 6-byte header)
        std::vector<uint8_t> payload(
            receive_buffer_.begin() + pdu_header_size,
            receive_buffer_.begin() + total_size);
 
        // Remove processed data from buffer
        receive_buffer_.erase(
            receive_buffer_.begin(),
            receive_buffer_.begin() + total_size);
 
        // Create PDU data
        pdu_data pdu(type, std::move(payload));
 
        // Deliver through callback or queue
        if (pdu_callback_) {
            pdu_callback_(pdu);
        } else {
            received_pdus_.push_back(std::move(pdu));
            receive_cv_.notify_one();
        }
    }
}

References last_error_, max_pdu_payload_size, parse_pdu_header(), pdu_callback_, pdu_header_size, receive_buffer_, receive_cv_, and received_pdus_.

Referenced by on_data_received().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ receive_pdu()

Result< pdu_data > kcenon::pacs::integration::dicom_session::receive_pdu ( duration timeout = default_timeout )

nodiscard

Receive a complete DICOM PDU.

Waits for and receives a complete PDU, handling the PDU framing protocol (reading header, then payload based on length).

Parameters

timeout Maximum time to wait for PDU

Returns: Result containing received PDU data or error

Note: This method blocks until a complete PDU is received or timeout

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/dicom_session.h.

Definition at line 154 of file dicom_session.cpp.

                                           {
    std::unique_lock<std::mutex> lock(mutex_);
 
    if (closed_) {
        return Result<pdu_data>(error_info("Session is closed"));
    }
 
    // Wait for a complete PDU with timeout
    auto deadline = clock::now() + timeout;
 
    while (received_pdus_.empty()) {
        if (closed_) {
            return Result<pdu_data>(error_info("Session closed while waiting"));
        }
 
        auto status = receive_cv_.wait_until(lock, deadline);
        if (status == std::cv_status::timeout) {
            return Result<pdu_data>(error_info("Receive timeout"));
        }
 
        if (last_error_) {
            return Result<pdu_data>(error_info("Receive error: " + last_error_.message()));
        }
    }
 
    // Get the first PDU from the queue
    pdu_data pdu = std::move(received_pdus_.front());
    received_pdus_.erase(received_pdus_.begin());
 
    return Result<pdu_data>(std::move(pdu));
}

References closed_, last_error_, mutex_, receive_cv_, and received_pdus_.

◆ remote_address()

std::string kcenon::pacs::integration::dicom_session::remote_address ( ) const

nodiscard

Get the remote peer address.

Returns: Remote address as "host:port" string

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/dicom_session.h.

Definition at line 246 of file dicom_session.cpp.

                                              {
    std::lock_guard<std::mutex> lock(mutex_);
 
    // For now, return a placeholder
    // Real implementation would query the underlying socket
    return "unknown";
}

References mutex_.

◆ send_data()

void kcenon::pacs::integration::dicom_session::send_data ( std::vector< uint8_t > && data )

private

Send data through the underlying session.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/dicom_session.h.

Definition at line 435 of file dicom_session.cpp.

                                                       {
    std::visit([&data](auto&& session) {
        if (session) {
            if constexpr (std::is_same_v<std::decay_t<decltype(session)>,
                          std::shared_ptr<kcenon::network::interfaces::i_session>>) {
                (void)session->send(std::move(data));
            } else {
                session->send_packet(std::move(data));
            }
        }
    }, session_);
}

References session_.

Referenced by send_pdu(), and send_raw().

Here is the caller graph for this function:

◆ send_pdu()

Result< std::monostate > kcenon::pacs::integration::dicom_session::send_pdu	(	network::pdu_type	type,
		const std::vector< uint8_t > &	payload )

nodiscard

Send a complete DICOM PDU.

Constructs a properly framed PDU with header and sends it over the network connection.

Parameters

type	The PDU type
payload	The PDU payload (without header)

Returns: Result indicating success or error

Note: The payload should not include the 6-byte PDU header; the header is constructed automatically.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/dicom_session.h.

Definition at line 107 of file dicom_session.cpp.

                                                           {
    std::lock_guard<std::mutex> lock(mutex_);
 
    if (closed_) {
        return Result<std::monostate>(error_info("Session is closed"));
    }
 
    if (payload.size() > max_pdu_payload_size) {
        return Result<std::monostate>(error_info("PDU payload exceeds maximum size"));
    }
 
    // Encode PDU header
    auto header = encode_pdu_header(type, static_cast<uint32_t>(payload.size()));
 
    // Combine header and payload
    std::vector<uint8_t> pdu_data;
    pdu_data.reserve(header.size() + payload.size());
    pdu_data.insert(pdu_data.end(), header.begin(), header.end());
    pdu_data.insert(pdu_data.end(), payload.begin(), payload.end());
 
    // Send data
    send_data(std::move(pdu_data));
 
    return Result<std::monostate>(std::monostate{});
}

References closed_, encode_pdu_header(), max_pdu_payload_size, mutex_, and send_data().

Here is the call graph for this function:

◆ send_raw()

Result< std::monostate > kcenon::pacs::integration::dicom_session::send_raw ( const std::vector< uint8_t > & data )

nodiscard

Send raw PDU data (with header already included)

Sends pre-encoded PDU data directly without modification. Use this when the PDU has already been fully encoded.

Parameters

data	Complete PDU data including header

Returns: Result indicating success or error

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/dicom_session.h.

Definition at line 135 of file dicom_session.cpp.

                                                      {
    std::lock_guard<std::mutex> lock(mutex_);
 
    if (closed_) {
        return Result<std::monostate>(error_info("Session is closed"));
    }
 
    if (data.size() < pdu_header_size) {
        return Result<std::monostate>(error_info("Raw PDU data too small"));
    }
 
    // Send data as-is
    std::vector<uint8_t> copy = data;
    send_data(std::move(copy));
 
    return Result<std::monostate>(std::monostate{});
}

References closed_, mutex_, pdu_header_size, and send_data().

Here is the call graph for this function:

◆ session_id()

std::string kcenon::pacs::integration::dicom_session::session_id ( ) const

nodiscard

Get session identifier.

Returns: Unique session identifier string

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/dicom_session.h.

Definition at line 254 of file dicom_session.cpp.

                                          {
    std::lock_guard<std::mutex> lock(mutex_);
 
    return std::visit([](auto&& session) -> std::string {
        if (session) {
            if constexpr (std::is_same_v<std::decay_t<decltype(session)>,
                          std::shared_ptr<kcenon::network::interfaces::i_session>>) {
                return std::string(session->id());
            } else {
                return session->server_id();
            }
        }
        return "invalid";
    }, session_);
}

References mutex_, and session_.

◆ set_error_callback()

void kcenon::pacs::integration::dicom_session::set_error_callback ( std::function< void(std::error_code)> callback )

Set callback for error events.

Parameters

callback Function called on errors

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/dicom_session.h.

Definition at line 291 of file dicom_session.cpp.

                                               {
    std::lock_guard<std::mutex> lock(mutex_);
    error_callback_ = std::move(callback);
}

References error_callback_, and mutex_.

◆ set_pdu_callback()

void kcenon::pacs::integration::dicom_session::set_pdu_callback ( std::function< void(const pdu_data &)> callback )

Set callback for asynchronous PDU reception.

When set, incoming PDUs are delivered through this callback instead of requiring explicit receive_pdu() calls.

Parameters

callback Function called when PDU is received

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/dicom_session.h.

Definition at line 186 of file dicom_session.cpp.

                                                 {
    std::lock_guard<std::mutex> lock(mutex_);
    pdu_callback_ = std::move(callback);
}

References mutex_, and pdu_callback_.

Member Data Documentation

◆ closed_

bool kcenon::pacs::integration::dicom_session::closed_ = false

private

Session closed flag.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/dicom_session.h.

Definition at line 430 of file dicom_session.h.

Referenced by close(), is_open(), on_data_received(), receive_pdu(), send_pdu(), and send_raw().

◆ default_timeout

duration kcenon::pacs::integration::dicom_session::default_timeout {30000}

staticconstexpr

Default receive timeout.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/dicom_session.h.

Definition at line 183 of file dicom_session.h.

183{30000}; // 30 seconds

◆ error_callback_

std::function<void(std::error_code)> kcenon::pacs::integration::dicom_session::error_callback_

private

Error callback.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/dicom_session.h.

Definition at line 424 of file dicom_session.h.

Referenced by on_error(), and set_error_callback().

◆ last_error_

std::error_code kcenon::pacs::integration::dicom_session::last_error_

private

Last error code.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/dicom_session.h.

Definition at line 427 of file dicom_session.h.

Referenced by last_error(), on_error(), process_buffer(), and receive_pdu().

◆ max_pdu_payload_size

size_t kcenon::pacs::integration::dicom_session::max_pdu_payload_size = 64 * 1024 * 1024

staticconstexpr

Maximum PDU payload size (sanity check)

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/dicom_session.h.

Definition at line 189 of file dicom_session.h.

Referenced by process_buffer(), and send_pdu().

◆ mutex_

std::mutex kcenon::pacs::integration::dicom_session::mutex_

mutableprivate

Mutex for thread safety.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/dicom_session.h.

Definition at line 433 of file dicom_session.h.

Referenced by clear_pdu_callback(), close(), is_open(), last_error(), on_data_received(), on_error(), receive_pdu(), remote_address(), send_pdu(), send_raw(), session_id(), set_error_callback(), and set_pdu_callback().

◆ pdu_callback_

std::function<void(const pdu_data&)> kcenon::pacs::integration::dicom_session::pdu_callback_

private

PDU callback for async reception.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/dicom_session.h.

Definition at line 421 of file dicom_session.h.

Referenced by clear_pdu_callback(), process_buffer(), and set_pdu_callback().

◆ pdu_header_size

size_t kcenon::pacs::integration::dicom_session::pdu_header_size = 6

staticconstexpr

PDU header size per DICOM PS3.8.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/dicom_session.h.

Definition at line 186 of file dicom_session.h.

Referenced by encode_pdu_header(), parse_pdu_header(), process_buffer(), and send_raw().

◆ receive_buffer_

std::vector<uint8_t> kcenon::pacs::integration::dicom_session::receive_buffer_

private

Receive buffer for PDU framing.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/dicom_session.h.

Definition at line 415 of file dicom_session.h.

Referenced by on_data_received(), and process_buffer().

◆ receive_cv_

std::condition_variable kcenon::pacs::integration::dicom_session::receive_cv_

private

Condition variable for synchronous receive.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/dicom_session.h.

Definition at line 436 of file dicom_session.h.

Referenced by close(), on_error(), process_buffer(), and receive_pdu().

◆ received_pdus_

std::vector<pdu_data> kcenon::pacs::integration::dicom_session::received_pdus_

private

Queue of received complete PDUs.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/dicom_session.h.

Definition at line 418 of file dicom_session.h.

Referenced by process_buffer(), and receive_pdu().

◆ session_

session_variant kcenon::pacs::integration::dicom_session::session_

private

Underlying network session.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/dicom_session.h.

Definition at line 412 of file dicom_session.h.

Referenced by close(), dicom_session(), dicom_session(), is_open(), is_secure(), send_data(), and session_id().

The documentation for this class was generated from the following files:

include/kcenon/pacs/integration/dicom_session.h
src/integration/dicom_session.cpp

Public Types

Public Member Functions

Static Public Attributes

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

PDU Header Format

Member Typedef Documentation

◆ clock

◆ duration

◆ session_variant

◆ time_point

Constructor & Destructor Documentation

◆ dicom_session() [1/5]

◆ dicom_session() [2/5]

◆ dicom_session() [3/5]

◆ ~dicom_session()

◆ dicom_session() [4/5]

◆ dicom_session() [5/5]

Member Function Documentation

◆ clear_pdu_callback()

◆ close()

◆ encode_pdu_header()

◆ feed_data()

◆ feed_error()

◆ is_open()

◆ is_secure()

◆ last_error()

◆ on_data_received()

◆ on_error()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ parse_pdu_header()

◆ process_buffer()

◆ receive_pdu()

◆ remote_address()

◆ send_data()

◆ send_pdu()

◆ send_raw()

◆ session_id()

◆ set_error_callback()

◆ set_pdu_callback()

Member Data Documentation

◆ closed_

◆ default_timeout

◆ error_callback_

◆ last_error_

◆ max_pdu_payload_size

◆ mutex_

◆ pdu_callback_

◆ pdu_header_size

◆ receive_buffer_

◆ receive_cv_

◆ received_pdus_

◆ session_