#include <retrieve_scp.h>

Inheritance diagram for kcenon::pacs::services::retrieve_scp:

Collaboration diagram for kcenon::pacs::services::retrieve_scp:

Public Member Functions
	retrieve_scp (std::shared_ptr< di::ILogger > logger=nullptr)
	Construct a Retrieve SCP with optional logger.

	~retrieve_scp () override=default

void	set_retrieve_handler (retrieve_handler handler)
	Set the retrieve handler function.

void	set_destination_resolver (destination_resolver resolver)
	Set the destination resolver function.

void	set_store_sub_operation (store_sub_operation handler)
	Set the store sub-operation handler.

void	set_cancel_check (retrieve_cancel_check check)
	Set the cancel check function.

std::vector< std::string >	supported_sop_classes () const override
	Get supported SOP Class UIDs.

network::Result< std::monostate >	handle_message (network::association &assoc, uint8_t context_id, const network::dimse::dimse_message &request) override
	Handle an incoming DIMSE message (C-MOVE-RQ or C-GET-RQ)

std::string_view	service_name () const noexcept override
	Get the service name.

size_t	move_operations () const noexcept
	Get total number of C-MOVE operations processed.

size_t	get_operations () const noexcept
	Get total number of C-GET operations processed.

size_t	images_transferred () const noexcept
	Get total number of images transferred.

void	reset_statistics () noexcept
	Reset statistics counters.

Public Member Functions inherited from kcenon::pacs::services::scp_service
	scp_service (std::shared_ptr< di::ILogger > logger=nullptr)
	Construct SCP service with optional logger.

virtual	~scp_service ()=default

	scp_service (const scp_service &)=delete

scp_service &	operator= (const scp_service &)=delete

	scp_service (scp_service &&)=default

scp_service &	operator= (scp_service &&)=default

void	set_logger (std::shared_ptr< di::ILogger > logger)
	Set the logger instance.

const std::shared_ptr< di::ILogger > &	logger () const noexcept
	Get the current logger instance.

bool	supports_sop_class (std::string_view sop_class_uid) const
	Check if this service supports a specific SOP Class.

Private Member Functions
network::Result< std::monostate >	handle_c_move (network::association &assoc, uint8_t context_id, const network::dimse::dimse_message &request)
	Handle a C-MOVE request.

network::Result< std::monostate >	handle_c_get (network::association &assoc, uint8_t context_id, const network::dimse::dimse_message &request)
	Handle a C-GET request.

network::Result< std::monostate >	send_pending_response (network::association &assoc, uint8_t context_id, uint16_t message_id, std::string_view sop_class_uid, bool is_move, const sub_operation_stats &stats)
	Send a pending response with progress information.

network::Result< std::monostate >	send_final_response (network::association &assoc, uint8_t context_id, uint16_t message_id, std::string_view sop_class_uid, bool is_move, const sub_operation_stats &stats, bool was_cancelled)
	Send a final response with completion status.

std::string	get_move_destination (const network::dimse::dimse_message &request) const
	Get the Move Destination AE title from the request.

Private Attributes
retrieve_handler	retrieve_handler_

destination_resolver	destination_resolver_

store_sub_operation	store_handler_

retrieve_cancel_check	cancel_check_

std::atomic< size_t >	move_operations_ {0}

std::atomic< size_t >	get_operations_ {0}

std::atomic< size_t >	images_transferred_ {0}

Additional Inherited Members
Protected Attributes inherited from kcenon::pacs::services::scp_service
std::shared_ptr< di::ILogger >	logger_
	Logger instance for service logging.

Detailed Description

Definition at line 230 of file retrieve_scp.h.

Constructor & Destructor Documentation

◆ retrieve_scp()

kcenon::pacs::services::retrieve_scp::retrieve_scp ( std::shared_ptr< di::ILogger > logger = nullptr )

explicit

Construct a Retrieve SCP with optional logger.

Parameters

logger Logger instance for service logging (nullptr uses null_logger)

Definition at line 26 of file retrieve_scp.cpp.

27 : scp_service(std::move(logger)) {}

kcenon::pacs::services::scp_service::logger

const std::shared_ptr< di::ILogger > & logger() const noexcept

