kcenon::pacs::services::ups_watch_scp Class Reference

UPS Watch SCP service for subscription and event notification. More...

#include <ups_watch_scp.h>

Inheritance diagram for kcenon::pacs::services::ups_watch_scp:

Collaboration diagram for kcenon::pacs::services::ups_watch_scp:

Public Member Functions
	ups_watch_scp (std::shared_ptr< di::ILogger > logger=nullptr)
	Construct UPS Watch SCP with optional logger.
	~ups_watch_scp () override=default
void	set_subscribe_handler (ups_subscribe_handler handler)
void	set_unsubscribe_handler (ups_unsubscribe_handler handler)
void	set_get_subscribers_handler (ups_get_subscribers_handler handler)
void	set_event_callback (ups_event_callback callback)
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.
void	notify_state_change (const std::string &workitem_uid, const std::string &new_state)
	Notify subscribers of a workitem state change.
void	notify_cancel_requested (const std::string &workitem_uid, const std::string &reason)
	Notify subscribers of a cancel request.
void	notify_progress (const std::string &workitem_uid, int progress_percent)
	Notify subscribers of progress update.
size_t	subscriptions_created () const noexcept
size_t	subscriptions_removed () const noexcept
size_t	events_sent () 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_action (network::association &assoc, uint8_t context_id, const network::dimse::dimse_message &request)
network::Result< std::monostate >	handle_subscribe (network::association &assoc, uint8_t context_id, uint16_t message_id, const std::string &sop_instance_uid)
network::Result< std::monostate >	handle_unsubscribe (network::association &assoc, uint8_t context_id, uint16_t message_id, const std::string &sop_instance_uid)
network::Result< std::monostate >	handle_suspend_global (network::association &assoc, uint8_t context_id, uint16_t message_id)
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)
void	dispatch_event (uint16_t event_type_id, const std::string &workitem_uid, const core::dicom_dataset &event_info)

