#include <storage_scu.h>

Collaboration diagram for kcenon::pacs::services::storage_scu:

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

	storage_scu (const storage_scu_config &config, std::shared_ptr< di::ILogger > logger=nullptr)
	Construct a Storage SCU with custom configuration.

	~storage_scu ()=default

	storage_scu (const storage_scu &)=delete

storage_scu &	operator= (const storage_scu &)=delete

	storage_scu (storage_scu &&)=delete

storage_scu &	operator= (storage_scu &&)=delete

network::Result< store_result >	store (network::association &assoc, const core::dicom_dataset &dataset)
	Store a single DICOM dataset.

std::vector< store_result >	store_batch (network::association &assoc, const std::vector< core::dicom_dataset > &datasets, store_progress_callback progress_callback=nullptr)
	Store multiple DICOM datasets.

network::Result< store_result >	store_file (network::association &assoc, const std::filesystem::path &file_path)
	Store a DICOM file.

std::vector< store_result >	store_files (network::association &assoc, const std::vector< std::filesystem::path > &file_paths, store_progress_callback progress_callback=nullptr)
	Store multiple DICOM files.

std::vector< store_result >	store_directory (network::association &assoc, const std::filesystem::path &directory, bool recursive=true, store_progress_callback progress_callback=nullptr)
	Store all DICOM files in a directory.

size_t	images_sent () const noexcept
	Get the number of images sent since construction.

size_t	failures () const noexcept
	Get the number of failed store operations since construction.

size_t	bytes_sent () const noexcept
	Get the total bytes sent since construction.

void	reset_statistics () noexcept
	Reset statistics counters to zero.

Private Member Functions
network::Result< store_result >	store_impl (network::association &assoc, const core::dicom_dataset &dataset, uint16_t message_id)
	Internal implementation of single store operation.

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

std::vector< std::filesystem::path >	collect_dicom_files (const std::filesystem::path &directory, bool recursive) const
	Collect DICOM files from a directory.

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

storage_scu_config	config_
	Configuration.

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

std::atomic< size_t >	images_sent_ {0}
	Statistics: number of images sent successfully.

std::atomic< size_t >	failures_ {0}
	Statistics: number of failed operations.

std::atomic< size_t >	bytes_sent_ {0}
	Statistics: total bytes sent.

Detailed Description

Definition at line 167 of file storage_scu.h.

Constructor & Destructor Documentation

◆ storage_scu() [1/4]

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

explicit

Construct a Storage SCU with default configuration.

Parameters

logger Logger instance for service logging (nullptr uses null_logger)

Definition at line 56 of file storage_scu.cpp.

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

kcenon::pacs::services::storage_scu::logger_

std::shared_ptr< di::ILogger > logger_

Logger instance for service logging.

Definition storage_scu.h:343

kcenon::pacs::di::null_logger

std::shared_ptr< ILogger > null_logger()

Get a shared null logger instance.

Definition ilogger.h:271

◆ storage_scu() [2/4]

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

explicit

Construct a Storage SCU with custom configuration.

Parameters

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

Definition at line 59 of file storage_scu.cpp.

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

kcenon::pacs::services::storage_scu::config_

storage_scu_config config_

Configuration.

Definition storage_scu.h:346

◆ ~storage_scu()

kcenon::pacs::services::storage_scu::~storage_scu ( )

default

◆ storage_scu() [3/4]

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

delete

◆ storage_scu() [4/4]

kcenon::pacs::services::storage_scu::storage_scu ( storage_scu && )

delete

Member Function Documentation

◆ bytes_sent()

size_t kcenon::pacs::services::storage_scu::bytes_sent ( ) const

nodiscardnoexcept

Get the total bytes sent since construction.

Returns: Total bytes of dataset data sent

Definition at line 357 of file storage_scu.cpp.

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

References bytes_sent_.

◆ collect_dicom_files()

std::vector< std::filesystem::path > kcenon::pacs::services::storage_scu::collect_dicom_files	(	const std::filesystem::path &	directory,
		bool	recursive ) const

nodiscardprivate

Collect DICOM files from a directory.

Definition at line 312 of file storage_scu.cpp.

                          {
 
    std::vector<std::filesystem::path> files;
 
    if (!std::filesystem::exists(directory) ||
        !std::filesystem::is_directory(directory)) {
        return files;
    }
 
    if (recursive) {
        for (const auto& entry :
             std::filesystem::recursive_directory_iterator(directory)) {
            if (entry.is_regular_file() && is_dicom_file(entry.path())) {
                files.push_back(entry.path());
            }
        }
    } else {
        for (const auto& entry :
             std::filesystem::directory_iterator(directory)) {
            if (entry.is_regular_file() && is_dicom_file(entry.path())) {
                files.push_back(entry.path());
            }
        }
    }
 
    // Sort files for deterministic order
    std::sort(files.begin(), files.end());
 
    return files;
}