Get the current logger instance.

Definition scp_service.h:93

kcenon::pacs::services::scp_service::scp_service

scp_service(std::shared_ptr< di::ILogger > logger=nullptr)

Construct SCP service with optional logger.

Definition scp_service.h:64

◆ ~retrieve_scp()

kcenon::pacs::services::retrieve_scp::~retrieve_scp ( )

overridedefault

Member Function Documentation

◆ get_move_destination()

std::string kcenon::pacs::services::retrieve_scp::get_move_destination ( const network::dimse::dimse_message & request ) const

nodiscardprivate

Get the Move Destination AE title from the request.

Parameters

request The C-MOVE-RQ message

Returns: Move Destination AE title, or empty string if not present

Definition at line 528 of file retrieve_scp.cpp.

                                                    {
 
    // Move Destination is in the command set at tag (0000,0600)
    return request.command_set().get_string(network::dimse::tag_move_destination);
}

References kcenon::pacs::network::dimse::dimse_message::command_set(), and kcenon::pacs::network::dimse::tag_move_destination.

Referenced by handle_c_move().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_operations()

size_t kcenon::pacs::services::retrieve_scp::get_operations ( ) const

nodiscardnoexcept

Get total number of C-GET operations processed.

Returns: Number of C-GET requests handled

Definition at line 97 of file retrieve_scp.cpp.

                                                   {
    return get_operations_.load();
}

References get_operations_.

◆ handle_c_get()

network::Result< std::monostate > kcenon::pacs::services::retrieve_scp::handle_c_get	(	network::association &	assoc,
		uint8_t	context_id,
		const network::dimse::dimse_message &	request )

nodiscardprivate

Handle a C-GET request.

Parameters

assoc	The association
context_id	The presentation context ID
request	The C-GET-RQ message

Returns: Success or error

