kcenon::pacs::storage::file_storage Class Reference

#include <file_storage.h>

Inheritance diagram for kcenon::pacs::storage::file_storage:

Collaboration diagram for kcenon::pacs::storage::file_storage:

Public Member Functions
	file_storage (const file_storage_config &config)
	Construct file storage with configuration.
	~file_storage () override=default
	Destructor.
	file_storage (const file_storage &)=delete
	Non-copyable (contains mutex)
file_storage &	operator= (const file_storage &)=delete
	file_storage (file_storage &&)=delete
	Non-movable (contains mutex)
file_storage &	operator= (file_storage &&)=delete
auto	store (const core::dicom_dataset &dataset) -> VoidResult override
	Store a DICOM dataset to filesystem.
auto	retrieve (std::string_view sop_instance_uid) -> Result< core::dicom_dataset > override
	Retrieve a DICOM dataset by SOP Instance UID.
auto	remove (std::string_view sop_instance_uid) -> VoidResult override
	Remove a DICOM file by SOP Instance UID.
auto	exists (std::string_view sop_instance_uid) const -> bool override
	Check if a DICOM instance exists.
auto	find (const core::dicom_dataset &query) -> Result< std::vector< core::dicom_dataset > > override
	Find DICOM datasets matching query criteria.
auto	get_statistics () const -> storage_statistics override
	Get storage statistics.
auto	verify_integrity () -> VoidResult override
	Verify storage integrity.
auto	get_file_path (std::string_view sop_instance_uid) const -> std::filesystem::path
	Get the filesystem path for a SOP Instance UID.
auto	import_directory (const std::filesystem::path &source) -> VoidResult
	Import DICOM files from a directory.
auto	root_path () const -> const std::filesystem::path &
	Get the root storage path.
auto	rebuild_index () -> VoidResult
	Rebuild the internal index from filesystem.
Public Member Functions inherited from kcenon::pacs::storage::storage_interface
virtual	~storage_interface ()=default
	Virtual destructor for proper polymorphic destruction.
virtual auto	store_batch (const std::vector< core::dicom_dataset > &datasets) -> VoidResult
	Store multiple DICOM datasets in a single operation.
virtual auto	retrieve_batch (const std::vector< std::string > &sop_instance_uids) -> Result< std::vector< core::dicom_dataset > >
	Retrieve multiple DICOM datasets by their SOP Instance UIDs.

Private Member Functions
auto	build_path (std::string_view study_uid, std::string_view series_uid, std::string_view sop_uid) const -> std::filesystem::path
	Build filesystem path for a dataset.
auto	build_date_path (std::string_view study_date, std::string_view study_uid, std::string_view sop_uid) const -> std::filesystem::path
	Build filesystem path using date-based hierarchy.
void	update_index (const std::string &sop_uid, const std::filesystem::path &path)
	Update internal index with new mapping.
void	remove_from_index (const std::string &sop_uid)
	Remove entry from internal index.

Static Private Member Functions
static auto	matches_query (const core::dicom_dataset &dataset, const core::dicom_dataset &query) -> bool
	Check if dataset matches query criteria.
static auto	sanitize_uid (std::string_view uid) -> std::string
	Sanitize UID for use in filesystem path.

Private Attributes
file_storage_config	config_
	Storage configuration.
std::unordered_map< std::string, std::filesystem::path >	index_
	Mapping from SOP Instance UID to file path.
std::shared_mutex	mutex_
	Mutex for thread-safe access.

Additional Inherited Members
Protected Member Functions inherited from kcenon::pacs::storage::storage_interface
	storage_interface ()=default
	Protected default constructor for derived classes.
	storage_interface (const storage_interface &)=delete
	Non-copyable.
storage_interface &	operator= (const storage_interface &)=delete
	storage_interface (storage_interface &&)=default
	Movable.
storage_interface &	operator= (storage_interface &&)=default

Detailed Description

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/monitoring/health_checker.h.

Definition at line 122 of file file_storage.h.

Constructor & Destructor Documentation

file_storage() [1/3]

