#include <worklist_scu.h>

Collaboration diagram for kcenon::pacs::services::worklist_scu:

Public Member Functions
	worklist_scu (std::shared_ptr< di::ILogger > logger=nullptr)
	Construct a Worklist SCU with default configuration.

	worklist_scu (const worklist_scu_config &config, std::shared_ptr< di::ILogger > logger=nullptr)
	Construct a Worklist SCU with custom configuration.

	~worklist_scu ()=default

	worklist_scu (const worklist_scu &)=delete

worklist_scu &	operator= (const worklist_scu &)=delete

	worklist_scu (worklist_scu &&)=delete

worklist_scu &	operator= (worklist_scu &&)=delete

network::Result< worklist_result >	query (network::association &assoc, const worklist_query_keys &keys)
	Perform a MWL C-FIND query with typed keys.

network::Result< worklist_result >	query (network::association &assoc, const core::dicom_dataset &query_keys)
	Perform a MWL C-FIND query with raw dataset.

network::Result< worklist_result >	query_today (network::association &assoc, std::string_view station_ae, std::string_view modality="")
	Query today's worklist for a station.

network::Result< worklist_result >	query_date_range (network::association &assoc, std::string_view start_date, std::string_view end_date, std::string_view modality="")
	Query worklist by date range.

network::Result< worklist_result >	query_patient (network::association &assoc, std::string_view patient_id)
	Query worklist by patient ID.

network::Result< size_t >	query_streaming (network::association &assoc, const worklist_query_keys &keys, worklist_streaming_callback callback)
	Perform a streaming MWL query for large worklists.

network::Result< std::monostate >	cancel (network::association &assoc, uint16_t message_id)
	Send a C-CANCEL request to stop an ongoing query.

void	set_config (const worklist_scu_config &config)
	Update the SCU configuration.

const worklist_scu_config &	config () const noexcept
	Get the current configuration.

size_t	queries_performed () const noexcept
	Get the number of queries performed since construction.

size_t	total_items () const noexcept
	Get the total number of items received since construction.

void	reset_statistics () noexcept
	Reset statistics counters to zero.

Private Member Functions
worklist_item	parse_worklist_item (const core::dicom_dataset &ds) const
	Parse a worklist item from a response dataset.

core::dicom_dataset	build_query_dataset (const worklist_query_keys &keys) const
	Build query dataset from typed keys.

uint16_t	next_message_id () noexcept
	Get the next message ID for DIMSE operations.

network::Result< worklist_result >	query_impl (network::association &assoc, const core::dicom_dataset &query_keys, uint16_t message_id)
	Internal query implementation.

Static Private Member Functions
static std::string	get_today_date ()
	Get today's date in DICOM format (YYYYMMDD)

Private Attributes
std::shared_ptr< di::ILogger >	logger_
	Logger instance for service logging.

worklist_scu_config	config_
	Configuration.

std::atomic< uint16_t >	message_id_counter_ {1}
	Message ID counter.

std::atomic< size_t >	queries_performed_ {0}
	Statistics: number of queries performed.

std::atomic< size_t >	total_items_ {0}
	Statistics: total number of items received.

Detailed Description

Examples: worklist_scu/main.cpp.

Definition at line 357 of file worklist_scu.h.

Constructor & Destructor Documentation

◆ worklist_scu() [1/4]

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

explicit

Construct a Worklist SCU with default configuration.

Parameters

logger Logger instance for service logging (nullptr uses null_logger)

Definition at line 31 of file worklist_scu.cpp.

32 : logger_(logger ? std::move(logger) : di::null_logger()) {}

kcenon::pacs::services::worklist_scu::logger_

std::shared_ptr< di::ILogger > logger_

Logger instance for service logging.

Definition worklist_scu.h:584

kcenon::pacs::di::null_logger

std::shared_ptr< ILogger > null_logger()

Get a shared null logger instance.

Definition ilogger.h:271

◆ worklist_scu() [2/4]

kcenon::pacs::services::worklist_scu::worklist_scu	(	const worklist_scu_config &	config,
		std::shared_ptr< di::ILogger >	logger = nullptr )

explicit

Construct a Worklist SCU with custom configuration.