Referenced by store_directory().

Here is the caller graph for this function:

◆ failures()

size_t kcenon::pacs::services::storage_scu::failures ( ) const

nodiscardnoexcept

Get the number of failed store operations since construction.

Returns: Count of failed operations

Definition at line 353 of file storage_scu.cpp.

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

References failures_.

◆ images_sent()

size_t kcenon::pacs::services::storage_scu::images_sent ( ) const

nodiscardnoexcept

Get the number of images sent since construction.

Returns: Count of successfully sent images

Definition at line 349 of file storage_scu.cpp.

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

References images_sent_.

◆ next_message_id()

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

nodiscardprivatenoexcept

Get the next message ID for DIMSE operations.

Definition at line 371 of file storage_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 store().

Here is the caller graph for this function:

◆ operator=() [1/2]

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

delete

◆ operator=() [2/2]

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

delete

◆ reset_statistics()

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

noexcept

Reset statistics counters to zero.

Definition at line 361 of file storage_scu.cpp.

                                            {
    images_sent_.store(0, std::memory_order_relaxed);
    failures_.store(0, std::memory_order_relaxed);
    bytes_sent_.store(0, std::memory_order_relaxed);
}

References bytes_sent_, failures_, and images_sent_.

◆ store()

network::Result< store_result > kcenon::pacs::services::storage_scu::store	(	network::association &	assoc,
		const core::dicom_dataset &	dataset )

nodiscard

Store a single DICOM dataset.

Sends the dataset via C-STORE to the remote SCP. The dataset must contain valid SOP Class UID and SOP Instance UID attributes.

Parameters

assoc	The established association to use
dataset	The DICOM dataset to store

Returns: Result containing store_result on success, or error message

Definition at line 67 of file storage_scu.cpp.

                                      {
 
    return store_impl(assoc, dataset, next_message_id());
}

References next_message_id(), and store_impl().

Referenced by store_batch(), store_file(), TEST_CASE(), TEST_CASE(), TEST_CASE(), TEST_CASE(), TEST_CASE(), TEST_CASE(), TEST_CASE(), TEST_CASE(), TEST_CASE(), TEST_CASE(), TEST_CASE(), TEST_CASE(), TEST_CASE(), and TEST_CASE().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ store_batch()

std::vector< store_result > kcenon::pacs::services::storage_scu::store_batch	(	network::association &	assoc,
		const std::vector< core::dicom_dataset > &	datasets,
		store_progress_callback	progress_callback = nullptr )

nodiscard

Store multiple DICOM datasets.

Sends multiple datasets via C-STORE operations. If continue_on_error is true (default), continues with remaining datasets after failures.

Parameters

assoc	The established association to use
datasets	Vector of datasets to store
progress_callback	Optional callback for progress updates

Returns: Vector of store_result for each dataset

Definition at line 177 of file storage_scu.cpp.

                                               {
 
    std::vector<store_result> results;
    results.reserve(datasets.size());
 
    const size_t total = datasets.size();
    size_t completed = 0;
 
    for (const auto& dataset : datasets) {
        auto result = store(assoc, dataset);
 
        if (result.is_ok()) {
            results.push_back(std::move(result.value()));
        } else {
            // Create a failure result
            store_result failure_result;
            failure_result.sop_instance_uid = dataset.get_string(tag_sop_instance_uid);
            failure_result.status = static_cast<uint16_t>(storage_status::cannot_understand);
            failure_result.error_comment = result.error().message;
            results.push_back(std::move(failure_result));
 
            // Stop on error if configured
            if (!config_.continue_on_error) {
                break;
            }
        }
 
        ++completed;
 
        // Report progress
        if (progress_callback) {
            progress_callback(completed, total);
        }
    }
 
    return results;
}

References kcenon::pacs::services::cannot_understand, kcenon::pacs::services::completed, config_, kcenon::pacs::services::storage_scu_config::continue_on_error, kcenon::pacs::services::store_result::error_comment, kcenon::pacs::services::store_result::sop_instance_uid, kcenon::pacs::services::store_result::status, and store().

Here is the call graph for this function:

◆ store_directory()

std::vector< store_result > kcenon::pacs::services::storage_scu::store_directory	(	network::association &	assoc,
		const std::filesystem::path &	directory,
		bool	recursive = true,
		store_progress_callback	progress_callback = nullptr )

nodiscard

Store all DICOM files in a directory.

Scans a directory for DICOM files and stores them via C-STORE.

Parameters

assoc	The established association to use
directory	Path to the directory
recursive	If true, scan subdirectories recursively
progress_callback	Optional callback for progress updates

Returns: Vector of store_result for each file