Definition at line 278 of file retrieve_scp.cpp.

                                              {
 
    using namespace network::dimse;
 
    // Verify we have a retrieve handler
    if (!retrieve_handler_) {
        return kcenon::pacs::pacs_void_error(
            kcenon::pacs::error_codes::retrieve_handler_not_set,
            "No retrieve handler configured");
    }
 
    auto sop_class_uid = request.affected_sop_class_uid();
    auto message_id = request.message_id();
 
    // Verify we have a dataset (query keys)
    if (!request.has_dataset()) {
        sub_operation_stats stats;
        return send_final_response(
            assoc, context_id, message_id,
            sop_class_uid, false, stats, false);
    }
 
    // Get calling AE for logging
    std::string calling_ae{assoc.calling_ae()};
 
    // Retrieve matching files
    const auto& query_keys = request.dataset().value().get();
    auto files = retrieve_handler_(query_keys);
    auto start_time = std::chrono::steady_clock::now();
 
    // Get study UID for event
    std::string study_uid = query_keys.get_string(core::tags::study_instance_uid);
 
    // Publish retrieve started event (C-GET has no destination AE)
    kcenon::common::get_event_bus().publish(
        kcenon::pacs::events::retrieve_started_event{
            kcenon::pacs::events::retrieve_operation::c_get,
            calling_ae,
            "",  // No destination for C-GET
            study_uid,
            static_cast<uint16_t>(files.size())
        }
    );
 
    // Initialize sub-operation statistics
    sub_operation_stats stats;
    stats.remaining = static_cast<uint16_t>(files.size());
    bool was_cancelled = false;
 
    // Process each file (C-STORE sub-operations on same association)
    for (const auto& file : files) {
        // Check for cancel request
        if (cancel_check_ && cancel_check_()) {
            was_cancelled = true;
            break;
        }
 
        // Send pending response with current progress
        auto pending_result = send_pending_response(
            assoc, context_id, message_id,
            sop_class_uid, false, stats);
 
        if (pending_result.is_err()) {
            return pending_result;
        }
 
        // Perform C-STORE sub-operation on the same association
        // For C-GET, images are sent back on the same association
        status_code store_status = status_success;
 
        if (store_handler_) {
            // Use custom store handler
            store_status = store_handler_(
                assoc, context_id, file,
                calling_ae, message_id);
        } else {
            // Default implementation: build and send C-STORE-RQ
            // Get the SOP Class and Instance UIDs from the file
            auto file_sop_class = file.sop_class_uid();
            auto file_sop_instance = file.sop_instance_uid();
 
            // Create C-STORE request
            dimse_message store_rq{command_field::c_store_rq, message_id};
            store_rq.set_affected_sop_class_uid(file_sop_class);
            store_rq.set_affected_sop_instance_uid(file_sop_instance);
            store_rq.set_priority(priority_medium);
 
            // For C-GET, include Move Originator information
            // (0000,1030) Move Originator Application Entity Title
            // (0000,1031) Move Originator Message ID
            store_rq.command_set().set_string(
                tag_move_originator_aet,
                encoding::vr_type::AE,
                calling_ae);
            store_rq.command_set().set_numeric<uint16_t>(
                tag_move_originator_message_id,
                encoding::vr_type::US,
                message_id);
 
            // Attach the dataset
            store_rq.set_dataset(file.dataset());
 
            // Find the presentation context for the SOP Class
            auto store_context_id = assoc.accepted_context_id(file_sop_class);
            if (!store_context_id.has_value()) {
                // No accepted context for this SOP Class
                stats.remaining--;
                stats.failed++;
                continue;
            }
 
            // Send the C-STORE request
            auto send_result = assoc.send_dimse(store_context_id.value(), store_rq);
            if (send_result.is_err()) {
                stats.remaining--;
                stats.failed++;
                continue;
            }
 
            // Wait for C-STORE response
            auto recv_result = assoc.receive_dimse();
            if (recv_result.is_err()) {
                stats.remaining--;
                stats.failed++;
                continue;
            }
 
            auto& [recv_ctx, store_rsp] = recv_result.value();
            store_status = store_rsp.status();
        }
 
        // Update statistics based on store result
        stats.remaining--;
        if (is_success(store_status)) {
            stats.completed++;
            ++images_transferred_;
        } else if (is_warning(store_status)) {
            stats.warning++;
            ++images_transferred_;
        } else {
            stats.failed++;
        }
    }
 
    // Update operation count
    ++get_operations_;
 
    // Calculate duration and publish completed event
    auto end_time = std::chrono::steady_clock::now();
    auto duration_ms = std::chrono::duration_cast<std::chrono::milliseconds>(
        end_time - start_time).count();
 
    kcenon::common::get_event_bus().publish(
        kcenon::pacs::events::retrieve_completed_event{
            kcenon::pacs::events::retrieve_operation::c_get,
            calling_ae,
            "",  // No destination for C-GET
            stats.completed,
            stats.failed,
            stats.warning,
            static_cast<uint64_t>(duration_ms)
        }
    );
 
    // Send final response
    return send_final_response(
        assoc, context_id, message_id,
        sop_class_uid, false, stats, was_cancelled);
}

Referenced by handle_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_c_move()

network::Result< std::monostate > kcenon::pacs::services::retrieve_scp::handle_c_move	(	network::association &	assoc,
		uint8_t	context_id,
		const network::dimse::dimse_message &	request )

nodiscardprivate

Handle a C-MOVE request.

Parameters

assoc	The association
context_id	The presentation context ID
request	The C-MOVE-RQ message

Returns: Success or error