Parameters

config	Configuration options
logger	Logger instance for service logging (nullptr uses null_logger)

Definition at line 34 of file worklist_scu.cpp.

36 : logger_(logger ? std::move(logger) : di::null_logger()), config_(config) {}

kcenon::pacs::services::worklist_scu::config

const worklist_scu_config & config() const noexcept

Get the current configuration.

Definition worklist_scu.cpp:361

kcenon::pacs::services::worklist_scu::config_

worklist_scu_config config_

Configuration.

Definition worklist_scu.h:587

◆ ~worklist_scu()

kcenon::pacs::services::worklist_scu::~worklist_scu ( )

default

◆ worklist_scu() [3/4]

kcenon::pacs::services::worklist_scu::worklist_scu ( const worklist_scu & )

delete

◆ worklist_scu() [4/4]

kcenon::pacs::services::worklist_scu::worklist_scu ( worklist_scu && )

delete

Member Function Documentation

◆ build_query_dataset()

core::dicom_dataset kcenon::pacs::services::worklist_scu::build_query_dataset ( const worklist_query_keys & keys ) const

nodiscardprivate

Build query dataset from typed keys.

Definition at line 441 of file worklist_scu.cpp.

                                           {
 
    using namespace core;
    using namespace encoding;
 
    dicom_dataset ds;
 
    // Patient demographics (return keys with optional search criteria)
    ds.set_string(tags::patient_name, vr_type::PN, keys.patient_name);
    ds.set_string(tags::patient_id, vr_type::LO, keys.patient_id);
 
    if (!keys.patient_birth_date.empty()) {
        ds.set_string(tags::patient_birth_date, vr_type::DA, keys.patient_birth_date);
    } else {
        ds.set_string(tags::patient_birth_date, vr_type::DA, "");
    }
 
    if (!keys.patient_sex.empty()) {
        ds.set_string(tags::patient_sex, vr_type::CS, keys.patient_sex);
    } else {
        ds.set_string(tags::patient_sex, vr_type::CS, "");
    }
 
    // Study-level return keys
    ds.set_string(tags::study_instance_uid, vr_type::UI, "");
    ds.set_string(tags::accession_number, vr_type::SH, keys.accession_number);
    ds.set_string(tags::referring_physician_name, vr_type::PN, keys.referring_physician);
    ds.set_string(tags::institution_name, vr_type::LO, keys.institution);
 
    // Requested Procedure attributes
    ds.set_string(tags::requested_procedure_id, vr_type::SH, keys.requested_procedure_id);
    ds.set_string(tags::study_description, vr_type::LO, keys.requested_procedure_description);
 
    // Scheduled Procedure Step attributes (flat structure)
    ds.set_string(tags::scheduled_station_ae_title, vr_type::AE, keys.scheduled_station_ae);
    ds.set_string(tags::scheduled_procedure_step_start_date, vr_type::DA, keys.scheduled_date);
    ds.set_string(tags::scheduled_procedure_step_start_time, vr_type::TM, keys.scheduled_time);
    ds.set_string(tags::modality, vr_type::CS, keys.modality);
    ds.set_string(tags::scheduled_performing_physician_name, vr_type::PN, keys.scheduled_physician);
    ds.set_string(tags::scheduled_procedure_step_id, vr_type::SH, keys.scheduled_procedure_step_id);
 
    // Additional return keys
    ds.set_string(tags::scheduled_procedure_step_description, vr_type::LO, "");
    ds.set_string(tags::scheduled_station_name, vr_type::SH, "");
    ds.set_string(tags::scheduled_procedure_step_location, vr_type::SH, "");
 
    return ds;
}

Referenced by query(), and query_streaming().

Here is the caller graph for this function:

◆ cancel()

network::Result< std::monostate > kcenon::pacs::services::worklist_scu::cancel	(	network::association &	assoc,
		uint16_t	message_id )

nodiscard

Send a C-CANCEL request to stop an ongoing query.

Parameters

assoc	The association on which the query is running
message_id	The message ID of the query to cancel

Returns: Success or error