Definition at line 299 of file storage_scu.cpp.

                                               {
 
    // Collect all DICOM files from the directory
    auto files = collect_dicom_files(directory, recursive);
 
    // Delegate to store_files for the actual processing
    return store_files(assoc, files, progress_callback);
}

References collect_dicom_files(), and store_files().

Here is the call graph for this function:

◆ store_file()

network::Result< store_result > kcenon::pacs::services::storage_scu::store_file	(	network::association &	assoc,
		const std::filesystem::path &	file_path )

nodiscard

Store a DICOM file.

Reads and parses a DICOM file, then sends it via C-STORE.

Parameters

assoc	The established association to use
file_path	Path to the DICOM file

Returns: Result containing store_result on success, or error message

Definition at line 222 of file storage_scu.cpp.

                                        {
 
    // Check if file exists
    if (!std::filesystem::exists(file_path)) {
        return kcenon::pacs::pacs_error<store_result>(
            kcenon::pacs::error_codes::file_not_found_service,
            "File not found: " + file_path.string());
    }
 
    // Check if it's a regular file
    if (!std::filesystem::is_regular_file(file_path)) {
        return kcenon::pacs::pacs_error<store_result>(
            kcenon::pacs::error_codes::not_a_regular_file,
            "Not a regular file: " + file_path.string());
    }
 
    // Parse the DICOM file
    auto file_result = core::dicom_file::open(file_path);
    if (file_result.is_err()) {
        const auto error_msg = "Failed to parse DICOM file: " +
                               file_path.string() + ": " +
                               file_result.error().message;
        logger_->error(error_msg);
        return kcenon::pacs::pacs_error<store_result>(
            kcenon::pacs::error_codes::file_parse_failed, error_msg);
    }
 
    // Get the dataset from the parsed file
    const auto& dataset = file_result.value().dataset();
 
    // Store the dataset using the existing store method
    return store(assoc, dataset);
}

References kcenon::pacs::error_codes::file_not_found_service, kcenon::pacs::error_codes::file_parse_failed, logger_, kcenon::pacs::error_codes::not_a_regular_file, kcenon::pacs::core::dicom_file::open(), kcenon::pacs::pacs_error(), and store().

Referenced by store_files().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ store_files()

std::vector< store_result > kcenon::pacs::services::storage_scu::store_files	(	network::association &	assoc,
		const std::vector< std::filesystem::path > &	file_paths,
		store_progress_callback	progress_callback = nullptr )

nodiscard

Store multiple DICOM files.

Reads and parses multiple DICOM files, then sends them via C-STORE. If continue_on_error is true (default), continues with remaining files after failures.

Parameters

assoc	The established association to use
file_paths	Vector of paths to DICOM files
progress_callback	Optional callback for progress updates

Returns: Vector of store_result for each file

Definition at line 258 of file storage_scu.cpp.

                                               {
 
    std::vector<store_result> results;
    results.reserve(file_paths.size());
 
    const size_t total = file_paths.size();
    size_t completed = 0;
 
    for (const auto& file_path : file_paths) {
        auto result = store_file(assoc, file_path);
 
        if (result.is_ok()) {
            results.push_back(std::move(result.value()));
        } else {
            // Create a failure result
            store_result failure_result;
            failure_result.sop_instance_uid = file_path.filename().string();
            failure_result.status = static_cast<uint16_t>(storage_status::cannot_understand);
            failure_result.error_comment = result.error().message;
            results.push_back(std::move(failure_result));
 
            // Stop on error if configured
            if (!config_.continue_on_error) {
                break;
            }
        }
 
        ++completed;
 
        // Report progress
        if (progress_callback) {
            progress_callback(completed, total);
        }
    }
 
    return results;
}

References kcenon::pacs::services::cannot_understand, kcenon::pacs::services::completed, config_, kcenon::pacs::services::storage_scu_config::continue_on_error, kcenon::pacs::services::store_result::error_comment, kcenon::pacs::services::store_result::sop_instance_uid, kcenon::pacs::services::store_result::status, and store_file().

Referenced by store_directory().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ store_impl()

network::Result< store_result > kcenon::pacs::services::storage_scu::store_impl	(	network::association &	assoc,
		const core::dicom_dataset &	dataset,
		uint16_t	message_id )

nodiscardprivate

Internal implementation of single store operation.