Definition at line 115 of file retrieve_scp.cpp.

                                              {
 
    using namespace network::dimse;
 
    // Verify we have a retrieve handler
    if (!retrieve_handler_) {
        return kcenon::pacs::pacs_void_error(
            kcenon::pacs::error_codes::retrieve_handler_not_set,
            "No retrieve handler configured");
    }
 
    // Verify we have a destination resolver for C-MOVE
    if (!destination_resolver_) {
        return kcenon::pacs::pacs_void_error(
            kcenon::pacs::error_codes::retrieve_missing_destination,
            "No destination resolver configured for C-MOVE");
    }
 
    auto sop_class_uid = request.affected_sop_class_uid();
    auto message_id = request.message_id();
 
    // Verify we have a dataset (query keys)
    if (!request.has_dataset()) {
        sub_operation_stats stats;
        return send_final_response(
            assoc, context_id, message_id,
            sop_class_uid, true, stats, false);
    }
 
    // Get move destination AE title
    auto dest_ae = get_move_destination(request);
    if (dest_ae.empty()) {
        // Missing Move Destination - return error status
        ++move_operations_;
 
        dimse_message response{command_field::c_move_rsp, 0};
        response.set_affected_sop_class_uid(sop_class_uid);
        response.set_message_id_responded_to(message_id);
        response.set_status(status_refused_move_destination_unknown);
 
        return assoc.send_dimse(context_id, response);
    }
 
    // Resolve destination to network address
    auto dest_addr = destination_resolver_(dest_ae);
    if (!dest_addr.has_value()) {
        // Unknown destination AE - return error status
        ++move_operations_;
 
        dimse_message response{command_field::c_move_rsp, 0};
        response.set_affected_sop_class_uid(sop_class_uid);
        response.set_message_id_responded_to(message_id);
        response.set_status(status_refused_move_destination_unknown);
 
        return assoc.send_dimse(context_id, response);
    }
 
    // Get calling AE for move originator information
    std::string calling_ae{assoc.calling_ae()};
 
    // Retrieve matching files
    const auto& query_keys = request.dataset().value().get();
    auto files = retrieve_handler_(query_keys);
    auto start_time = std::chrono::steady_clock::now();
 
    // Get study UID for event
    std::string study_uid = query_keys.get_string(core::tags::study_instance_uid);
 
    // Publish retrieve started event
    kcenon::common::get_event_bus().publish(
        kcenon::pacs::events::retrieve_started_event{
            kcenon::pacs::events::retrieve_operation::c_move,
            calling_ae,
            dest_ae,
            study_uid,
            static_cast<uint16_t>(files.size())
        }
    );
 
    // Initialize sub-operation statistics
    sub_operation_stats stats;
    stats.remaining = static_cast<uint16_t>(files.size());
    bool was_cancelled = false;
 
    // Process each file (C-STORE sub-operations)
    for (const auto& file : files) {
        // Check for cancel request
        if (cancel_check_ && cancel_check_()) {
            was_cancelled = true;
            break;
        }
 
        // Send pending response with current progress
        auto pending_result = send_pending_response(
            assoc, context_id, message_id,
            sop_class_uid, true, stats);
 
        if (pending_result.is_err()) {
            return pending_result;
        }
 
        // Perform C-STORE sub-operation
        // Note: In a full implementation, this would establish a sub-association
        // to the destination and perform C-STORE. For now, we simulate success
        // or use the provided store handler.
        status_code store_status = status_success;
 
        if (store_handler_) {
            // Use custom store handler
            // The handler should establish connection to dest_addr and perform C-STORE
            // For now, we pass the current association (which isn't correct for C-MOVE)
            // A real implementation would create a separate association to destination
            store_status = store_handler_(
                assoc, context_id, file,
                calling_ae, message_id);
        }
 
        // Update statistics based on store result
        stats.remaining--;
        if (is_success(store_status)) {
            stats.completed++;
            ++images_transferred_;
        } else if (is_warning(store_status)) {
            stats.warning++;
            ++images_transferred_;
        } else {
            stats.failed++;
        }
    }
 
    // Update operation count
    ++move_operations_;
 
    // Calculate duration and publish completed event
    auto end_time = std::chrono::steady_clock::now();
    auto duration_ms = std::chrono::duration_cast<std::chrono::milliseconds>(
        end_time - start_time).count();
 
    kcenon::common::get_event_bus().publish(
        kcenon::pacs::events::retrieve_completed_event{
            kcenon::pacs::events::retrieve_operation::c_move,
            calling_ae,
            dest_ae,
            stats.completed,
            stats.failed,
            stats.warning,
            static_cast<uint64_t>(duration_ms)
        }
    );
 
    // Send final response
    return send_final_response(
        assoc, context_id, message_id,
        sop_class_uid, true, stats, was_cancelled);
}