Definition at line 335 of file worklist_scu.cpp.

                         {
 
    using namespace network::dimse;
 
    auto context_id = assoc.accepted_context_id(worklist_find_sop_class_uid);
    if (!context_id) {
        return kcenon::pacs::pacs_error<std::monostate>(
            kcenon::pacs::error_codes::no_acceptable_context,
            "No accepted presentation context for cancel");
    }
 
    // Build C-CANCEL-RQ
    dimse_message cancel_rq{command_field::c_cancel_rq, message_id};
    return assoc.send_dimse(*context_id, cancel_rq);
}

References kcenon::pacs::network::association::accepted_context_id(), kcenon::pacs::error_codes::no_acceptable_context, kcenon::pacs::pacs_error(), kcenon::pacs::network::association::send_dimse(), and kcenon::pacs::services::worklist_find_sop_class_uid.

Referenced by query_impl(), and query_streaming().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ config()

const worklist_scu_config & kcenon::pacs::services::worklist_scu::config ( ) const

nodiscardnoexcept

Get the current configuration.

Returns: Reference to the current configuration

Definition at line 361 of file worklist_scu.cpp.

                                                               {
    return config_;
}

References config_.

Referenced by set_config().

Here is the caller graph for this function:

◆ get_today_date()

std::string kcenon::pacs::services::worklist_scu::get_today_date ( )

staticnodiscardprivate

Get today's date in DICOM format (YYYYMMDD)

Definition at line 395 of file worklist_scu.cpp.

                                       {
    auto now = std::time(nullptr);
    auto* tm = std::localtime(&now);
    std::ostringstream oss;
    oss << std::put_time(tm, "%Y%m%d");
    return oss.str();
}

Referenced by query_today().

Here is the caller graph for this function:

◆ next_message_id()

uint16_t kcenon::pacs::services::worklist_scu::next_message_id ( )

nodiscardprivatenoexcept

Get the next message ID for DIMSE operations.

Definition at line 386 of file worklist_scu.cpp.

                                                {
    uint16_t id = message_id_counter_.fetch_add(1, std::memory_order_relaxed);
    // Wrap around at 0xFFFF, skip 0 (reserved)
    if (id == 0) {
        id = message_id_counter_.fetch_add(1, std::memory_order_relaxed);
    }
    return id;
}

References message_id_counter_.

Referenced by query(), and query_streaming().

Here is the caller graph for this function:

◆ operator=() [1/2]

worklist_scu & kcenon::pacs::services::worklist_scu::operator= ( const worklist_scu & )

delete

◆ operator=() [2/2]

worklist_scu & kcenon::pacs::services::worklist_scu::operator= ( worklist_scu && )

delete

◆ parse_worklist_item()

worklist_item kcenon::pacs::services::worklist_scu::parse_worklist_item ( const core::dicom_dataset & ds ) const

nodiscardprivate

Parse a worklist item from a response dataset.

Definition at line 403 of file worklist_scu.cpp.

                                       {
 
    using namespace core;
 
    worklist_item item;
 
    // Patient demographics
    item.patient_name = ds.get_string(tags::patient_name);
    item.patient_id = ds.get_string(tags::patient_id);
    item.patient_birth_date = ds.get_string(tags::patient_birth_date);
    item.patient_sex = ds.get_string(tags::patient_sex);
 
    // Study-level attributes
    item.study_instance_uid = ds.get_string(tags::study_instance_uid);
    item.accession_number = ds.get_string(tags::accession_number);
    item.referring_physician = ds.get_string(tags::referring_physician_name);
    item.institution = ds.get_string(tags::institution_name);
 
    // Requested Procedure attributes
    item.requested_procedure_id = ds.get_string(tags::requested_procedure_id);
    item.requested_procedure_description = ds.get_string(tags::study_description);
 
    // Scheduled Procedure Step attributes (flat structure)
    item.scheduled_station_ae = ds.get_string(tags::scheduled_station_ae_title);
    item.modality = ds.get_string(tags::modality);
    item.scheduled_date = ds.get_string(tags::scheduled_procedure_step_start_date);
    item.scheduled_time = ds.get_string(tags::scheduled_procedure_step_start_time);
    item.scheduled_procedure_step_id = ds.get_string(tags::scheduled_procedure_step_id);
    item.scheduled_procedure_step_description =
        ds.get_string(tags::scheduled_procedure_step_description);
 
    // Store original dataset for full access
    item.dataset = ds;
 
    return item;
}