Definition at line 74 of file storage_scu.cpp.

                         {
 
    using namespace network::dimse;
 
    // Extract SOP Class UID from dataset
    const auto sop_class_uid = dataset.get_string(tag_sop_class_uid);
    if (sop_class_uid.empty()) {
        return kcenon::pacs::pacs_error<store_result>(
            kcenon::pacs::error_codes::store_missing_sop_class_uid,
            "Missing SOP Class UID in dataset");
    }
 
    // Extract SOP Instance UID from dataset
    const auto sop_instance_uid = dataset.get_string(tag_sop_instance_uid);
    if (sop_instance_uid.empty()) {
        return kcenon::pacs::pacs_error<store_result>(
            kcenon::pacs::error_codes::store_missing_sop_instance_uid,
            "Missing SOP Instance UID in dataset");
    }
 
    // Verify association is established
    if (!assoc.is_established()) {
        return kcenon::pacs::pacs_error<store_result>(
            kcenon::pacs::error_codes::association_not_established,
            "Association not established");
    }
 
    // Get accepted presentation context for this SOP class
    auto context_id = assoc.accepted_context_id(sop_class_uid);
    if (!context_id) {
        return kcenon::pacs::pacs_error<store_result>(
            kcenon::pacs::error_codes::store_no_accepted_context,
            "No accepted presentation context for SOP Class: " + sop_class_uid);
    }
 
    // Build C-STORE-RQ message
    auto request = make_c_store_rq(
        message_id,
        sop_class_uid,
        sop_instance_uid,
        config_.default_priority
    );
 
    // Attach the dataset
    request.set_dataset(dataset);
 
    // Send the request
    auto send_result = assoc.send_dimse(*context_id, request);
    if (send_result.is_err()) {
        failures_.fetch_add(1, std::memory_order_relaxed);
        return send_result.error();
    }
 
    // Receive the response
    auto recv_result = assoc.receive_dimse(config_.response_timeout);
    if (recv_result.is_err()) {
        failures_.fetch_add(1, std::memory_order_relaxed);
        return recv_result.error();
    }
 
    const auto& [recv_context_id, response] = recv_result.value();
 
    // Verify it's a C-STORE response
    if (response.command() != command_field::c_store_rsp) {
        failures_.fetch_add(1, std::memory_order_relaxed);
        return kcenon::pacs::pacs_error<store_result>(
            kcenon::pacs::error_codes::store_unexpected_command,
            "Expected C-STORE-RSP but received " +
            std::string(to_string(response.command())));
    }
 
    // Build result from response
    store_result result;
    result.sop_instance_uid = sop_instance_uid;
    result.status = static_cast<uint16_t>(response.status());
 
    // Extract error comment if present
    if (response.command_set().contains(tag_error_comment)) {
        result.error_comment = response.command_set().get_string(tag_error_comment);
    }
 
    // Update statistics
    if (result.is_success() || result.is_warning()) {
        images_sent_.fetch_add(1, std::memory_order_relaxed);
        // Estimate dataset size
        bytes_sent_.fetch_add(
            dataset.size() * sizeof(uint32_t),
            std::memory_order_relaxed
        );
    } else {
        failures_.fetch_add(1, std::memory_order_relaxed);
    }
 
    return result;
}

Referenced by store().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ bytes_sent_

std::atomic<size_t> kcenon::pacs::services::storage_scu::bytes_sent_ {0}

private

Statistics: total bytes sent.

Definition at line 358 of file storage_scu.h.

358{0};

Referenced by bytes_sent(), reset_statistics(), and store_impl().

◆ config_

storage_scu_config kcenon::pacs::services::storage_scu::config_

private

Configuration.

Definition at line 346 of file storage_scu.h.

Referenced by store_batch(), store_files(), and store_impl().

◆ failures_

std::atomic<size_t> kcenon::pacs::services::storage_scu::failures_ {0}

private

Statistics: number of failed operations.

Definition at line 355 of file storage_scu.h.

355{0};

Referenced by failures(), reset_statistics(), and store_impl().

◆ images_sent_

std::atomic<size_t> kcenon::pacs::services::storage_scu::images_sent_ {0}

private

Statistics: number of images sent successfully.

Definition at line 352 of file storage_scu.h.

352{0};

Referenced by images_sent(), reset_statistics(), and store_impl().

◆ logger_

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

private

Logger instance for service logging.

Definition at line 343 of file storage_scu.h.

Referenced by store_file().

◆ message_id_counter_

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

private

Message ID counter.

Definition at line 349 of file storage_scu.h.

349{1};

Referenced by next_message_id().

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

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

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ storage_scu() [1/4]

◆ storage_scu() [2/4]

◆ ~storage_scu()

◆ storage_scu() [3/4]

◆ storage_scu() [4/4]

Member Function Documentation

◆ bytes_sent()

◆ collect_dicom_files()

◆ failures()

◆ images_sent()

◆ next_message_id()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ reset_statistics()

◆ store()

◆ store_batch()

◆ store_directory()

◆ store_file()

◆ store_files()

◆ store_impl()

Member Data Documentation

◆ bytes_sent_

◆ config_

◆ failures_

◆ images_sent_

◆ logger_

◆ message_id_counter_