kcenon::pacs::services::ups_push_scp Class Reference

#include <ups_push_scp.h>

Inheritance diagram for kcenon::pacs::services::ups_push_scp:

Collaboration diagram for kcenon::pacs::services::ups_push_scp:

Public Member Functions
	ups_push_scp (std::shared_ptr< di::ILogger > logger=nullptr)
	Construct UPS Push SCP with optional logger.
	~ups_push_scp () override=default
void	set_create_handler (ups_create_handler handler)
void	set_set_handler (ups_set_handler handler)
void	set_get_handler (ups_get_handler handler)
void	set_change_state_handler (ups_change_state_handler handler)
void	set_request_cancel_handler (ups_request_cancel_handler handler)
std::vector< std::string >	supported_sop_classes () const override
	Get the list of SOP Class UIDs supported by this service.
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.
std::string_view	service_name () const noexcept override
	Get the service name for logging/debugging.
size_t	creates_processed () const noexcept
size_t	sets_processed () const noexcept
size_t	gets_processed () const noexcept
size_t	actions_processed () const noexcept
size_t	state_changes () const noexcept
size_t	cancel_requests () const noexcept
void	reset_statistics () noexcept
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_n_create (network::association &assoc, uint8_t context_id, const network::dimse::dimse_message &request)
network::Result< std::monostate >	handle_n_set (network::association &assoc, uint8_t context_id, const network::dimse::dimse_message &request)
network::Result< std::monostate >	handle_n_get (network::association &assoc, uint8_t context_id, const network::dimse::dimse_message &request)
network::Result< std::monostate >	handle_n_action (network::association &assoc, uint8_t context_id, const network::dimse::dimse_message &request)
network::Result< std::monostate >	send_n_create_response (network::association &assoc, uint8_t context_id, uint16_t message_id, const std::string &sop_instance_uid, network::dimse::status_code status)
network::Result< std::monostate >	send_n_set_response (network::association &assoc, uint8_t context_id, uint16_t message_id, const std::string &sop_instance_uid, network::dimse::status_code status)
network::Result< std::monostate >	send_n_get_response (network::association &assoc, uint8_t context_id, uint16_t message_id, const std::string &sop_instance_uid, network::dimse::status_code status, core::dicom_dataset *dataset=nullptr)
network::Result< std::monostate >	send_n_action_response (network::association &assoc, uint8_t context_id, uint16_t message_id, const std::string &sop_instance_uid, uint16_t action_type_id, network::dimse::status_code status)