kcenon::pacs::storage::file_storage::file_storage ( const file_storage_config & config )

explicit

Construct file storage with configuration.

Parameters

config

Storage configuration

Exceptions

std::runtime_error

if root_path is invalid and create_directories is false

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/file_storage.h.

Definition at line 56 of file file_storage.cpp.

    : config_(config) {
    // Create root directory if configured
    if (config_.create_directories && !config_.root_path.empty()) {
        std::error_code ec;
        std::filesystem::create_directories(config_.root_path, ec);
        // Ignore error - will be caught during store operations
    }
 
    // Rebuild index from existing files
    if (std::filesystem::exists(config_.root_path)) {
        (void)rebuild_index();
    }
}

References config_, kcenon::pacs::storage::file_storage_config::create_directories, if(), and kcenon::pacs::storage::file_storage_config::root_path.

Here is the call graph for this function:

~file_storage()

kcenon::pacs::storage::file_storage::~file_storage ( )

overridedefault

Destructor.

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/file_storage.h.

file_storage() [2/3]

kcenon::pacs::storage::file_storage::file_storage ( const file_storage & )

delete

Non-copyable (contains mutex)

file_storage() [3/3]

kcenon::pacs::storage::file_storage::file_storage ( file_storage && )

delete

Non-movable (contains mutex)

Member Function Documentation

build_date_path()

auto kcenon::pacs::storage::file_storage::build_date_path ( std::string_view study_date, std::string_view study_uid, std::string_view sop_uid ) const -> std::filesystem::path

nodiscardprivate

Build filesystem path using date-based hierarchy.

Parameters

study_date	Study date (YYYYMMDD format)
study_uid	Study Instance UID
sop_uid	SOP Instance UID

Returns

The constructed path

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/file_storage.h.

Definition at line 472 of file file_storage.cpp.

                         {
    // Parse date YYYYMMDD
    std::string year = "unknown";
    std::string month = "01";
    std::string day = "01";
 
    if (study_date.length() >= 8) {
        year = std::string{study_date.substr(0, 4)};
        month = std::string{study_date.substr(4, 2)};
        day = std::string{study_date.substr(6, 2)};
    }
 
    return config_.root_path / year / month / day / sanitize_uid(study_uid) /
           (sanitize_uid(sop_uid) + config_.file_extension);
}

build_path()

auto kcenon::pacs::storage::file_storage::build_path ( std::string_view study_uid, std::string_view series_uid, std::string_view sop_uid ) const -> std::filesystem::path

nodiscardprivate

Build filesystem path for a dataset.

Parameters

study_uid	Study Instance UID
series_uid	Series Instance UID
sop_uid	SOP Instance UID

Returns

The constructed path

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/file_storage.h.

Definition at line 463 of file file_storage.cpp.

                         {
    return config_.root_path / sanitize_uid(study_uid) /
           sanitize_uid(series_uid) /
           (sanitize_uid(sop_uid) + config_.file_extension);
}

exists()

auto kcenon::pacs::storage::file_storage::exists ( std::string_view sop_instance_uid ) const -> bool

nodiscardoverridevirtual

Check if a DICOM instance exists.

Parameters

sop_instance_uid

The unique identifier to check

Returns

true if the file exists, false otherwise

Implements kcenon::pacs::storage::storage_interface.

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/file_storage.h.

Definition at line 247 of file file_storage.cpp.

                                                                       {
    std::shared_lock lock(mutex_);
    return index_.contains(std::string{sop_instance_uid});
}

find()

auto kcenon::pacs::storage::file_storage::find ( const core::dicom_dataset & query ) -> Result<std::vector<core::dicom_dataset>>

nodiscardoverridevirtual

Find DICOM datasets matching query criteria.

Scans the storage directory and matches datasets against query.

Parameters

query

The query dataset containing search criteria

Returns

Result containing matching datasets or error information

Note

This operation can be slow for large storage directories

Implements kcenon::pacs::storage::storage_interface.

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/file_storage.h.

