prefetch_config.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2021-2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <chrono>
#include <cstdint>
#include <functional>
#include <optional>
#include <set>
#include <string>
#include <vector>
 
namespace kcenon::pacs::workflow {
 
struct remote_pacs_config {
    std::string ae_title;
 
    std::string host;
 
    uint16_t port{11112};
 
    std::string local_ae_title{"PACS_PREFETCH"};
 
    std::chrono::seconds connection_timeout{30};
 
    std::chrono::seconds association_timeout{60};
 
    bool use_tls{false};
 
    [[nodiscard]] auto is_valid() const noexcept -> bool {
        return !ae_title.empty() && !host.empty() && port > 0;
    }
};
 
struct prefetch_criteria {
    std::chrono::days lookback_period{365};
 
    std::size_t max_studies_per_patient{10};
 
    std::size_t max_series_per_study{0};  // 0 = unlimited
 
    std::set<std::string> include_modalities;
 
    std::set<std::string> exclude_modalities;
 
    std::set<std::string> include_body_parts;
 
    bool prefer_same_modality{true};
 
    bool prefer_same_body_part{true};
};
 
struct prefetch_result {
    std::size_t patients_processed{0};
 
    std::size_t studies_prefetched{0};
 
    std::size_t series_prefetched{0};
 
    std::size_t instances_prefetched{0};
 
    std::size_t studies_failed{0};
 
    std::size_t studies_already_present{0};
 
    std::size_t bytes_downloaded{0};
 
    std::chrono::milliseconds duration{0};
 
    std::chrono::system_clock::time_point timestamp;
 
    [[nodiscard]] auto is_successful() const noexcept -> bool {
        return studies_failed == 0;
    }
 
    auto operator+=(const prefetch_result& other) -> prefetch_result& {
        patients_processed += other.patients_processed;
        studies_prefetched += other.studies_prefetched;
        series_prefetched += other.series_prefetched;
        instances_prefetched += other.instances_prefetched;
        studies_failed += other.studies_failed;
        studies_already_present += other.studies_already_present;
        bytes_downloaded += other.bytes_downloaded;
        duration += other.duration;
        return *this;
    }
};
 
struct prior_study_info {
    std::string study_instance_uid;
 
    std::string patient_id;
 
    std::string patient_name;
 
    std::string study_date;
 
    std::string study_description;
 
    std::set<std::string> modalities;
 
    std::string body_part_examined;
 
    std::string accession_number;
 
    std::size_t number_of_series{0};
 
    std::size_t number_of_instances{0};
};
 
struct prefetch_service_config {
    bool enabled{true};
 
    std::chrono::seconds prefetch_interval{300};
 
    std::size_t max_concurrent_prefetches{4};
 
    bool auto_start{false};
 
    std::vector<remote_pacs_config> remote_pacs;
 
    prefetch_criteria criteria;
 
    std::size_t rate_limit_per_minute{0};
 
    bool retry_on_failure{true};
 
    std::size_t max_retry_attempts{3};
 
    std::chrono::seconds retry_delay{60};
 
    using cycle_complete_callback =
        std::function<void(const prefetch_result& result)>;
    cycle_complete_callback on_cycle_complete;
 
    using prefetch_complete_callback =
        std::function<void(const std::string& patient_id,
                          const prior_study_info& study,
                          bool success,
                          const std::string& error_message)>;
    prefetch_complete_callback on_prefetch_complete;
 
    using error_callback =
        std::function<void(const std::string& patient_id,
                          const std::string& study_uid,
                          const std::string& error)>;
    error_callback on_prefetch_error;
 
    [[nodiscard]] auto is_valid() const noexcept -> bool {
        if (!enabled) {
            return true;  // Disabled config is always valid
        }
        // Must have at least one valid remote PACS
        for (const auto& pacs : remote_pacs) {
            if (pacs.is_valid()) {
                return true;
            }
        }
        return false;
    }
};
 
}  // namespace kcenon::pacs::workflow