Referenced by query_impl(), and query_streaming().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ queries_performed()

size_t kcenon::pacs::services::worklist_scu::queries_performed ( ) const

nodiscardnoexcept

Get the number of queries performed since construction.

Returns: Count of C-FIND requests sent

Examples: worklist_scu/main.cpp.

Definition at line 369 of file worklist_scu.cpp.

                                                      {
    return queries_performed_.load(std::memory_order_relaxed);
}

References queries_performed_.

◆ query() [1/2]

network::Result< worklist_result > kcenon::pacs::services::worklist_scu::query	(	network::association &	assoc,
		const core::dicom_dataset &	query_keys )

nodiscard

Perform a MWL C-FIND query with raw dataset.

Sends a C-FIND request with the provided raw query dataset. Use this when you need full control over the query attributes.

Parameters

assoc	The established association to use
query_keys	The DICOM dataset containing query keys

Returns: Result containing worklist_result on success, or error message

Definition at line 50 of file worklist_scu.cpp.

                                         {
 
    return query_impl(assoc, query_keys, next_message_id());
}

References next_message_id(), and query_impl().

Here is the call graph for this function:

◆ query() [2/2]

network::Result< worklist_result > kcenon::pacs::services::worklist_scu::query	(	network::association &	assoc,
		const worklist_query_keys &	keys )

nodiscard

Perform a MWL C-FIND query with typed keys.

Sends a C-FIND request with the provided query keys and collects all matching worklist items from the SCP.

Parameters

assoc	The established association to use
keys	The typed query keys for filtering

Returns: Result containing worklist_result on success, or error message

Examples: worklist_scu/main.cpp.

Definition at line 42 of file worklist_scu.cpp.

                                     {
 
    auto query_ds = build_query_dataset(keys);
    return query(assoc, query_ds);
}

References build_query_dataset(), and query().

Referenced by query(), query_date_range(), query_patient(), and query_today().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ query_date_range()

network::Result< worklist_result > kcenon::pacs::services::worklist_scu::query_date_range	(	network::association &	assoc,
		std::string_view	start_date,
		std::string_view	end_date,
		std::string_view	modality = "" )

nodiscard

Query worklist by date range.

Query scheduled procedures within a date range, optionally filtered by modality.

Parameters

assoc	The established association to use
start_date	Start date in YYYYMMDD format
end_date	End date in YYYYMMDD format
modality	Modality filter (empty = any)

Returns: Result containing worklist_result on success

Definition at line 192 of file worklist_scu.cpp.

                             {
 
    worklist_query_keys keys;
    // DICOM date range format: YYYYMMDD-YYYYMMDD
    keys.scheduled_date = std::string(start_date) + "-" + std::string(end_date);
    keys.modality = std::string(modality);
 
    return query(assoc, keys);
}

References kcenon::pacs::services::worklist_query_keys::modality, query(), and kcenon::pacs::services::worklist_query_keys::scheduled_date.

Here is the call graph for this function:

◆ query_impl()

network::Result< worklist_result > kcenon::pacs::services::worklist_scu::query_impl	(	network::association &	assoc,
		const core::dicom_dataset &	query_keys,
		uint16_t	message_id )

nodiscardprivate

Internal query implementation.