Private Attributes
ups_subscribe_handler	subscribe_handler_
ups_unsubscribe_handler	unsubscribe_handler_
ups_get_subscribers_handler	get_subscribers_handler_
ups_event_callback	event_callback_
std::atomic< size_t >	subscriptions_created_ {0}
std::atomic< size_t >	subscriptions_removed_ {0}
std::atomic< size_t >	events_sent_ {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

UPS Watch SCP service for subscription and event notification.

The UPS Watch SCP handles subscribe/unsubscribe N-ACTION requests and provides event notification infrastructure. When workitem state changes occur (triggered externally, e.g., by UPS Push SCP), the Watch SCP notifies all relevant subscribers via the event callback.

UPS Watch Message Flow

Subscriber (SCU)                     UPS Watch SCP
 |                                   |
 |  N-ACTION-RQ (Subscribe, Type 3)  |
 |  WorkitemUID: 1.2.3.4...         |
 |---------------------------------->|
 |  N-ACTION-RSP (Success)           |
 |<----------------------------------|
 |                                   |
 |  [Workitem state changes]         |
 |                                   |
 |  N-EVENT-REPORT-RQ (Type 1)       |
 |  State: COMPLETED                |
 |<----------------------------------|
 |  N-EVENT-REPORT-RSP               |
 |---------------------------------->|
 |                                   |
 |  N-ACTION-RQ (Unsubscribe, Type 4)|
 |---------------------------------->|
 |  N-ACTION-RSP (Success)           |
 |<----------------------------------|

Definition at line 174 of file ups_watch_scp.h.

Constructor & Destructor Documentation

ups_watch_scp()

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

explicit

Construct UPS Watch SCP with optional logger.

Parameters

logger

Logger instance (nullptr uses null_logger)

Definition at line 21 of file ups_watch_scp.cpp.

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

~ups_watch_scp()

kcenon::pacs::services::ups_watch_scp::~ups_watch_scp ( )

overridedefault

Member Function Documentation

dispatch_event()

void kcenon::pacs::services::ups_watch_scp::dispatch_event ( uint16_t event_type_id, const std::string & workitem_uid, const core::dicom_dataset & event_info )

private

Definition at line 361 of file ups_watch_scp.cpp.

                                         {
 
    if (!get_subscribers_handler_ || !event_callback_) {
        return;
    }
 
    // Get subscribers for this workitem
    auto subscribers_result = get_subscribers_handler_(workitem_uid);
    if (subscribers_result.is_err()) {
        logger_->warn("UPS Watch: Failed to get subscribers for " +
                         workitem_uid);
        return;
    }
 
    const auto& subscribers = subscribers_result.value();
 
    for (const auto& subscriber_ae : subscribers) {
        event_callback_(subscriber_ae, event_type_id,
                        workitem_uid, event_info);
        ++events_sent_;
    }
 
    if (!subscribers.empty()) {
        logger_->info("UPS Watch: Dispatched event type " +
                      std::to_string(event_type_id) + " to " +
                      std::to_string(subscribers.size()) +
                      " subscribers for workitem " + workitem_uid);
    }
}

References event_callback_, events_sent_, get_subscribers_handler_, and kcenon::pacs::services::scp_service::logger_.

Referenced by notify_cancel_requested(), notify_progress(), and notify_state_change().

Here is the caller graph for this function:

events_sent()

size_t kcenon::pacs::services::ups_watch_scp::events_sent ( ) const

nodiscardnoexcept

Definition at line 130 of file ups_watch_scp.cpp.

                                                 {
    return events_sent_.load();
}

References events_sent_.

handle_message()

network::Result< std::monostate > kcenon::pacs::services::ups_watch_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 55 of file ups_watch_scp.cpp.

                                              {
 
    using namespace network::dimse;
 
    if (request.command() != command_field::n_action_rq) {
        return kcenon::pacs::pacs_void_error(
            kcenon::pacs::error_codes::ups_unexpected_command,
            "Expected N-ACTION-RQ but received " +
            std::string(to_string(request.command())));
    }
 
    return handle_n_action(assoc, context_id, request);
}

References kcenon::pacs::network::dimse::dimse_message::command(), handle_n_action(), 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_watch_scp::handle_n_action ( network::association & assoc, uint8_t context_id, const network::dimse::dimse_message & request )

nodiscardprivate

Definition at line 144 of file ups_watch_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 (workitem UID or global subscription UID)
    auto sop_instance_uid = request.requested_sop_instance_uid();
    if (sop_instance_uid.empty()) {
        sop_instance_uid = request.affected_sop_instance_uid();
    }
 
    uint16_t action_id = action_type.value();
    uint16_t message_id = request.message_id();
 
    switch (action_id) {
        case ups_watch_action_subscribe:
            return handle_subscribe(
                assoc, context_id, message_id, sop_instance_uid);
 
        case ups_watch_action_unsubscribe:
            return handle_unsubscribe(
                assoc, context_id, message_id, sop_instance_uid);
 
        case ups_watch_action_suspend_global:
            return handle_suspend_global(
                assoc, context_id, message_id);
 
        default:
            return send_n_action_response(
                assoc, context_id, message_id,
                sop_instance_uid, action_id,
                status_error_no_such_action_type);
    }
}

References kcenon::pacs::network::dimse::dimse_message::action_type_id(), kcenon::pacs::network::dimse::dimse_message::affected_sop_instance_uid(), handle_subscribe(), handle_suspend_global(), handle_unsubscribe(), kcenon::pacs::network::dimse::dimse_message::message_id(), kcenon::pacs::pacs_void_error(), kcenon::pacs::network::dimse::dimse_message::requested_sop_instance_uid(), send_n_action_response(), kcenon::pacs::error_codes::ups_invalid_action_type, kcenon::pacs::services::ups_watch_action_subscribe, kcenon::pacs::services::ups_watch_action_suspend_global, and kcenon::pacs::services::ups_watch_action_unsubscribe.

Referenced by handle_message().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_subscribe()

network::Result< std::monostate > kcenon::pacs::services::ups_watch_scp::handle_subscribe ( network::association & assoc, uint8_t context_id, uint16_t message_id, const std::string & sop_instance_uid )

nodiscardprivate