Definition at line 252 of file file_storage.cpp.

                                            {
    std::vector<core::dicom_dataset> results;
 
    std::vector<std::filesystem::path> paths_to_check;
    {
        std::shared_lock lock(mutex_);
        paths_to_check.reserve(index_.size());
        for (const auto& [uid, path] : index_) {
            paths_to_check.push_back(path);
        }
    }
 
    for (const auto& path : paths_to_check) {
        auto open_result = core::dicom_file::open(path);
        if (open_result.is_err()) {
            continue;  // Skip files that can't be read
        }
 
        const auto& dataset = open_result.value().dataset();
        if (matches_query(dataset, query)) {
            results.push_back(dataset);
        }
    }
 
    return results;
}

References kcenon::pacs::core::dicom_file::open(), and uid.

Here is the call graph for this function:

get_file_path()

auto kcenon::pacs::storage::file_storage::get_file_path ( std::string_view sop_instance_uid ) const -> std::filesystem::path

nodiscard

Get the filesystem path for a SOP Instance UID.

Parameters

sop_instance_uid

The SOP Instance UID

Returns

The filesystem path (may not exist)

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/file_storage.h.

Definition at line 375 of file file_storage.cpp.

                         {
    std::shared_lock lock(mutex_);
    auto it = index_.find(std::string{sop_instance_uid});
    if (it != index_.end()) {
        return it->second;
    }
    return {};
}

get_statistics()

auto kcenon::pacs::storage::file_storage::get_statistics ( ) const -> storage_statistics

nodiscardoverridevirtual

Get storage statistics.

Returns

Storage statistics structure

Implements kcenon::pacs::storage::storage_interface.

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/file_storage.h.

Definition at line 280 of file file_storage.cpp.

                                                              {
    storage_statistics stats;
 
    std::set<std::string> studies;
    std::set<std::string> series;
    std::set<std::string> patients;
 
    std::vector<std::filesystem::path> paths;
    {
        std::shared_lock lock(mutex_);
        stats.total_instances = index_.size();
        paths.reserve(index_.size());
        for (const auto& [uid, path] : index_) {
            paths.push_back(path);
        }
    }
 
    for (const auto& path : paths) {
        std::error_code ec;
        stats.total_bytes += std::filesystem::file_size(path, ec);
 
        // Read file to get study/series/patient info
        auto open_result = core::dicom_file::open(path);
        if (open_result.is_ok()) {
            const auto& ds = open_result.value().dataset();
            auto study_uid = ds.get_string(core::tags::study_instance_uid);
            auto series_uid = ds.get_string(core::tags::series_instance_uid);
            auto patient_id = ds.get_string(core::tags::patient_id);
 
            if (!study_uid.empty()) {
                studies.insert(study_uid);
            }
            if (!series_uid.empty()) {
                series.insert(series_uid);
            }
            if (!patient_id.empty()) {
                patients.insert(patient_id);
            }
        }
    }
 
    stats.studies_count = studies.size();
    stats.series_count = series.size();
    stats.patients_count = patients.size();
 
    return stats;
}

References index_, mutex_, kcenon::pacs::core::dicom_file::open(), kcenon::pacs::core::tags::patient_id, kcenon::pacs::core::tags::series_instance_uid, kcenon::pacs::core::tags::study_instance_uid, and uid.

Here is the call graph for this function:

import_directory()

auto kcenon::pacs::storage::file_storage::import_directory ( const std::filesystem::path & source ) -> VoidResult

nodiscard

Import DICOM files from a directory.

Recursively scans the source directory for DICOM files and imports them.

Parameters

source

Source directory to import from

Returns

VoidResult Success or error information

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/file_storage.h.

Definition at line 385 of file file_storage.cpp.

                  {
    if (!std::filesystem::exists(source)) {
        return make_error<std::monostate>(
            kFileNotFound,
            "Source directory does not exist: " + source.string(),
            "file_storage");
    }
 
    std::error_code ec;
    for (const auto& entry :
         std::filesystem::recursive_directory_iterator(source, ec)) {
        if (!entry.is_regular_file()) {
            continue;
        }
 
        // Try to open as DICOM file
        auto open_result = core::dicom_file::open(entry.path());
        if (open_result.is_err()) {
            continue;  // Not a DICOM file, skip
        }
 
        // Store the dataset
        auto store_result = store(open_result.value().dataset());
        if (store_result.is_err()) {
            // Log error but continue with other files
            // In production, this should be logged
        }
    }
 
    return ok();
}