Definition at line 57 of file worklist_scu.cpp.

                         {
 
    using namespace network::dimse;
 
    auto start_time = std::chrono::steady_clock::now();
 
    // Verify association is established
    if (!assoc.is_established()) {
        return kcenon::pacs::pacs_error<worklist_result>(
            kcenon::pacs::error_codes::association_not_established,
            "Association not established");
    }
 
    // Get accepted presentation context for MWL
    auto context_id = assoc.accepted_context_id(worklist_find_sop_class_uid);
    if (!context_id) {
        return kcenon::pacs::pacs_error<worklist_result>(
            kcenon::pacs::error_codes::no_acceptable_context,
            "No accepted presentation context for Modality Worklist: " +
            std::string(worklist_find_sop_class_uid));
    }
 
    // Build C-FIND-RQ message
    auto request = make_c_find_rq(message_id, worklist_find_sop_class_uid);
    request.set_dataset(query_keys);
 
    logger_->debug_fmt("Sending MWL C-FIND request (message_id={})", message_id);
 
    // Send the request
    auto send_result = assoc.send_dimse(*context_id, request);
    if (send_result.is_err()) {
        return send_result.error();
    }
 
    // Receive responses
    worklist_result result;
    bool query_complete = false;
 
    while (!query_complete) {
        auto recv_result = assoc.receive_dimse(config_.timeout);
        if (recv_result.is_err()) {
            return recv_result.error();
        }
 
        const auto& [recv_context_id, response] = recv_result.value();
 
        // Verify it's a C-FIND response
        if (response.command() != command_field::c_find_rsp) {
            return kcenon::pacs::pacs_error<worklist_result>(
                kcenon::pacs::error_codes::find_unexpected_command,
                "Expected C-FIND-RSP but received " +
                std::string(to_string(response.command())));
        }
 
        auto status = response.status();
 
        if (status == status_pending || status == status_pending_warning) {
            ++result.total_pending;
 
            if (response.has_dataset()) {
                // Check if we should collect this result
                if (config_.max_results == 0 ||
                    result.items.size() < config_.max_results) {
 
                    auto dataset_result = response.dataset();
                    if (dataset_result.is_ok()) {
                        result.items.push_back(
                            parse_worklist_item(dataset_result.value().get()));
                    }
                }
 
                // Check if we should cancel due to max_results
                if (config_.max_results > 0 &&
                    result.items.size() >= config_.max_results &&
                    config_.cancel_on_max) {
 
                    logger_->debug_fmt(
                        "Max results ({}) reached, sending C-CANCEL",
                        config_.max_results);
 
                    // Send C-CANCEL
                    auto cancel_result = cancel(assoc, message_id);
                    if (cancel_result.is_err()) {
                        logger_->warn_fmt("Failed to send C-CANCEL: {}",
                                          cancel_result.error().message);
                    }
                }
            }
        } else if (status == status_success) {
            query_complete = true;
            result.status = static_cast<uint16_t>(status);
        } else if (status == status_cancel) {
            query_complete = true;
            result.status = static_cast<uint16_t>(status);
        } else {
            // Error status
            query_complete = true;
            result.status = static_cast<uint16_t>(status);
        }
    }
 
    auto end_time = std::chrono::steady_clock::now();
    result.elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
        end_time - start_time);
 
    // Update statistics
    queries_performed_.fetch_add(1, std::memory_order_relaxed);
    total_items_.fetch_add(result.items.size(), std::memory_order_relaxed);
 
    logger_->debug_fmt("MWL C-FIND completed: {} items in {} ms",
                       result.items.size(), result.elapsed.count());
 
    return result;
}

Referenced by query().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ query_patient()

network::Result< worklist_result > kcenon::pacs::services::worklist_scu::query_patient	(	network::association &	assoc,
		std::string_view	patient_id )

nodiscard

Query worklist by patient ID.

Query all scheduled procedures for a specific patient.

Parameters

assoc	The established association to use
patient_id	The patient ID to query

Returns: Result containing worklist_result on success

Definition at line 206 of file worklist_scu.cpp.

                               {
 
    worklist_query_keys keys;
    keys.patient_id = std::string(patient_id);
 
    return query(assoc, keys);
}

References kcenon::pacs::services::worklist_query_keys::patient_id, and query().

Here is the call graph for this function:

◆ query_streaming()

network::Result< size_t > kcenon::pacs::services::worklist_scu::query_streaming	(	network::association &	assoc,
		const worklist_query_keys &	keys,
		worklist_streaming_callback	callback )

nodiscard

Perform a streaming MWL query for large worklists.

Sends a C-FIND request and calls the callback for each pending response. This is more memory-efficient for large worklists.

Parameters

assoc	The established association to use
keys	The typed query keys for filtering
callback	Called for each worklist item; return false to cancel

Returns: Result containing the number of items processed, or error