Definition at line 193 of file ups_watch_scp.cpp.

                                       {
 
    using namespace network::dimse;
 
    if (!subscribe_handler_) {
        return kcenon::pacs::pacs_void_error(
            kcenon::pacs::error_codes::ups_handler_not_set,
            "No subscribe handler configured for UPS Watch SCP");
    }
 
    // Determine subscriber AE from the association
    std::string subscriber_ae{assoc.calling_ae()};
 
    // Determine if this is a global or workitem-specific subscription
    std::string workitem_uid;
    if (sop_instance_uid != ups_global_subscription_instance_uid) {
        workitem_uid = sop_instance_uid;
    }
 
    // Deletion lock defaults to false (could be extracted from dataset)
    bool deletion_lock = false;
 
    logger_->debug("UPS Watch: Subscribe request from " + subscriber_ae +
                   (workitem_uid.empty() ? " (global)" :
                    " for workitem " + workitem_uid));
 
    auto result = subscribe_handler_(subscriber_ae, workitem_uid, deletion_lock);
    if (result.is_err()) {
        return send_n_action_response(
            assoc, context_id, message_id,
            sop_instance_uid, ups_watch_action_subscribe,
            status_error_unable_to_process);
    }
 
    ++subscriptions_created_;
 
    logger_->info("UPS Watch: Subscription created for " + subscriber_ae);
 
    return send_n_action_response(
        assoc, context_id, message_id,
        sop_instance_uid, ups_watch_action_subscribe,
        status_success);
}

References kcenon::pacs::network::association::calling_ae(), kcenon::pacs::services::scp_service::logger_, kcenon::pacs::pacs_void_error(), send_n_action_response(), subscribe_handler_, subscriptions_created_, kcenon::pacs::services::ups_global_subscription_instance_uid, kcenon::pacs::error_codes::ups_handler_not_set, and kcenon::pacs::services::ups_watch_action_subscribe.

Referenced by handle_n_action().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_suspend_global()

network::Result< std::monostate > kcenon::pacs::services::ups_watch_scp::handle_suspend_global ( network::association & assoc, uint8_t context_id, uint16_t message_id )

nodiscardprivate

Definition at line 293 of file ups_watch_scp.cpp.

                         {
 
    using namespace network::dimse;
 
    if (!unsubscribe_handler_) {
        return kcenon::pacs::pacs_void_error(
            kcenon::pacs::error_codes::ups_handler_not_set,
            "No unsubscribe handler configured for UPS Watch SCP");
    }
 
    std::string subscriber_ae{assoc.calling_ae()};
 
    logger_->debug("UPS Watch: Suspend global subscription from " +
                   subscriber_ae);
 
    // Suspend global = unsubscribe from global (empty workitem_uid)
    auto result = unsubscribe_handler_(subscriber_ae, "");
    if (result.is_err()) {
        return send_n_action_response(
            assoc, context_id, message_id,
            std::string(ups_global_subscription_instance_uid),
            ups_watch_action_suspend_global,
            status_error_unable_to_process);
    }
 
    ++subscriptions_removed_;
 
    logger_->info("UPS Watch: Global subscription suspended for " +
                  subscriber_ae);
 
    return send_n_action_response(
        assoc, context_id, message_id,
        std::string(ups_global_subscription_instance_uid),
        ups_watch_action_suspend_global,
        status_success);
}

References kcenon::pacs::network::association::calling_ae(), kcenon::pacs::services::scp_service::logger_, kcenon::pacs::pacs_void_error(), send_n_action_response(), subscriptions_removed_, unsubscribe_handler_, kcenon::pacs::services::ups_global_subscription_instance_uid, kcenon::pacs::error_codes::ups_handler_not_set, and kcenon::pacs::services::ups_watch_action_suspend_global.

Referenced by handle_n_action().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_unsubscribe()

network::Result< std::monostate > kcenon::pacs::services::ups_watch_scp::handle_unsubscribe ( network::association & assoc, uint8_t context_id, uint16_t message_id, const std::string & sop_instance_uid )

nodiscardprivate