References kcenon::pacs::core::dicom_file::open().

Here is the call graph for this function:

matches_query()

auto kcenon::pacs::storage::file_storage::matches_query ( const core::dicom_dataset & dataset, const core::dicom_dataset & query ) -> bool

staticnodiscardprivate

Check if dataset matches query criteria.

Parameters

dataset	The dataset to check
query	The query criteria

Returns

true if dataset matches query

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/file_storage.h.

Definition at line 502 of file file_storage.cpp.

                                                                         {
    // If query is empty, match all
    if (query.empty()) {
        return true;
    }
 
    // Check each query element
    for (const auto& [tag, element] : query) {
        auto query_value = element.as_string().unwrap_or("");
        if (query_value.empty()) {
            continue;  // Empty value acts as wildcard
        }
 
        auto dataset_value = dataset.get_string(tag);
 
        // Support basic wildcard matching (* and ?)
        if (query_value.find('*') != std::string::npos ||
            query_value.find('?') != std::string::npos) {
            // Convert to regex-like matching
            std::string pattern = query_value;
            // Escape regex special characters except * and ?
            std::string escaped;
            for (char c : pattern) {
                if (c == '*') {
                    escaped += ".*";
                } else if (c == '?') {
                    escaped += ".";
                } else if (c == '.' || c == '[' || c == ']' || c == '(' ||
                           c == ')' || c == '+' || c == '^' || c == '$' ||
                           c == '|' || c == '\\') {
                    escaped += '\\';
                    escaped += c;
                } else {
                    escaped += c;
                }
            }
 
            // Simple pattern matching (without full regex for performance)
            // For now, just check if pattern starts with or ends with value
            if (query_value.front() == '*' && query_value.back() == '*') {
                // Contains
                auto inner =
                    query_value.substr(1, query_value.length() - 2);
                if (dataset_value.find(inner) == std::string::npos) {
                    return false;
                }
            } else if (query_value.front() == '*') {
                // Ends with
                auto suffix = query_value.substr(1);
                if (dataset_value.length() < suffix.length() ||
                    dataset_value.substr(dataset_value.length() -
                                         suffix.length()) != suffix) {
                    return false;
                }
            } else if (query_value.back() == '*') {
                // Starts with
                auto prefix = query_value.substr(0, query_value.length() - 1);
                if (dataset_value.substr(0, prefix.length()) != prefix) {
                    return false;
                }
            }
        } else {
            // Exact match
            if (dataset_value != query_value) {
                return false;
            }
        }
    }
 
    return true;
}

operator=() [1/2]

file_storage & kcenon::pacs::storage::file_storage::operator= ( const file_storage & )

delete

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/file_storage.h.

operator=() [2/2]

file_storage & kcenon::pacs::storage::file_storage::operator= ( file_storage && )

delete

rebuild_index()

auto kcenon::pacs::storage::file_storage::rebuild_index ( ) -> VoidResult

nodiscard

Rebuild the internal index from filesystem.

Scans the storage directory and rebuilds the SOP UID to path mapping.

Returns

VoidResult Success or error information

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/file_storage.h.

Definition at line 422 of file file_storage.cpp.

                                               {
    std::unique_lock lock(mutex_);
    index_.clear();
 
    if (!std::filesystem::exists(config_.root_path)) {
        return ok();
    }
 
    std::error_code ec;
    for (const auto& entry :
         std::filesystem::recursive_directory_iterator(config_.root_path, ec)) {
        if (!entry.is_regular_file()) {
            continue;
        }
 
        // Check file extension
        if (!config_.file_extension.empty() &&
            entry.path().extension() != config_.file_extension) {
            continue;
        }
 
        // Try to read as DICOM file
        auto open_result = core::dicom_file::open(entry.path());
        if (open_result.is_err()) {
            continue;
        }
 
        auto sop_uid =
            open_result.value().dataset().get_string(core::tags::sop_instance_uid);
        if (!sop_uid.empty()) {
            index_[sop_uid] = entry.path();
        }
    }
 
    return ok();
}