References kcenon::pacs::network::dimse::dimse_message::affected_sop_class_uid(), kcenon::pacs::events::c_move, kcenon::pacs::network::association::calling_ae(), cancel_check_, kcenon::pacs::network::dimse::dimse_message::dataset(), destination_resolver_, get_move_destination(), kcenon::pacs::network::dimse::dimse_message::has_dataset(), images_transferred_, kcenon::pacs::services::is_success(), kcenon::pacs::services::is_warning(), kcenon::pacs::network::dimse::dimse_message::message_id(), move_operations_, kcenon::pacs::pacs_void_error(), retrieve_handler_, kcenon::pacs::error_codes::retrieve_handler_not_set, kcenon::pacs::error_codes::retrieve_missing_destination, kcenon::pacs::network::association::send_dimse(), send_final_response(), send_pending_response(), store_handler_, and kcenon::pacs::core::tags::study_instance_uid.

Referenced by handle_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_message()

network::Result< std::monostate > kcenon::pacs::services::retrieve_scp::handle_message	(	network::association &	assoc,
		uint8_t	context_id,
		const network::dimse::dimse_message &	request )

nodiscardoverridevirtual

Handle an incoming DIMSE message (C-MOVE-RQ or C-GET-RQ)

Processes the retrieve request:

Validates the message type (C-MOVE-RQ or C-GET-RQ)
Extracts query keys from the dataset
Retrieves matching files via the retrieve handler
For C-MOVE: resolves destination and establishes sub-association
Performs C-STORE sub-operations for each file
Sends pending responses with progress updates
Sends final response with operation statistics

Parameters

assoc	The association on which the message was received
context_id	The presentation context ID for the message
request	The incoming C-MOVE-RQ or C-GET-RQ message

Returns: Success or error

Implements kcenon::pacs::services::scp_service.

Definition at line 62 of file retrieve_scp.cpp.

                                              {
 
    using namespace network::dimse;
 
    // Route to appropriate handler based on command type
    switch (request.command()) {
        case command_field::c_move_rq:
            return handle_c_move(assoc, context_id, request);
 
        case command_field::c_get_rq:
            return handle_c_get(assoc, context_id, request);
 
        default:
            return kcenon::pacs::pacs_void_error(
                kcenon::pacs::error_codes::retrieve_unexpected_command,
                "Expected C-MOVE-RQ or C-GET-RQ but received " +
                std::string(to_string(request.command())));
    }
}

References kcenon::pacs::network::dimse::dimse_message::command(), handle_c_get(), handle_c_move(), kcenon::pacs::pacs_void_error(), kcenon::pacs::error_codes::retrieve_unexpected_command, and kcenon::pacs::services::to_string().

Here is the call graph for this function:

◆ images_transferred()

size_t kcenon::pacs::services::retrieve_scp::images_transferred ( ) const

nodiscardnoexcept

Get total number of images transferred.

Returns: Number of images sent via C-STORE sub-operations

Definition at line 101 of file retrieve_scp.cpp.

                                                       {
    return images_transferred_.load();
}

References images_transferred_.

◆ move_operations()

size_t kcenon::pacs::services::retrieve_scp::move_operations ( ) const

nodiscardnoexcept

Get total number of C-MOVE operations processed.

Returns: Number of C-MOVE requests handled

Definition at line 93 of file retrieve_scp.cpp.

                                                    {
    return move_operations_.load();
}

References move_operations_.

◆ reset_statistics()

void kcenon::pacs::services::retrieve_scp::reset_statistics ( )

noexcept

Reset statistics counters.

Definition at line 105 of file retrieve_scp.cpp.

                                             {
    move_operations_ = 0;
    get_operations_ = 0;
    images_transferred_ = 0;
}

References get_operations_, images_transferred_, and move_operations_.

◆ send_final_response()

network::Result< std::monostate > kcenon::pacs::services::retrieve_scp::send_final_response	(	network::association &	assoc,
		uint8_t	context_id,
		uint16_t	message_id,
		std::string_view	sop_class_uid,
		bool	is_move,
		const sub_operation_stats &	stats,
		bool	was_cancelled )

nodiscardprivate

Send a final response with completion status.

Parameters

assoc	The association
context_id	The presentation context ID
message_id	The original request message ID
sop_class_uid	The SOP Class UID
is_move	true for C-MOVE-RSP, false for C-GET-RSP
stats	Final sub-operation statistics
was_cancelled	true if operation was cancelled

Returns: Success or error