Definition at line 220 of file worklist_scu.cpp.

                                          {
 
    using namespace network::dimse;
 
    auto message_id = next_message_id();
    auto start_time = std::chrono::steady_clock::now();
 
    // Verify association is established
    if (!assoc.is_established()) {
        return kcenon::pacs::pacs_error<size_t>(
            kcenon::pacs::error_codes::association_not_established,
            "Association not established");
    }
 
    // Get accepted presentation context for MWL
    auto context_id = assoc.accepted_context_id(worklist_find_sop_class_uid);
    if (!context_id) {
        return kcenon::pacs::pacs_error<size_t>(
            kcenon::pacs::error_codes::no_acceptable_context,
            "No accepted presentation context for Modality Worklist");
    }
 
    // Build query dataset and C-FIND-RQ message
    auto query_ds = build_query_dataset(keys);
    auto request = make_c_find_rq(message_id, worklist_find_sop_class_uid);
    request.set_dataset(query_ds);
 
    logger_->debug_fmt("Sending streaming MWL C-FIND request (message_id={})",
                       message_id);
 
    // Send the request
    auto send_result = assoc.send_dimse(*context_id, request);
    if (send_result.is_err()) {
        return send_result.error();
    }
 
    // Receive responses
    size_t count = 0;
    bool query_complete = false;
    bool should_cancel = false;
 
    while (!query_complete) {
        auto recv_result = assoc.receive_dimse(config_.timeout);
        if (recv_result.is_err()) {
            return recv_result.error();
        }
 
        const auto& [recv_context_id, response] = recv_result.value();
 
        // Verify it's a C-FIND response
        if (response.command() != command_field::c_find_rsp) {
            return kcenon::pacs::pacs_error<size_t>(
                kcenon::pacs::error_codes::find_unexpected_command,
                "Expected C-FIND-RSP but received " +
                std::string(to_string(response.command())));
        }
 
        auto status = response.status();
 
        if (status == status_pending || status == status_pending_warning) {
            if (response.has_dataset()) {
                auto dataset_result = response.dataset();
                if (dataset_result.is_ok()) {
                    ++count;
                    auto item = parse_worklist_item(dataset_result.value().get());
 
                    // Call the callback
                    if (callback) {
                        if (!callback(item)) {
                            should_cancel = true;
                        }
                    }
 
                    // Check if we need to cancel
                    if (should_cancel ||
                        (config_.max_results > 0 &&
                         count >= config_.max_results &&
                         config_.cancel_on_max)) {
 
                        logger_->debug("Cancelling streaming MWL query");
                        auto cancel_result = cancel(assoc, message_id);
                        if (cancel_result.is_err()) {
                            logger_->warn_fmt("Failed to send C-CANCEL: {}",
                                              cancel_result.error().message);
                        }
                        should_cancel = false;  // Already sent cancel
                    }
                }
            }
        } else {
            query_complete = true;
        }
    }
 
    // Update statistics
    queries_performed_.fetch_add(1, std::memory_order_relaxed);
    total_items_.fetch_add(count, std::memory_order_relaxed);
 
    auto end_time = std::chrono::steady_clock::now();
    auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
        end_time - start_time);
 
    logger_->debug_fmt("Streaming MWL C-FIND completed: {} items in {} ms",
                       count, elapsed.count());
 
    return count;
}

References kcenon::pacs::network::association::accepted_context_id(), kcenon::pacs::error_codes::association_not_established, build_query_dataset(), cancel(), kcenon::pacs::services::worklist_scu_config::cancel_on_max, config_, kcenon::pacs::error_codes::find_unexpected_command, kcenon::pacs::network::association::is_established(), logger_, kcenon::pacs::services::worklist_scu_config::max_results, next_message_id(), kcenon::pacs::error_codes::no_acceptable_context, kcenon::pacs::pacs_error(), parse_worklist_item(), queries_performed_, kcenon::pacs::network::association::receive_dimse(), kcenon::pacs::network::association::send_dimse(), kcenon::pacs::services::worklist_scu_config::timeout, kcenon::pacs::services::to_string(), total_items_, and kcenon::pacs::services::worklist_find_sop_class_uid.

Here is the call graph for this function:

◆ query_today()