Definition at line 245 of file ups_watch_scp.cpp.

                                       {
 
    using namespace network::dimse;
 
    if (!unsubscribe_handler_) {
        return kcenon::pacs::pacs_void_error(
            kcenon::pacs::error_codes::ups_handler_not_set,
            "No unsubscribe handler configured for UPS Watch SCP");
    }
 
    std::string subscriber_ae{assoc.calling_ae()};
 
    // Determine if this is a global or workitem-specific unsubscription
    std::string workitem_uid;
    if (sop_instance_uid != ups_global_subscription_instance_uid) {
        workitem_uid = sop_instance_uid;
    }
 
    logger_->debug("UPS Watch: Unsubscribe request from " + subscriber_ae +
                   (workitem_uid.empty() ? " (global)" :
                    " for workitem " + workitem_uid));
 
    auto result = unsubscribe_handler_(subscriber_ae, workitem_uid);
    if (result.is_err()) {
        return send_n_action_response(
            assoc, context_id, message_id,
            sop_instance_uid, ups_watch_action_unsubscribe,
            status_error_unable_to_process);
    }
 
    ++subscriptions_removed_;
 
    logger_->info("UPS Watch: Subscription removed for " + subscriber_ae);
 
    return send_n_action_response(
        assoc, context_id, message_id,
        sop_instance_uid, ups_watch_action_unsubscribe,
        status_success);
}

References kcenon::pacs::network::association::calling_ae(), kcenon::pacs::services::scp_service::logger_, kcenon::pacs::pacs_void_error(), send_n_action_response(), subscriptions_removed_, unsubscribe_handler_, kcenon::pacs::services::ups_global_subscription_instance_uid, kcenon::pacs::error_codes::ups_handler_not_set, and kcenon::pacs::services::ups_watch_action_unsubscribe.

Referenced by handle_n_action().

Here is the call graph for this function:

Here is the caller graph for this function:

notify_cancel_requested()

void kcenon::pacs::services::ups_watch_scp::notify_cancel_requested	(	const std::string &	workitem_uid,
		const std::string &	reason )

Notify subscribers of a cancel request.

Parameters

workitem_uid	The workitem for which cancel was requested
reason	The cancellation reason (may be empty)

Definition at line 92 of file ups_watch_scp.cpp.

                             {
 
    core::dicom_dataset event_info;
    if (!reason.empty()) {
        event_info.set_string(
            ups_tags::reason_for_cancellation,
            encoding::vr_type::LT, reason);
    }
 
    dispatch_event(ups_event_cancel_requested, workitem_uid, event_info);
}

References dispatch_event(), kcenon::pacs::encoding::LT, kcenon::pacs::services::ups_tags::reason_for_cancellation, kcenon::pacs::core::dicom_dataset::set_string(), and kcenon::pacs::services::ups_event_cancel_requested.

Here is the call graph for this function:

notify_progress()

void kcenon::pacs::services::ups_watch_scp::notify_progress	(	const std::string &	workitem_uid,
		int	progress_percent )

Notify subscribers of progress update.

Parameters

workitem_uid	The workitem that reported progress
progress_percent	The progress percentage (0-100)

Definition at line 106 of file ups_watch_scp.cpp.

                          {
 
    core::dicom_dataset event_info;
    event_info.set_string(
        ups_tags::procedure_step_progress,
        encoding::vr_type::DS, std::to_string(progress_percent));
 
    dispatch_event(ups_event_progress_report, workitem_uid, event_info);
}

References dispatch_event(), kcenon::pacs::encoding::DS, kcenon::pacs::services::ups_tags::procedure_step_progress, kcenon::pacs::core::dicom_dataset::set_string(), and kcenon::pacs::services::ups_event_progress_report.

Here is the call graph for this function:

notify_state_change()

void kcenon::pacs::services::ups_watch_scp::notify_state_change	(	const std::string &	workitem_uid,
		const std::string &	new_state )

Notify subscribers of a workitem state change.

Looks up subscribers for the given workitem and dispatches UPS State Report events via the event callback.

Parameters

workitem_uid	The workitem that changed state
new_state	The new state string

Definition at line 80 of file ups_watch_scp.cpp.

                                {
 
    core::dicom_dataset event_info;
    event_info.set_string(
        ups_tags::procedure_step_state,
        encoding::vr_type::CS, new_state);
 
    dispatch_event(ups_event_state_report, workitem_uid, event_info);
}

References kcenon::pacs::encoding::CS, dispatch_event(), kcenon::pacs::services::ups_tags::procedure_step_state, kcenon::pacs::core::dicom_dataset::set_string(), and kcenon::pacs::services::ups_event_state_report.

Here is the call graph for this function:

reset_statistics()

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

noexcept

Definition at line 134 of file ups_watch_scp.cpp.

                                              {
    subscriptions_created_ = 0;
    subscriptions_removed_ = 0;
    events_sent_ = 0;
}

References events_sent_, subscriptions_created_, and subscriptions_removed_.