Definition at line 483 of file retrieve_scp.cpp.

                        {
 
    using namespace network::dimse;
 
    // Create response message
    auto cmd = is_move ? command_field::c_move_rsp : command_field::c_get_rsp;
    dimse_message response{cmd, 0};
 
    response.set_affected_sop_class_uid(sop_class_uid);
    response.set_message_id_responded_to(message_id);
 
    // Determine final status
    status_code final_status;
    if (was_cancelled) {
        final_status = status_cancel;
    } else if (stats.failed > 0 && stats.completed == 0 && stats.warning == 0) {
        // All sub-operations failed
        final_status = status_refused_out_of_resources_subops;
    } else if (stats.failed > 0 || stats.warning > 0) {
        // Some sub-operations had issues
        final_status = status_warning_subops_complete_failures;
    } else {
        // All successful
        final_status = status_success;
    }
 
    response.set_status(final_status);
 
    // Set final sub-operation counts
    response.set_remaining_subops(stats.remaining);
    response.set_completed_subops(stats.completed);
    response.set_failed_subops(stats.failed);
    response.set_warning_subops(stats.warning);
 
    // Send the response
    return assoc.send_dimse(context_id, response);
}

References kcenon::pacs::network::association::send_dimse().

Referenced by handle_c_get(), and handle_c_move().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_pending_response()

network::Result< std::monostate > kcenon::pacs::services::retrieve_scp::send_pending_response	(	network::association &	assoc,
		uint8_t	context_id,
		uint16_t	message_id,
		std::string_view	sop_class_uid,
		bool	is_move,
		const sub_operation_stats &	stats )

nodiscardprivate

Send a pending response with progress information.

Parameters

assoc	The association
context_id	The presentation context ID
message_id	The original request message ID
sop_class_uid	The SOP Class UID
is_move	true for C-MOVE-RSP, false for C-GET-RSP
stats	Current sub-operation statistics

Returns: Success or error

Definition at line 455 of file retrieve_scp.cpp.

                                      {
 
    using namespace network::dimse;
 
    // Create response message
    auto cmd = is_move ? command_field::c_move_rsp : command_field::c_get_rsp;
    dimse_message response{cmd, 0};
 
    response.set_affected_sop_class_uid(sop_class_uid);
    response.set_message_id_responded_to(message_id);
    response.set_status(status_pending);
 
    // Set sub-operation counts
    response.set_remaining_subops(stats.remaining);
    response.set_completed_subops(stats.completed);
    response.set_failed_subops(stats.failed);
    response.set_warning_subops(stats.warning);
 
    // Send the response
    return assoc.send_dimse(context_id, response);
}

References kcenon::pacs::network::association::send_dimse().

Referenced by handle_c_get(), and handle_c_move().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ service_name()

std::string_view kcenon::pacs::services::retrieve_scp::service_name ( ) const

nodiscardoverridevirtualnoexcept

Get the service name.

Returns: "Retrieve SCP"

Implements kcenon::pacs::services::scp_service.

Definition at line 85 of file retrieve_scp.cpp.

                                                         {
    return "Retrieve SCP";
}

◆ set_cancel_check()

void kcenon::pacs::services::retrieve_scp::set_cancel_check ( retrieve_cancel_check check )

Set the cancel check function.

The cancel check is called periodically during retrieve processing to check if a C-CANCEL has been received.

Parameters

check The cancel check function

Definition at line 45 of file retrieve_scp.cpp.

                                                               {
    cancel_check_ = std::move(check);
}

References cancel_check_.

◆ set_destination_resolver()

void kcenon::pacs::services::retrieve_scp::set_destination_resolver ( destination_resolver resolver )

Set the destination resolver function.

The resolver maps AE titles to network addresses for C-MOVE operations.

Parameters

resolver The destination resolver function

Definition at line 37 of file retrieve_scp.cpp.

                                                                         {
    destination_resolver_ = std::move(resolver);
}

References destination_resolver_.

◆ set_retrieve_handler()

void kcenon::pacs::services::retrieve_scp::set_retrieve_handler ( retrieve_handler handler )

Set the retrieve handler function.

The handler is called for each retrieve request to find matching DICOM files in storage.

Parameters

handler The retrieve handler function