Private Attributes
ups_create_handler	create_handler_
ups_set_handler	set_handler_
ups_get_handler	get_handler_
ups_change_state_handler	change_state_handler_
ups_request_cancel_handler	request_cancel_handler_
std::atomic< size_t >	creates_processed_ {0}
std::atomic< size_t >	sets_processed_ {0}
std::atomic< size_t >	gets_processed_ {0}
std::atomic< size_t >	actions_processed_ {0}
std::atomic< size_t >	state_changes_ {0}
std::atomic< size_t >	cancel_requests_ {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 171 of file ups_push_scp.h.

Constructor & Destructor Documentation

ups_push_scp()

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

explicit

Construct UPS Push SCP with optional logger.

Parameters

logger

Logger instance for service logging (nullptr uses null_logger)

Definition at line 21 of file ups_push_scp.cpp.

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

~ups_push_scp()

kcenon::pacs::services::ups_push_scp::~ups_push_scp ( )

overridedefault

Member Function Documentation

actions_processed()

size_t kcenon::pacs::services::ups_push_scp::actions_processed ( ) const

nodiscardnoexcept

Definition at line 104 of file ups_push_scp.cpp.

                                                      {
    return actions_processed_.load();
}

References actions_processed_.

cancel_requests()

size_t kcenon::pacs::services::ups_push_scp::cancel_requests ( ) const

nodiscardnoexcept

Definition at line 112 of file ups_push_scp.cpp.

                                                    {
    return cancel_requests_.load();
}

References cancel_requests_.

creates_processed()

size_t kcenon::pacs::services::ups_push_scp::creates_processed ( ) const

nodiscardnoexcept

Definition at line 92 of file ups_push_scp.cpp.

                                                      {
    return creates_processed_.load();
}

References creates_processed_.

gets_processed()

size_t kcenon::pacs::services::ups_push_scp::gets_processed ( ) const

nodiscardnoexcept

Definition at line 100 of file ups_push_scp.cpp.

                                                   {
    return gets_processed_.load();
}

References gets_processed_.

handle_message()

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

nodiscardoverridevirtual

Handle an incoming DIMSE message.

Processes the request and sends appropriate response(s) via the association.

Parameters

assoc	The association on which the message was received
context_id	The presentation context ID for the message
request	The incoming DIMSE request message

Returns

Success or error result

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

Definition at line 56 of file ups_push_scp.cpp.

                                              {
 
    using namespace network::dimse;
 
    switch (request.command()) {
        case command_field::n_create_rq:
            return handle_n_create(assoc, context_id, request);
 
        case command_field::n_set_rq:
            return handle_n_set(assoc, context_id, request);
 
        case command_field::n_get_rq:
            return handle_n_get(assoc, context_id, request);
 
        case command_field::n_action_rq:
            return handle_n_action(assoc, context_id, request);
 
        default:
            return kcenon::pacs::pacs_void_error(
                kcenon::pacs::error_codes::ups_unexpected_command,
                "Unexpected command for UPS Push SCP: " +
                std::string(to_string(request.command())));
    }
}

References kcenon::pacs::network::dimse::dimse_message::command(), handle_n_action(), handle_n_create(), handle_n_get(), handle_n_set(), kcenon::pacs::pacs_void_error(), kcenon::pacs::services::to_string(), and kcenon::pacs::error_codes::ups_unexpected_command.

Here is the call graph for this function:

handle_n_action()

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

nodiscardprivate

Definition at line 365 of file ups_push_scp.cpp.

                                              {
 
    using namespace network::dimse;
 
    // Get Action Type ID
    auto action_type = request.action_type_id();
    if (!action_type.has_value()) {
        return kcenon::pacs::pacs_void_error(
            kcenon::pacs::error_codes::ups_invalid_action_type,
            "Missing Action Type ID in N-ACTION request");
    }
 
    // Get SOP Instance UID
    auto sop_instance_uid = request.requested_sop_instance_uid();
    if (sop_instance_uid.empty()) {
        sop_instance_uid = request.affected_sop_instance_uid();
    }
 
    if (sop_instance_uid.empty()) {
        return send_n_action_response(
            assoc, context_id, request.message_id(),
            "", action_type.value(), status_error_missing_attribute);
    }
 
    uint16_t action_id = action_type.value();
 
    if (action_id == ups_action_change_state) {
        // N-ACTION Type 1: Change UPS State
        if (!change_state_handler_) {
            return kcenon::pacs::pacs_void_error(
                kcenon::pacs::error_codes::ups_handler_not_set,
                "No Change State handler configured for UPS Push SCP");
        }
 
        if (!request.has_dataset()) {
            return send_n_action_response(
                assoc, context_id, request.message_id(),
                sop_instance_uid, action_id, status_error_cannot_understand);
        }
 
        const auto& dataset = request.dataset().value().get();
 
        // Extract new state
        if (!dataset.contains(ups_tags::procedure_step_state)) {
            return send_n_action_response(
                assoc, context_id, request.message_id(),
                sop_instance_uid, action_id, status_error_missing_attribute);
        }
 
        auto new_state = dataset.get_string(ups_tags::procedure_step_state);
 
        // Validate the state value
        auto parsed_state = storage::parse_ups_state(new_state);
        if (!parsed_state.has_value()) {
            return send_n_action_response(
                assoc, context_id, request.message_id(),
                sop_instance_uid, action_id, status_error_cannot_understand);
        }
 
        // Extract Transaction UID (required when transitioning to IN PROGRESS)
        std::string txn_uid;
        if (dataset.contains(ups_tags::transaction_uid)) {
            txn_uid = dataset.get_string(ups_tags::transaction_uid);
        }
 
        if (parsed_state.value() == storage::ups_state::in_progress &&
            txn_uid.empty()) {
            return send_n_action_response(
                assoc, context_id, request.message_id(),
                sop_instance_uid, action_id, status_error_missing_attribute);
        }
 
        auto result = change_state_handler_(sop_instance_uid, new_state, txn_uid);
        if (result.is_err()) {
            return send_n_action_response(
                assoc, context_id, request.message_id(),
                sop_instance_uid, action_id, status_error_unable_to_process);
        }
 
        ++actions_processed_;
        ++state_changes_;
 
        return send_n_action_response(
            assoc, context_id, request.message_id(),
            sop_instance_uid, action_id, status_success);
 
    } else if (action_id == ups_action_request_cancel) {
        // N-ACTION Type 3: Request Cancellation
        if (!request_cancel_handler_) {
            return kcenon::pacs::pacs_void_error(
                kcenon::pacs::error_codes::ups_handler_not_set,
                "No Request Cancel handler configured for UPS Push SCP");
        }
 
        // Extract cancellation reason (optional)
        std::string reason;
        if (request.has_dataset()) {
            const auto& dataset = request.dataset().value().get();
            if (dataset.contains(ups_tags::reason_for_cancellation)) {
                reason = dataset.get_string(ups_tags::reason_for_cancellation);
            }
        }
 
        auto result = request_cancel_handler_(sop_instance_uid, reason);
        if (result.is_err()) {
            return send_n_action_response(
                assoc, context_id, request.message_id(),
                sop_instance_uid, action_id, status_error_unable_to_process);
        }
 
        ++actions_processed_;
        ++cancel_requests_;
 
        return send_n_action_response(
            assoc, context_id, request.message_id(),
            sop_instance_uid, action_id, status_success);
 
    } else {
        // Unknown action type
        return send_n_action_response(
            assoc, context_id, request.message_id(),
            sop_instance_uid, action_id, status_error_no_such_action_type);
    }
}

References kcenon::pacs::network::dimse::dimse_message::action_type_id(), actions_processed_, kcenon::pacs::network::dimse::dimse_message::affected_sop_instance_uid(), cancel_requests_, change_state_handler_, kcenon::pacs::network::dimse::dimse_message::dataset(), kcenon::pacs::network::dimse::dimse_message::has_dataset(), kcenon::pacs::storage::in_progress, kcenon::pacs::network::dimse::dimse_message::message_id(), kcenon::pacs::pacs_void_error(), kcenon::pacs::storage::parse_ups_state(), kcenon::pacs::services::ups_tags::procedure_step_state, kcenon::pacs::services::ups_tags::reason_for_cancellation, request_cancel_handler_, kcenon::pacs::network::dimse::dimse_message::requested_sop_instance_uid(), send_n_action_response(), state_changes_, kcenon::pacs::services::ups_tags::transaction_uid, kcenon::pacs::services::ups_action_change_state, kcenon::pacs::services::ups_action_request_cancel, kcenon::pacs::error_codes::ups_handler_not_set, and kcenon::pacs::error_codes::ups_invalid_action_type.

Referenced by handle_message().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_n_create()

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

nodiscardprivate

Definition at line 129 of file ups_push_scp.cpp.

                                              {
 
    using namespace network::dimse;
 
    // Verify we have a handler configured
    if (!create_handler_) {
        return kcenon::pacs::pacs_void_error(
            kcenon::pacs::error_codes::ups_handler_not_set,
            "No N-CREATE handler configured for UPS Push SCP");
    }
 
    // Verify the SOP Class is UPS Push
    auto sop_class_uid = request.affected_sop_class_uid();
    if (sop_class_uid != ups_push_sop_class_uid) {
        return send_n_create_response(
            assoc, context_id, request.message_id(),
            "", status_refused_sop_class_not_supported);
    }
 
    // Get the SOP Instance UID (workitem UID)
    auto sop_instance_uid = request.affected_sop_instance_uid();
    if (sop_instance_uid.empty()) {
        return send_n_create_response(
            assoc, context_id, request.message_id(),
            "", status_error_missing_attribute);
    }
 
    // Verify we have a dataset
    if (!request.has_dataset()) {
        return send_n_create_response(
            assoc, context_id, request.message_id(),
            sop_instance_uid, status_error_cannot_understand);
    }
 
    const auto& dataset = request.dataset().value().get();
 
    // Validate initial state is SCHEDULED (if present in dataset)
    if (dataset.contains(ups_tags::procedure_step_state)) {
        auto state_str = dataset.get_string(ups_tags::procedure_step_state);
        auto parsed_state = storage::parse_ups_state(state_str);
 
        if (!parsed_state.has_value() ||
            parsed_state.value() != storage::ups_state::scheduled) {
            return send_n_create_response(
                assoc, context_id, request.message_id(),
                sop_instance_uid, status_error_cannot_understand);
        }
    }
 
    // Build UPS workitem from request data
    storage::ups_workitem workitem;
    workitem.workitem_uid = sop_instance_uid;
    workitem.state = "SCHEDULED";
 
    // Extract optional fields from dataset
    if (dataset.contains(ups_tags::procedure_step_label)) {
        workitem.procedure_step_label =
            dataset.get_string(ups_tags::procedure_step_label);
    }
    if (dataset.contains(ups_tags::worklist_label)) {
        workitem.worklist_label =
            dataset.get_string(ups_tags::worklist_label);
    }
    if (dataset.contains(ups_tags::scheduled_procedure_step_priority)) {
        workitem.priority =
            dataset.get_string(ups_tags::scheduled_procedure_step_priority);
    }
 
    // Call the handler to create the workitem
    auto result = create_handler_(workitem);
    if (result.is_err()) {
        return send_n_create_response(
            assoc, context_id, request.message_id(),
            sop_instance_uid, status_error_unable_to_process);
    }
 
    ++creates_processed_;
 
    return send_n_create_response(
        assoc, context_id, request.message_id(),
        sop_instance_uid, status_success);
}

References kcenon::pacs::network::dimse::dimse_message::affected_sop_class_uid(), kcenon::pacs::network::dimse::dimse_message::affected_sop_instance_uid(), create_handler_, creates_processed_, kcenon::pacs::network::dimse::dimse_message::dataset(), kcenon::pacs::network::dimse::dimse_message::has_dataset(), kcenon::pacs::network::dimse::dimse_message::message_id(), kcenon::pacs::pacs_void_error(), kcenon::pacs::storage::parse_ups_state(), kcenon::pacs::storage::ups_workitem::priority, kcenon::pacs::services::ups_tags::procedure_step_label, kcenon::pacs::storage::ups_workitem::procedure_step_label, kcenon::pacs::services::ups_tags::procedure_step_state, kcenon::pacs::storage::scheduled, kcenon::pacs::services::ups_tags::scheduled_procedure_step_priority, send_n_create_response(), kcenon::pacs::storage::ups_workitem::state, kcenon::pacs::error_codes::ups_handler_not_set, kcenon::pacs::services::ups_push_sop_class_uid, kcenon::pacs::storage::ups_workitem::workitem_uid, kcenon::pacs::services::ups_tags::worklist_label, and kcenon::pacs::storage::ups_workitem::worklist_label.

Referenced by handle_message().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_n_get()

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

nodiscardprivate

Definition at line 289 of file ups_push_scp.cpp.

                                              {
 
    using namespace network::dimse;
 
    // Verify we have a handler configured
    if (!get_handler_) {
        return kcenon::pacs::pacs_void_error(
            kcenon::pacs::error_codes::ups_handler_not_set,
            "No N-GET handler configured for UPS Push SCP");
    }
 
    // Extract Requested SOP Instance UID
    auto sop_instance_uid = request.requested_sop_instance_uid();
    if (sop_instance_uid.empty()) {
        return send_n_get_response(
            assoc, context_id, request.message_id(),
            "", status_error_missing_attribute);
    }
 
    // Call the handler to retrieve the workitem
    auto result = get_handler_(sop_instance_uid);
    if (result.is_err()) {
        return send_n_get_response(
            assoc, context_id, request.message_id(),
            sop_instance_uid, status_error_invalid_object_instance);
    }
 
    ++gets_processed_;
 
    // Build response dataset from workitem
    const auto& workitem = result.value();
    core::dicom_dataset response_dataset;
 
    response_dataset.set_string(
        ups_tags::procedure_step_state,
        encoding::vr_type::CS, workitem.state);
 
    if (!workitem.procedure_step_label.empty()) {
        response_dataset.set_string(
            ups_tags::procedure_step_label,
            encoding::vr_type::LO, workitem.procedure_step_label);
    }
    if (!workitem.worklist_label.empty()) {
        response_dataset.set_string(
            ups_tags::worklist_label,
            encoding::vr_type::LO, workitem.worklist_label);
    }
    if (!workitem.priority.empty()) {
        response_dataset.set_string(
            ups_tags::scheduled_procedure_step_priority,
            encoding::vr_type::CS, workitem.priority);
    }
    if (!workitem.progress_description.empty()) {
        response_dataset.set_string(
            ups_tags::procedure_step_progress,
            encoding::vr_type::DS,
            std::to_string(workitem.progress_percent));
    }
    if (!workitem.transaction_uid.empty()) {
        response_dataset.set_string(
            ups_tags::transaction_uid,
            encoding::vr_type::UI, workitem.transaction_uid);
    }
 
    return send_n_get_response(
        assoc, context_id, request.message_id(),
        sop_instance_uid, status_success, &response_dataset);
}

References kcenon::pacs::encoding::CS, kcenon::pacs::encoding::DS, get_handler_, gets_processed_, kcenon::pacs::encoding::LO, kcenon::pacs::network::dimse::dimse_message::message_id(), kcenon::pacs::pacs_void_error(), kcenon::pacs::services::ups_tags::procedure_step_label, kcenon::pacs::services::ups_tags::procedure_step_progress, kcenon::pacs::services::ups_tags::procedure_step_state, kcenon::pacs::network::dimse::dimse_message::requested_sop_instance_uid(), kcenon::pacs::services::ups_tags::scheduled_procedure_step_priority, send_n_get_response(), kcenon::pacs::core::dicom_dataset::set_string(), kcenon::pacs::services::ups_tags::transaction_uid, kcenon::pacs::encoding::UI, kcenon::pacs::error_codes::ups_handler_not_set, and kcenon::pacs::services::ups_tags::worklist_label.

Referenced by handle_message().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_n_set()

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

nodiscardprivate

Definition at line 219 of file ups_push_scp.cpp.

                                              {
 
    using namespace network::dimse;
 
    // Verify we have a handler configured
    if (!set_handler_) {
        return kcenon::pacs::pacs_void_error(
            kcenon::pacs::error_codes::ups_handler_not_set,
            "No N-SET handler configured for UPS Push SCP");
    }
 
    // Get SOP Instance UID (from Requested SOP Instance UID for N-SET)
    auto sop_instance_uid = request.command_set().get_string(
        tag_requested_sop_instance_uid);
 
    if (sop_instance_uid.empty()) {
        sop_instance_uid = request.affected_sop_instance_uid();
    }
 
    if (sop_instance_uid.empty()) {
        return send_n_set_response(
            assoc, context_id, request.message_id(),
            "", status_error_missing_attribute);
    }
 
    // Verify we have a dataset with modifications
    if (!request.has_dataset()) {
        return send_n_set_response(
            assoc, context_id, request.message_id(),
            sop_instance_uid, status_error_cannot_understand);
    }
 
    const auto& dataset = request.dataset().value().get();
 
    // Reject if dataset tries to set a final state directly via N-SET
    // (state changes must go through N-ACTION)
    if (dataset.contains(ups_tags::procedure_step_state)) {
        auto state_str = dataset.get_string(ups_tags::procedure_step_state);
        auto parsed_state = storage::parse_ups_state(state_str);
        if (parsed_state.has_value() &&
            (parsed_state.value() == storage::ups_state::completed ||
             parsed_state.value() == storage::ups_state::canceled)) {
            return send_n_set_response(
                assoc, context_id, request.message_id(),
                sop_instance_uid, status_error_cannot_understand);
        }
    }
 
    // Call the handler to update the workitem
    auto result = set_handler_(sop_instance_uid, dataset);
    if (result.is_err()) {
        return send_n_set_response(
            assoc, context_id, request.message_id(),
            sop_instance_uid, status_error_unable_to_process);
    }
 
    ++sets_processed_;
 
    return send_n_set_response(
        assoc, context_id, request.message_id(),
        sop_instance_uid, status_success);
}

References kcenon::pacs::network::dimse::dimse_message::affected_sop_instance_uid(), kcenon::pacs::storage::canceled, kcenon::pacs::network::dimse::dimse_message::command_set(), kcenon::pacs::storage::completed, kcenon::pacs::network::dimse::dimse_message::dataset(), kcenon::pacs::network::dimse::dimse_message::has_dataset(), kcenon::pacs::network::dimse::dimse_message::message_id(), kcenon::pacs::pacs_void_error(), kcenon::pacs::storage::parse_ups_state(), kcenon::pacs::services::ups_tags::procedure_step_state, send_n_set_response(), set_handler_, sets_processed_, and kcenon::pacs::error_codes::ups_handler_not_set.

Referenced by handle_message().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_statistics()

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

noexcept

Definition at line 116 of file ups_push_scp.cpp.

                                             {
    creates_processed_ = 0;
    sets_processed_ = 0;
    gets_processed_ = 0;
    actions_processed_ = 0;
    state_changes_ = 0;
    cancel_requests_ = 0;
}

References actions_processed_, cancel_requests_, creates_processed_, gets_processed_, sets_processed_, and state_changes_.

send_n_action_response()

network::Result< std::monostate > kcenon::pacs::services::ups_push_scp::send_n_action_response ( network::association & assoc, uint8_t context_id, uint16_t message_id, const std::string & sop_instance_uid, uint16_t action_type_id, network::dimse::status_code status )

nodiscardprivate

Definition at line 559 of file ups_push_scp.cpp.

                                    {
 
    using namespace network::dimse;
 
    auto response = make_n_action_rsp(
        message_id, ups_push_sop_class_uid, sop_instance_uid,
        action_type_id, status);
 
    return assoc.send_dimse(context_id, response);
}

References kcenon::pacs::network::association::send_dimse(), and kcenon::pacs::services::ups_push_sop_class_uid.

Referenced by handle_n_action().

Here is the call graph for this function:

Here is the caller graph for this function:

send_n_create_response()

network::Result< std::monostate > kcenon::pacs::services::ups_push_scp::send_n_create_response ( network::association & assoc, uint8_t context_id, uint16_t message_id, const std::string & sop_instance_uid, network::dimse::status_code status )

nodiscardprivate

Definition at line 497 of file ups_push_scp.cpp.

                                    {
 
    using namespace network::dimse;
 
    dimse_message response{command_field::n_create_rsp, 0};
    response.set_message_id_responded_to(message_id);
    response.set_affected_sop_class_uid(ups_push_sop_class_uid);
    response.set_status(status);
 
    if (!sop_instance_uid.empty()) {
        response.set_affected_sop_instance_uid(sop_instance_uid);
    }
 
    return assoc.send_dimse(context_id, response);
}

References kcenon::pacs::network::association::send_dimse(), and kcenon::pacs::services::ups_push_sop_class_uid.

Referenced by handle_n_create().

Here is the call graph for this function:

Here is the caller graph for this function:

send_n_get_response()

network::Result< std::monostate > kcenon::pacs::services::ups_push_scp::send_n_get_response ( network::association & assoc, uint8_t context_id, uint16_t message_id, const std::string & sop_instance_uid, network::dimse::status_code status, core::dicom_dataset * dataset = nullptr )

nodiscardprivate

Definition at line 539 of file ups_push_scp.cpp.

                                {
 
    using namespace network::dimse;
 
    auto response = make_n_get_rsp(
        message_id, ups_push_sop_class_uid, sop_instance_uid, status);
 
    if (dataset != nullptr) {
        response.set_dataset(std::move(*dataset));
    }
 
    return assoc.send_dimse(context_id, response);
}

References kcenon::pacs::network::association::send_dimse(), and kcenon::pacs::services::ups_push_sop_class_uid.

Referenced by handle_n_get().

Here is the call graph for this function:

Here is the caller graph for this function:

send_n_set_response()

network::Result< std::monostate > kcenon::pacs::services::ups_push_scp::send_n_set_response ( network::association & assoc, uint8_t context_id, uint16_t message_id, const std::string & sop_instance_uid, network::dimse::status_code status )

nodiscardprivate

Definition at line 518 of file ups_push_scp.cpp.

                                    {
 
    using namespace network::dimse;
 
    dimse_message response{command_field::n_set_rsp, 0};
    response.set_message_id_responded_to(message_id);
    response.set_affected_sop_class_uid(ups_push_sop_class_uid);
    response.set_status(status);
 
    if (!sop_instance_uid.empty()) {
        response.set_affected_sop_instance_uid(sop_instance_uid);
    }
 
    return assoc.send_dimse(context_id, response);
}

References kcenon::pacs::network::association::send_dimse(), and kcenon::pacs::services::ups_push_sop_class_uid.

Referenced by handle_n_set().

Here is the call graph for this function:

Here is the caller graph for this function:

service_name()

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

nodiscardoverridevirtualnoexcept

Get the service name for logging/debugging.

Returns

Human-readable service name

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

Definition at line 84 of file ups_push_scp.cpp.

                                                         {
    return "UPS Push SCP";
}

set_change_state_handler()

void kcenon::pacs::services::ups_push_scp::set_change_state_handler

(

ups_change_state_handler

handler

)

Definition at line 40 of file ups_push_scp.cpp.

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

References change_state_handler_.

set_create_handler()

void kcenon::pacs::services::ups_push_scp::set_create_handler

(

ups_create_handler

handler

)

Definition at line 28 of file ups_push_scp.cpp.

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

References create_handler_.

set_get_handler()

void kcenon::pacs::services::ups_push_scp::set_get_handler

(

ups_get_handler

handler

)

Definition at line 36 of file ups_push_scp.cpp.

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

References get_handler_.

set_request_cancel_handler()

void kcenon::pacs::services::ups_push_scp::set_request_cancel_handler

(

ups_request_cancel_handler

handler

)

Definition at line 44 of file ups_push_scp.cpp.

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

References request_cancel_handler_.

set_set_handler()

void kcenon::pacs::services::ups_push_scp::set_set_handler

(

ups_set_handler

handler

)

Definition at line 32 of file ups_push_scp.cpp.

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

References set_handler_.

sets_processed()

size_t kcenon::pacs::services::ups_push_scp::sets_processed ( ) const

nodiscardnoexcept

Definition at line 96 of file ups_push_scp.cpp.

                                                   {
    return sets_processed_.load();
}

References sets_processed_.

state_changes()

size_t kcenon::pacs::services::ups_push_scp::state_changes ( ) const

nodiscardnoexcept

Definition at line 108 of file ups_push_scp.cpp.

                                                  {
    return state_changes_.load();
}

References state_changes_.

supported_sop_classes()

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

nodiscardoverridevirtual

Get the list of SOP Class UIDs supported by this service.

Returns

Vector of SOP Class UIDs that this service can handle

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

Definition at line 52 of file ups_push_scp.cpp.

                                                               {
    return {std::string(ups_push_sop_class_uid)};
}

References kcenon::pacs::services::ups_push_sop_class_uid.

Member Data Documentation

actions_processed_

std::atomic<size_t> kcenon::pacs::services::ups_push_scp::actions_processed_ {0}

private

Definition at line 290 of file ups_push_scp.h.

{0};

Referenced by actions_processed(), handle_n_action(), and reset_statistics().

cancel_requests_

std::atomic<size_t> kcenon::pacs::services::ups_push_scp::cancel_requests_ {0}

private

Definition at line 292 of file ups_push_scp.h.

{0};

Referenced by cancel_requests(), handle_n_action(), and reset_statistics().

change_state_handler_

ups_change_state_handler kcenon::pacs::services::ups_push_scp::change_state_handler_

private

Definition at line 284 of file ups_push_scp.h.

Referenced by handle_n_action(), and set_change_state_handler().

create_handler_

ups_create_handler kcenon::pacs::services::ups_push_scp::create_handler_

private

Definition at line 281 of file ups_push_scp.h.

Referenced by handle_n_create(), and set_create_handler().

creates_processed_

std::atomic<size_t> kcenon::pacs::services::ups_push_scp::creates_processed_ {0}

private

Definition at line 287 of file ups_push_scp.h.

{0};

Referenced by creates_processed(), handle_n_create(), and reset_statistics().

get_handler_

ups_get_handler kcenon::pacs::services::ups_push_scp::get_handler_

private

Definition at line 283 of file ups_push_scp.h.

Referenced by handle_n_get(), and set_get_handler().

gets_processed_

std::atomic<size_t> kcenon::pacs::services::ups_push_scp::gets_processed_ {0}

private

Definition at line 289 of file ups_push_scp.h.

{0};

Referenced by gets_processed(), handle_n_get(), and reset_statistics().

request_cancel_handler_

ups_request_cancel_handler kcenon::pacs::services::ups_push_scp::request_cancel_handler_

private

Definition at line 285 of file ups_push_scp.h.

Referenced by handle_n_action(), and set_request_cancel_handler().

set_handler_

ups_set_handler kcenon::pacs::services::ups_push_scp::set_handler_

private

Definition at line 282 of file ups_push_scp.h.

Referenced by handle_n_set(), and set_set_handler().

sets_processed_

std::atomic<size_t> kcenon::pacs::services::ups_push_scp::sets_processed_ {0}

private

Definition at line 288 of file ups_push_scp.h.

{0};

Referenced by handle_n_set(), reset_statistics(), and sets_processed().

state_changes_

std::atomic<size_t> kcenon::pacs::services::ups_push_scp::state_changes_ {0}

private

Definition at line 291 of file ups_push_scp.h.

{0};

Referenced by handle_n_action(), reset_statistics(), and state_changes().

---

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

• include/kcenon/pacs/services/ups/ups_push_scp.h
• src/services/ups/ups_push_scp.cpp