send_n_action_response()

network::Result< std::monostate > kcenon::pacs::services::ups_watch_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 337 of file ups_watch_scp.cpp.

                                    {
 
    using namespace network::dimse;
 
    auto response = make_n_action_rsp(
        message_id,
        ups_watch_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_watch_sop_class_uid.

Referenced by handle_n_action(), handle_subscribe(), handle_suspend_global(), and handle_unsubscribe().

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_watch_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 72 of file ups_watch_scp.cpp.

                                                          {
    return "UPS Watch SCP";
}

set_event_callback()

void kcenon::pacs::services::ups_watch_scp::set_event_callback

(

ups_event_callback

callback

)

Definition at line 41 of file ups_watch_scp.cpp.

                                                                  {
    event_callback_ = std::move(callback);
}

References event_callback_.

set_get_subscribers_handler()

void kcenon::pacs::services::ups_watch_scp::set_get_subscribers_handler

(

ups_get_subscribers_handler

handler

)

Definition at line 36 of file ups_watch_scp.cpp.

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

References get_subscribers_handler_.

set_subscribe_handler()

void kcenon::pacs::services::ups_watch_scp::set_subscribe_handler

(

ups_subscribe_handler

handler

)

Definition at line 28 of file ups_watch_scp.cpp.

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

References subscribe_handler_.

set_unsubscribe_handler()

void kcenon::pacs::services::ups_watch_scp::set_unsubscribe_handler

(

ups_unsubscribe_handler

handler

)

Definition at line 32 of file ups_watch_scp.cpp.

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

References unsubscribe_handler_.

subscriptions_created()

size_t kcenon::pacs::services::ups_watch_scp::subscriptions_created ( ) const

nodiscardnoexcept

Definition at line 122 of file ups_watch_scp.cpp.

                                                           {
    return subscriptions_created_.load();
}

References subscriptions_created_.

subscriptions_removed()

size_t kcenon::pacs::services::ups_watch_scp::subscriptions_removed ( ) const

nodiscardnoexcept

Definition at line 126 of file ups_watch_scp.cpp.

                                                           {
    return subscriptions_removed_.load();
}

References subscriptions_removed_.

supported_sop_classes()

std::vector< std::string > kcenon::pacs::services::ups_watch_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 49 of file ups_watch_scp.cpp.

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

References kcenon::pacs::services::ups_watch_sop_class_uid.

Member Data Documentation

event_callback_

ups_event_callback kcenon::pacs::services::ups_watch_scp::event_callback_

private

Definition at line 301 of file ups_watch_scp.h.

Referenced by dispatch_event(), and set_event_callback().

events_sent_

std::atomic<size_t> kcenon::pacs::services::ups_watch_scp::events_sent_ {0}

private

Definition at line 305 of file ups_watch_scp.h.

{0};

Referenced by dispatch_event(), events_sent(), and reset_statistics().

get_subscribers_handler_

ups_get_subscribers_handler kcenon::pacs::services::ups_watch_scp::get_subscribers_handler_

private

Definition at line 300 of file ups_watch_scp.h.

Referenced by dispatch_event(), and set_get_subscribers_handler().

subscribe_handler_

ups_subscribe_handler kcenon::pacs::services::ups_watch_scp::subscribe_handler_

private

Definition at line 298 of file ups_watch_scp.h.

Referenced by handle_subscribe(), and set_subscribe_handler().

subscriptions_created_

std::atomic<size_t> kcenon::pacs::services::ups_watch_scp::subscriptions_created_ {0}

private

Definition at line 303 of file ups_watch_scp.h.

{0};

Referenced by handle_subscribe(), reset_statistics(), and subscriptions_created().

subscriptions_removed_

std::atomic<size_t> kcenon::pacs::services::ups_watch_scp::subscriptions_removed_ {0}

private

Definition at line 304 of file ups_watch_scp.h.

{0};

Referenced by handle_suspend_global(), handle_unsubscribe(), reset_statistics(), and subscriptions_removed().

unsubscribe_handler_

ups_unsubscribe_handler kcenon::pacs::services::ups_watch_scp::unsubscribe_handler_

private

Definition at line 299 of file ups_watch_scp.h.

Referenced by handle_suspend_global(), handle_unsubscribe(), and set_unsubscribe_handler().

---

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

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