network::Result< worklist_result > kcenon::pacs::services::worklist_scu::query_today	(	network::association &	assoc,
		std::string_view	station_ae,
		std::string_view	modality = "" )

nodiscard

Query today's worklist for a station.

Convenience method to query scheduled procedures for today, optionally filtered by station AE title and modality.

Parameters

assoc	The established association to use
station_ae	Scheduled Station AE Title (empty = any)
modality	Modality filter (empty = any)

Returns: Result containing worklist_result on success

Definition at line 179 of file worklist_scu.cpp.

                             {
 
    worklist_query_keys keys;
    keys.scheduled_station_ae = std::string(station_ae);
    keys.modality = std::string(modality);
    keys.scheduled_date = get_today_date();
 
    return query(assoc, keys);
}

References get_today_date(), kcenon::pacs::services::worklist_query_keys::modality, query(), kcenon::pacs::services::worklist_query_keys::scheduled_date, and kcenon::pacs::services::worklist_query_keys::scheduled_station_ae.

Here is the call graph for this function:

◆ reset_statistics()

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

noexcept

Reset statistics counters to zero.

Definition at line 377 of file worklist_scu.cpp.

                                             {
    queries_performed_.store(0, std::memory_order_relaxed);
    total_items_.store(0, std::memory_order_relaxed);
}

References queries_performed_, and total_items_.

◆ set_config()

void kcenon::pacs::services::worklist_scu::set_config ( const worklist_scu_config & config )

Update the SCU configuration.

Parameters

config New configuration options

Definition at line 357 of file worklist_scu.cpp.

                                                               {
    config_ = config;
}

References config(), and config_.

Here is the call graph for this function:

◆ total_items()

size_t kcenon::pacs::services::worklist_scu::total_items ( ) const

nodiscardnoexcept

Get the total number of items received since construction.

Returns: Total count of worklist items received

Examples: worklist_scu/main.cpp.

Definition at line 373 of file worklist_scu.cpp.

                                                {
    return total_items_.load(std::memory_order_relaxed);
}

References total_items_.

Member Data Documentation

◆ config_

worklist_scu_config kcenon::pacs::services::worklist_scu::config_

private

Configuration.

Definition at line 587 of file worklist_scu.h.

Referenced by config(), query_impl(), query_streaming(), and set_config().

◆ logger_

std::shared_ptr<di::ILogger> kcenon::pacs::services::worklist_scu::logger_

private

Logger instance for service logging.

Definition at line 584 of file worklist_scu.h.

Referenced by query_impl(), and query_streaming().

◆ message_id_counter_

std::atomic<uint16_t> kcenon::pacs::services::worklist_scu::message_id_counter_ {1}

private

Message ID counter.

Definition at line 590 of file worklist_scu.h.

590{1};

Referenced by next_message_id().

◆ queries_performed_

std::atomic<size_t> kcenon::pacs::services::worklist_scu::queries_performed_ {0}

private

Statistics: number of queries performed.

Definition at line 593 of file worklist_scu.h.

593{0};

Referenced by queries_performed(), query_impl(), query_streaming(), and reset_statistics().

◆ total_items_

std::atomic<size_t> kcenon::pacs::services::worklist_scu::total_items_ {0}

private

Statistics: total number of items received.

Definition at line 596 of file worklist_scu.h.

596{0};

Referenced by query_impl(), query_streaming(), reset_statistics(), and total_items().

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

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

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ worklist_scu() [1/4]

◆ worklist_scu() [2/4]

◆ ~worklist_scu()

◆ worklist_scu() [3/4]

◆ worklist_scu() [4/4]

Member Function Documentation

◆ build_query_dataset()

◆ cancel()

◆ config()

◆ get_today_date()

◆ next_message_id()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ parse_worklist_item()

◆ queries_performed()

◆ query() [1/2]

◆ query() [2/2]

◆ query_date_range()

◆ query_impl()

◆ query_patient()

◆ query_streaming()

◆ query_today()

◆ reset_statistics()

◆ set_config()

◆ total_items()

Member Data Documentation

◆ config_

◆ logger_

◆ message_id_counter_

◆ queries_performed_

◆ total_items_