References kcenon::pacs::core::dicom_file::open(), and kcenon::pacs::core::tags::sop_instance_uid.

Here is the call graph for this function:

remove()

auto kcenon::pacs::storage::file_storage::remove ( std::string_view sop_instance_uid ) -> VoidResult

nodiscardoverridevirtual

Remove a DICOM file by SOP Instance UID.

Parameters

sop_instance_uid

The unique identifier for the instance to remove

Returns

VoidResult Success or error information

Implements kcenon::pacs::storage::storage_interface.

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/file_storage.h.

Definition at line 214 of file file_storage.cpp.

                                                                       {
    std::filesystem::path file_path;
 
    {
        std::unique_lock lock(mutex_);
        auto it = index_.find(std::string{sop_instance_uid});
        if (it == index_.end()) {
            // Not found is not an error for remove
            return ok();
        }
        file_path = it->second;
        index_.erase(it);
    }
 
    // Delete the file
    std::error_code ec;
    std::filesystem::remove(file_path, ec);
    // Ignore errors - file might have been deleted externally
 
    // Try to clean up empty parent directories
    auto parent = file_path.parent_path();
    while (parent != config_.root_path) {
        if (std::filesystem::is_empty(parent)) {
            std::filesystem::remove(parent, ec);
            parent = parent.parent_path();
        } else {
            break;
        }
    }
 
    return ok();
}

remove_from_index()

void kcenon::pacs::storage::file_storage::remove_from_index ( const std::string & sop_uid )

private

Remove entry from internal index.

Parameters

sop_uid

SOP Instance UID

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/file_storage.h.

Definition at line 497 of file file_storage.cpp.

                                                             {
    std::unique_lock lock(mutex_);
    index_.erase(sop_uid);
}

References index_, and mutex_.

retrieve()

auto kcenon::pacs::storage::file_storage::retrieve ( std::string_view sop_instance_uid ) -> Result<core::dicom_dataset>

nodiscardoverridevirtual

Retrieve a DICOM dataset by SOP Instance UID.

Parameters

sop_instance_uid

The unique identifier for the instance

Returns

Result containing the dataset or error information

Implements kcenon::pacs::storage::storage_interface.

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/file_storage.h.

Definition at line 186 of file file_storage.cpp.

                                 {
    std::filesystem::path file_path;
 
    {
        std::shared_lock lock(mutex_);
        auto it = index_.find(std::string{sop_instance_uid});
        if (it == index_.end()) {
            return make_error<core::dicom_dataset>(
                kFileNotFound,
                "Instance not found: " + std::string{sop_instance_uid},
                "file_storage");
        }
        file_path = it->second;
    }
 
    // Read DICOM file
    auto open_result = core::dicom_file::open(file_path);
    if (open_result.is_err()) {
        return make_error<core::dicom_dataset>(
            kFileReadError,
            "Failed to read DICOM file: " + open_result.error().message,
            "file_storage");
    }
 
    return open_result.value().dataset();
}

References kcenon::pacs::core::dicom_file::open().

Here is the call graph for this function:

root_path()

auto kcenon::pacs::storage::file_storage::root_path ( ) const -> const std::filesystem::path&

nodiscard

Get the root storage path.

Returns

The configured root path

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/file_storage.h.

Definition at line 418 of file file_storage.cpp.

                                                               {
    return config_.root_path;
}

References config_, and kcenon::pacs::storage::file_storage_config::root_path.

sanitize_uid()

auto kcenon::pacs::storage::file_storage::sanitize_uid ( std::string_view uid ) -> std::string

staticnodiscardprivate

Sanitize UID for use in filesystem path.

Parameters

uid	The UID to sanitize

Returns

Sanitized string safe for filesystem use

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/file_storage.h.