Definition at line 33 of file retrieve_scp.cpp.

                                                                {
    retrieve_handler_ = std::move(handler);
}

References retrieve_handler_.

◆ set_store_sub_operation()

void kcenon::pacs::services::retrieve_scp::set_store_sub_operation ( store_sub_operation handler )

Set the store sub-operation handler.

The store handler performs C-STORE sub-operations during C-MOVE/C-GET. If not set, a default implementation using the association's send_dimse will be used.

Parameters

handler The store sub-operation handler

Definition at line 41 of file retrieve_scp.cpp.

                                                                      {
    store_handler_ = std::move(handler);
}

References store_handler_.

◆ supported_sop_classes()

std::vector< std::string > kcenon::pacs::services::retrieve_scp::supported_sop_classes ( ) const

nodiscardoverridevirtual

Get supported SOP Class UIDs.

Returns: Vector containing Patient Root and Study Root Move/Get SOP Classes

Implements kcenon::pacs::services::scp_service.

Definition at line 53 of file retrieve_scp.cpp.

                                                               {
    return {
        std::string(patient_root_move_sop_class_uid),
        std::string(study_root_move_sop_class_uid),
        std::string(patient_root_get_sop_class_uid),
        std::string(study_root_get_sop_class_uid)
    };
}

References kcenon::pacs::services::patient_root_get_sop_class_uid, kcenon::pacs::services::patient_root_move_sop_class_uid, kcenon::pacs::services::study_root_get_sop_class_uid, and kcenon::pacs::services::study_root_move_sop_class_uid.

Member Data Documentation

◆ cancel_check_

retrieve_cancel_check kcenon::pacs::services::retrieve_scp::cancel_check_

private

Definition at line 442 of file retrieve_scp.h.

Referenced by handle_c_get(), handle_c_move(), and set_cancel_check().

◆ destination_resolver_

destination_resolver kcenon::pacs::services::retrieve_scp::destination_resolver_

private

Definition at line 440 of file retrieve_scp.h.

Referenced by handle_c_move(), and set_destination_resolver().

◆ get_operations_

std::atomic<size_t> kcenon::pacs::services::retrieve_scp::get_operations_ {0}

private

Definition at line 445 of file retrieve_scp.h.

445{0};

Referenced by get_operations(), handle_c_get(), and reset_statistics().

◆ images_transferred_

std::atomic<size_t> kcenon::pacs::services::retrieve_scp::images_transferred_ {0}

private

Definition at line 446 of file retrieve_scp.h.

446{0};

Referenced by handle_c_get(), handle_c_move(), images_transferred(), and reset_statistics().

◆ move_operations_

std::atomic<size_t> kcenon::pacs::services::retrieve_scp::move_operations_ {0}

private

Definition at line 444 of file retrieve_scp.h.

444{0};

Referenced by handle_c_move(), move_operations(), and reset_statistics().

◆ retrieve_handler_

retrieve_handler kcenon::pacs::services::retrieve_scp::retrieve_handler_

private

Definition at line 439 of file retrieve_scp.h.

Referenced by handle_c_get(), handle_c_move(), and set_retrieve_handler().

◆ store_handler_

store_sub_operation kcenon::pacs::services::retrieve_scp::store_handler_

private

Definition at line 441 of file retrieve_scp.h.

Referenced by handle_c_get(), handle_c_move(), and set_store_sub_operation().

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

include/kcenon/pacs/services/retrieve_scp.h
src/services/retrieve_scp.cpp

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ retrieve_scp()

◆ ~retrieve_scp()

Member Function Documentation

◆ get_move_destination()

◆ get_operations()

◆ handle_c_get()

◆ handle_c_move()

◆ handle_message()

◆ images_transferred()

◆ move_operations()

◆ reset_statistics()

◆ send_final_response()

◆ send_pending_response()

◆ service_name()

◆ set_cancel_check()

◆ set_destination_resolver()

◆ set_retrieve_handler()

◆ set_store_sub_operation()

◆ supported_sop_classes()

Member Data Documentation

◆ cancel_check_

◆ destination_resolver_

◆ get_operations_

◆ images_transferred_

◆ move_operations_

◆ retrieve_handler_

◆ store_handler_