Definition at line 575 of file file_storage.cpp.

                                                               {
    std::string result;
    result.reserve(uid.length());
 
    for (char c : uid) {
        // UIDs contain digits and dots, which are safe for filesystems
        // Replace any other characters with underscore
        if (std::isalnum(static_cast<unsigned char>(c)) || c == '.') {
            result += c;
        } else {
            result += '_';
        }
    }
 
    return result;
}

References uid.

store()

auto kcenon::pacs::storage::file_storage::store ( const core::dicom_dataset & dataset ) -> VoidResult

nodiscardoverridevirtual

Store a DICOM dataset to filesystem.

Extracts UIDs from the dataset and stores as a Part 10 file. Uses atomic write pattern: writes to temp file, then renames.

Parameters

dataset

The DICOM dataset to store

Returns

VoidResult Success or error information

Note

Requires Study, Series, and SOP Instance UIDs in the dataset

Implements kcenon::pacs::storage::storage_interface.

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/file_storage.h.

Definition at line 75 of file file_storage.cpp.

                                                                       {
    // Extract required UIDs
    auto study_uid = dataset.get_string(core::tags::study_instance_uid);
    auto series_uid = dataset.get_string(core::tags::series_instance_uid);
    auto sop_uid = dataset.get_string(core::tags::sop_instance_uid);
 
    if (study_uid.empty() || series_uid.empty() || sop_uid.empty()) {
        return make_error<std::monostate>(
            kMissingRequiredUid,
            "Missing required UID (Study, Series, or SOP Instance UID)",
            "file_storage");
    }
 
    // Build file path based on naming scheme
    std::filesystem::path file_path;
    switch (config_.naming) {
        case naming_scheme::uid_hierarchical:
            file_path = build_path(study_uid, series_uid, sop_uid);
            break;
        case naming_scheme::date_hierarchical: {
            auto study_date = dataset.get_string(core::tags::study_date);
            if (study_date.empty()) {
                // Use current date if study date not available
                auto now = std::chrono::system_clock::now();
                auto time = std::chrono::system_clock::to_time_t(now);
                std::tm tm_buf{};
#ifdef _WIN32
                localtime_s(&tm_buf, &time);
#else
                localtime_r(&time, &tm_buf);
#endif
                char date_str[9];
                std::strftime(date_str, sizeof(date_str), "%Y%m%d", &tm_buf);
                study_date = date_str;
            }
            file_path = build_date_path(study_date, study_uid, sop_uid);
            break;
        }
        case naming_scheme::flat:
            file_path = config_.root_path /
                        (sanitize_uid(sop_uid) + config_.file_extension);
            break;
    }
 
    // Handle duplicate checking
    {
        std::shared_lock lock(mutex_);
        if (index_.contains(sop_uid)) {
            switch (config_.duplicate) {
                case duplicate_policy::reject:
                    return make_error<std::monostate>(
                        kDuplicateInstance,
                        "Instance already exists: " + sop_uid,
                        "file_storage");
                case duplicate_policy::ignore:
                    return ok();
                case duplicate_policy::replace:
                    // Continue to overwrite
                    break;
            }
        }
    }
 
    // Create directories if needed
    if (config_.create_directories) {
        std::error_code ec;
        std::filesystem::create_directories(file_path.parent_path(), ec);
        if (ec) {
            return make_error<std::monostate>(
                kDirectoryCreateError,
                "Failed to create directory: " + ec.message(),
                "file_storage");
        }
    }
 
    // Create DICOM file and write atomically
    auto dicom_file = core::dicom_file::create(
        dataset, encoding::transfer_syntax::explicit_vr_little_endian);
 
    // Write to temporary file first
    auto temp_path = generate_temp_filename(file_path);
    auto save_result = dicom_file.save(temp_path);
 
    if (save_result.is_err()) {
        std::filesystem::remove(temp_path);
        return make_error<std::monostate>(
            kFileWriteError,
            "Failed to write DICOM file: " + save_result.error().message,
            "file_storage");
    }
 
    // Atomic rename
    std::error_code ec;
    std::filesystem::rename(temp_path, file_path, ec);
    if (ec) {
        std::filesystem::remove(temp_path);
        return make_error<std::monostate>(
            kFileWriteError,
            "Failed to rename temp file: " + ec.message(),
            "file_storage");
    }
 
    // Update index
    {
        std::unique_lock lock(mutex_);
        index_[sop_uid] = file_path;
    }
 
    return ok();
}

References kcenon::pacs::core::dicom_file::create(), kcenon::pacs::storage::date_hierarchical, kcenon::pacs::encoding::transfer_syntax::explicit_vr_little_endian, kcenon::pacs::storage::flat, kcenon::pacs::storage::ignore, kcenon::pacs::storage::reject, kcenon::pacs::storage::replace, kcenon::pacs::core::tags::series_instance_uid, kcenon::pacs::core::tags::sop_instance_uid, kcenon::pacs::core::tags::study_date, kcenon::pacs::core::tags::study_instance_uid, and kcenon::pacs::storage::uid_hierarchical.

Here is the call graph for this function:

update_index()

void kcenon::pacs::storage::file_storage::update_index ( const std::string & sop_uid, const std::filesystem::path & path )

private

Update internal index with new mapping.

Parameters

sop_uid	SOP Instance UID
path	File path

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/file_storage.h.

Definition at line 491 of file file_storage.cpp.

                                                               {
    std::unique_lock lock(mutex_);
    index_[sop_uid] = path;
}

References index_, and mutex_.

verify_integrity()

auto kcenon::pacs::storage::file_storage::verify_integrity ( ) -> VoidResult

nodiscardoverridevirtual

Verify storage integrity.

Checks that all indexed files exist and are valid DICOM files.

Returns

VoidResult Success if integrity is verified, error otherwise

Implements kcenon::pacs::storage::storage_interface.

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/file_storage.h.

Definition at line 328 of file file_storage.cpp.

                                                  {
    std::vector<std::pair<std::string, std::filesystem::path>> entries;
    {
        std::shared_lock lock(mutex_);
        entries.reserve(index_.size());
        for (const auto& [uid, path] : index_) {
            entries.emplace_back(uid, path);
        }
    }
 
    std::vector<std::string> invalid_entries;
 
    for (const auto& [uid, path] : entries) {
        if (!std::filesystem::exists(path)) {
            invalid_entries.push_back(uid + " (file missing)");
            continue;
        }
 
        auto open_result = core::dicom_file::open(path);
        if (open_result.is_err()) {
            invalid_entries.push_back(uid + " (invalid DICOM)");
            continue;
        }
 
        // Verify UID matches
        auto file_uid =
            open_result.value().dataset().get_string(core::tags::sop_instance_uid);
        if (file_uid != uid) {
            invalid_entries.push_back(uid + " (UID mismatch)");
        }
    }
 
    if (!invalid_entries.empty()) {
        std::string message = "Integrity check failed for " +
                              std::to_string(invalid_entries.size()) +
                              " entries";
        return make_error<std::monostate>(kIntegrityError, message,
                                          "file_storage");
    }
 
    return ok();
}

References kcenon::pacs::core::dicom_file::open(), kcenon::pacs::core::tags::sop_instance_uid, and uid.

Here is the call graph for this function:

Member Data Documentation

config_

file_storage_config kcenon::pacs::storage::file_storage::config_

private

Storage configuration.

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/file_storage.h.

Definition at line 327 of file file_storage.h.

Referenced by file_storage(), and root_path().

index_

std::unordered_map<std::string, std::filesystem::path> kcenon::pacs::storage::file_storage::index_

private

Mapping from SOP Instance UID to file path.

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/file_storage.h.

Definition at line 330 of file file_storage.h.

Referenced by get_statistics(), remove_from_index(), and update_index().

mutex_

std::shared_mutex kcenon::pacs::storage::file_storage::mutex_

mutableprivate

Mutex for thread-safe access.

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/file_storage.h.

Definition at line 333 of file file_storage.h.

Referenced by get_statistics(), remove_from_index(), and update_index().

---

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

• include/kcenon/pacs/storage/file_storage.h
• src/storage/file_storage.cpp