#include <prefetch_manager.h>

Collaboration diagram for kcenon::pacs::client::prefetch_manager:

Classes
struct	impl

Public Member Functions
	prefetch_manager (prefetch_repositories repositories, std::shared_ptr< remote_node_manager > node_manager, std::shared_ptr< job_manager > job_manager, std::shared_ptr< services::worklist_scu > worklist_scu=nullptr, std::shared_ptr< di::ILogger > logger=nullptr)
	Construct a prefetch manager from split repositories.

	prefetch_manager (const prefetch_manager_config &config, prefetch_repositories repositories, std::shared_ptr< remote_node_manager > node_manager, std::shared_ptr< job_manager > job_manager, std::shared_ptr< services::worklist_scu > worklist_scu=nullptr, std::shared_ptr< di::ILogger > logger=nullptr)
	Construct with custom configuration and split repositories.

	prefetch_manager (std::shared_ptr< storage::prefetch_repository > repo, std::shared_ptr< remote_node_manager > node_manager, std::shared_ptr< job_manager > job_manager, std::shared_ptr< services::worklist_scu > worklist_scu=nullptr, std::shared_ptr< di::ILogger > logger=nullptr)
	Construct a prefetch manager with dependencies.

	prefetch_manager (const prefetch_manager_config &config, std::shared_ptr< storage::prefetch_repository > repo, std::shared_ptr< remote_node_manager > node_manager, std::shared_ptr< job_manager > job_manager, std::shared_ptr< services::worklist_scu > worklist_scu=nullptr, std::shared_ptr< di::ILogger > logger=nullptr)
	Construct with custom configuration.

	~prefetch_manager ()
	Destructor - stops scheduler and monitor if running.

	prefetch_manager (const prefetch_manager &)=delete

auto	operator= (const prefetch_manager &) -> prefetch_manager &=delete

	prefetch_manager (prefetch_manager &&)=delete

auto	operator= (prefetch_manager &&) -> prefetch_manager &=delete

auto	add_rule (const prefetch_rule &rule) -> kcenon::pacs::VoidResult
	Add a new prefetch rule.

auto	update_rule (const prefetch_rule &rule) -> kcenon::pacs::VoidResult
	Update an existing prefetch rule.

auto	remove_rule (std::string_view rule_id) -> kcenon::pacs::VoidResult
	Remove a prefetch rule.

auto	get_rule (std::string_view rule_id) const -> std::optional< prefetch_rule >
	Get a rule by ID.

auto	list_rules () const -> std::vector< prefetch_rule >
	List all prefetch rules.

void	process_worklist (const std::vector< core::dicom_dataset > &worklist_items)
	Process worklist items and trigger prefetch.

auto	process_worklist_async (const std::vector< core::dicom_dataset > &worklist_items) -> std::future< void >
	Process worklist items asynchronously.

auto	prefetch_priors (std::string_view patient_id, std::string_view current_modality, std::optional< std::string_view > body_part=std::nullopt) -> prefetch_result
	Prefetch prior studies for a patient.

auto	prefetch_priors_async (std::string_view patient_id, std::string_view current_modality, std::optional< std::string_view > body_part=std::nullopt) -> std::future< prefetch_result >
	Prefetch prior studies asynchronously.

auto	prefetch_study (std::string_view source_node_id, std::string_view study_uid) -> std::string
	Prefetch a specific study.

auto	prefetch_patient (std::string_view source_node_id, std::string_view patient_id, std::chrono::hours lookback=std::chrono::hours{8760}) -> std::string
	Prefetch all studies for a patient.

void	start_scheduler ()
	Start the scheduler for cron-based rules.

void	stop_scheduler ()
	Stop the scheduler.

auto	is_scheduler_running () const noexcept -> bool
	Check if scheduler is running.

void	start_worklist_monitor (std::string_view worklist_node_id)
	Start the worklist monitor.

void	stop_worklist_monitor ()
	Stop the worklist monitor.

auto	is_worklist_monitor_running () const noexcept -> bool
	Check if worklist monitor is running.

auto	pending_prefetches () const -> size_t
	Get number of pending prefetch operations.

auto	completed_today () const -> size_t
	Get number of prefetches completed today.

auto	failed_today () const -> size_t
	Get number of prefetches failed today.

auto	get_rule_statistics (std::string_view rule_id) const -> prefetch_rule_statistics
	Get statistics for a specific rule.

auto	config () const noexcept -> const prefetch_manager_config &
	Get current configuration.

void	set_config (prefetch_manager_config new_config)
	Update configuration.

Private Attributes
std::unique_ptr< impl >	impl_

Detailed Description

Definition at line 111 of file prefetch_manager.h.

Constructor & Destructor Documentation

◆ prefetch_manager() [1/6]

kcenon::pacs::client::prefetch_manager::prefetch_manager	(	prefetch_repositories	repositories,
		std::shared_ptr< remote_node_manager >	node_manager,
		std::shared_ptr< job_manager >	job_manager,
		std::shared_ptr< services::worklist_scu >	worklist_scu = nullptr,
		std::shared_ptr< di::ILogger >	logger = nullptr )

explicit

Construct a prefetch manager from split repositories.

Parameters

repositories	Split prefetch repositories for rules and history
node_manager	Remote node manager for DICOM operations (required)
job_manager	Job manager for async operations (required)
worklist_scu	Worklist SCU for MWL queries (optional)
logger	Logger instance (optional, defaults to NullLogger)

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/prefetch_manager.h.

Definition at line 394 of file prefetch_manager.cpp.

    : prefetch_manager(
          prefetch_manager_config{},
          std::move(repositories),
          std::move(node_manager),
          std::move(job_manager),
          std::move(worklist_scu),
          std::move(logger)) {}

◆ prefetch_manager() [2/6]

kcenon::pacs::client::prefetch_manager::prefetch_manager	(	const prefetch_manager_config &	config,
		prefetch_repositories	repositories,
		std::shared_ptr< remote_node_manager >	node_manager,
		std::shared_ptr< job_manager >	job_manager,
		std::shared_ptr< services::worklist_scu >	worklist_scu = nullptr,
		std::shared_ptr< di::ILogger >	logger = nullptr )

explicit

Construct with custom configuration and split repositories.

Parameters

config	Manager configuration
repositories	Split prefetch repositories for rules and history
node_manager	Remote node manager for DICOM operations (required)
job_manager	Job manager for async operations (required)
worklist_scu	Worklist SCU for MWL queries (optional)
logger	Logger instance (optional, defaults to NullLogger)

Definition at line 408 of file prefetch_manager.cpp.

    : impl_(std::make_unique<impl>()) {
    impl_->config = config;
    impl_->repositories = std::move(repositories);
    impl_->node_manager = std::move(node_manager);
    impl_->job_mgr = std::move(job_manager);
    impl_->worklist_scu = std::move(worklist_scu);
    impl_->logger = logger ? std::move(logger) : std::make_shared<di::NullLogger>();
 
    impl_->load_rules_from_repo();
}

References config(), kcenon::pacs::client::prefetch_manager::impl::config, impl_, kcenon::pacs::client::prefetch_manager::impl::job_mgr, kcenon::pacs::client::prefetch_manager::impl::load_rules_from_repo(), kcenon::pacs::client::prefetch_manager::impl::logger, kcenon::pacs::client::prefetch_manager::impl::node_manager, kcenon::pacs::client::prefetch_manager::impl::repositories, and kcenon::pacs::client::prefetch_manager::impl::worklist_scu.

Here is the call graph for this function:

◆ prefetch_manager() [3/6]

kcenon::pacs::client::prefetch_manager::prefetch_manager	(	std::shared_ptr< storage::prefetch_repository >	repo,
		std::shared_ptr< remote_node_manager >	node_manager,
		std::shared_ptr< job_manager >	job_manager,
		std::shared_ptr< services::worklist_scu >	worklist_scu = nullptr,
		std::shared_ptr< di::ILogger >	logger = nullptr )

explicit

Construct a prefetch manager with dependencies.

Compatibility-only overload. Prefer split repositories for new wiring.

Parameters

repo	Prefetch repository for persistence (required)
node_manager	Remote node manager for DICOM operations (required)
job_manager	Job manager for async operations (required)
worklist_scu	Worklist SCU for MWL queries (optional)
logger	Logger instance (optional, defaults to NullLogger)

Definition at line 426 of file prefetch_manager.cpp.

    : prefetch_manager(
          prefetch_manager_config{},
          std::move(repo),
          std::move(node_manager),
          std::move(job_manager),
          std::move(worklist_scu),
          std::move(logger)) {}

◆ prefetch_manager() [4/6]

kcenon::pacs::client::prefetch_manager::prefetch_manager	(	const prefetch_manager_config &	config,
		std::shared_ptr< storage::prefetch_repository >	repo,
		std::shared_ptr< remote_node_manager >	node_manager,
		std::shared_ptr< job_manager >	job_manager,
		std::shared_ptr< services::worklist_scu >	worklist_scu = nullptr,
		std::shared_ptr< di::ILogger >	logger = nullptr )

explicit

Construct with custom configuration.

Compatibility-only overload. Prefer split repositories for new wiring.

Parameters

config	Manager configuration
repo	Prefetch repository for persistence (required)
node_manager	Remote node manager for DICOM operations (required)
job_manager	Job manager for async operations (required)
worklist_scu	Worklist SCU for MWL queries (optional)
logger	Logger instance (optional, defaults to NullLogger)

Definition at line 440 of file prefetch_manager.cpp.

    : impl_(std::make_unique<impl>()) {
    impl_->config = config;
    impl_->compatibility_repo = std::move(repo);
    impl_->node_manager = std::move(node_manager);
    impl_->job_mgr = std::move(job_manager);
    impl_->worklist_scu = std::move(worklist_scu);
    impl_->logger = logger ? std::move(logger) : std::make_shared<di::NullLogger>();
 
    // Initialize tables if repository exists
    if (impl_->compatibility_repo) {
        [[maybe_unused]] auto result = impl_->compatibility_repo->initialize_tables();
    }
 
    // Load rules from repository
    impl_->load_rules_from_repo();
}

References kcenon::pacs::client::prefetch_manager::impl::compatibility_repo, config(), kcenon::pacs::client::prefetch_manager::impl::config, impl_, kcenon::pacs::client::prefetch_manager::impl::job_mgr, kcenon::pacs::client::prefetch_manager::impl::load_rules_from_repo(), kcenon::pacs::client::prefetch_manager::impl::logger, kcenon::pacs::client::prefetch_manager::impl::node_manager, and kcenon::pacs::client::prefetch_manager::impl::worklist_scu.

Here is the call graph for this function:

◆ ~prefetch_manager()

kcenon::pacs::client::prefetch_manager::~prefetch_manager ( )

Destructor - stops scheduler and monitor if running.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/prefetch_manager.h.

Definition at line 464 of file prefetch_manager.cpp.

                                    {
    stop_scheduler();
    stop_worklist_monitor();
}

References stop_scheduler(), and stop_worklist_monitor().

Here is the call graph for this function:

◆ prefetch_manager() [5/6]

kcenon::pacs::client::prefetch_manager::prefetch_manager ( const prefetch_manager & )

delete

◆ prefetch_manager() [6/6]

kcenon::pacs::client::prefetch_manager::prefetch_manager ( prefetch_manager && )

delete

Member Function Documentation

◆ add_rule()

kcenon::pacs::VoidResult kcenon::pacs::client::prefetch_manager::add_rule ( const prefetch_rule & rule ) -> kcenon::pacs::VoidResult

nodiscard

Add a new prefetch rule.

Parameters

rule	The rule to add

Returns: VoidResult indicating success or error

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/prefetch_manager.h.

Definition at line 473 of file prefetch_manager.cpp.

                                                                         {
    prefetch_rule new_rule = rule;
    if (new_rule.rule_id.empty()) {
        new_rule.rule_id = generate_uuid();
    }
 
    // Save to repository
    #ifdef PACS_WITH_DATABASE_SYSTEM
    if (impl_->repositories.rules) {
        auto result = impl_->repositories.rules->save(new_rule);
        if (result.is_err()) {
            return result.error();
        }
    } else if (impl_->compatibility_repo) {
        auto result = impl_->compatibility_repo->save_rule(new_rule);
        if (result.is_err()) {
            return result;
        }
    }
    #else
    if (impl_->compatibility_repo) {
        auto result = impl_->compatibility_repo->save_rule(new_rule);
        if (result.is_err()) {
            return result;
        }
    }
    #endif
 
    // Update cache
    {
        std::unique_lock lock(impl_->rules_mutex);
        impl_->rules_cache.push_back(new_rule);
    }
 
    impl_->logger->info_fmt("Added prefetch rule: {} ({})", new_rule.name, new_rule.rule_id);
    return kcenon::common::ok();
}

References kcenon::pacs::client::prefetch_manager::impl::compatibility_repo, impl_, kcenon::pacs::client::prefetch_manager::impl::logger, kcenon::pacs::client::prefetch_rule::name, kcenon::pacs::client::prefetch_manager::impl::repositories, kcenon::pacs::client::prefetch_rule::rule_id, kcenon::pacs::client::prefetch_repositories::rules, kcenon::pacs::client::prefetch_manager::impl::rules_cache, and kcenon::pacs::client::prefetch_manager::impl::rules_mutex.

◆ completed_today()

size_t kcenon::pacs::client::prefetch_manager::completed_today ( ) const -> size_t

nodiscard

Get number of prefetches completed today.

Returns: Number of successful prefetches today

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/prefetch_manager.h.

Definition at line 863 of file prefetch_manager.cpp.

                                               {
    #ifdef PACS_WITH_DATABASE_SYSTEM
    if (impl_->repositories.history) {
        auto result =
            impl_->repositories.history->count_by_status_on_current_date("completed");
        return result.is_ok() ? result.value() : 0;
    }
    #endif
    if (impl_->compatibility_repo) {
        return impl_->compatibility_repo->count_completed_today();
    }
    return 0;
}

References kcenon::pacs::client::prefetch_manager::impl::compatibility_repo, kcenon::pacs::client::prefetch_repositories::history, impl_, and kcenon::pacs::client::prefetch_manager::impl::repositories.

◆ config()

const prefetch_manager_config & kcenon::pacs::client::prefetch_manager::config ( ) const -> const prefetch_manager_config&

nodiscardnoexcept

Get current configuration.

Returns: Current manager configuration

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/prefetch_manager.h.

Definition at line 908 of file prefetch_manager.cpp.

                                                                       {
    return impl_->config;
}

References kcenon::pacs::client::prefetch_manager::impl::config, and impl_.

Referenced by prefetch_manager(), and prefetch_manager().

Here is the caller graph for this function:

◆ failed_today()

size_t kcenon::pacs::client::prefetch_manager::failed_today ( ) const -> size_t

nodiscard

Get number of prefetches failed today.

Returns: Number of failed prefetches today

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/prefetch_manager.h.

Definition at line 877 of file prefetch_manager.cpp.

                                            {
    #ifdef PACS_WITH_DATABASE_SYSTEM
    if (impl_->repositories.history) {
        auto result =
            impl_->repositories.history->count_by_status_on_current_date("failed");
        return result.is_ok() ? result.value() : 0;
    }
    #endif
    if (impl_->compatibility_repo) {
        return impl_->compatibility_repo->count_failed_today();
    }
    return 0;
}

References kcenon::pacs::client::prefetch_manager::impl::compatibility_repo, kcenon::pacs::client::prefetch_repositories::history, impl_, and kcenon::pacs::client::prefetch_manager::impl::repositories.

◆ get_rule()

std::optional< prefetch_rule > kcenon::pacs::client::prefetch_manager::get_rule ( std::string_view rule_id ) const -> std::optional<prefetch_rule>

nodiscard

Get a rule by ID.

Parameters

rule_id ID of the rule to retrieve

Returns: Optional containing the rule if found

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/prefetch_manager.h.

Definition at line 589 of file prefetch_manager.cpp.

                                                                                  {
    std::shared_lock lock(impl_->rules_mutex);
    for (const auto& rule : impl_->rules_cache) {
        if (rule.rule_id == rule_id) {
            return rule;
        }
    }
    return std::nullopt;
}

References impl_, kcenon::pacs::client::prefetch_manager::impl::rules_cache, and kcenon::pacs::client::prefetch_manager::impl::rules_mutex.

Referenced by get_rule_statistics().

Here is the caller graph for this function:

◆ get_rule_statistics()

prefetch_rule_statistics kcenon::pacs::client::prefetch_manager::get_rule_statistics ( std::string_view rule_id ) const -> prefetch_rule_statistics

nodiscard

Get statistics for a specific rule.

Parameters

rule_id Rule ID to get statistics for

Returns: Statistics for the rule

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/prefetch_manager.h.

Definition at line 891 of file prefetch_manager.cpp.

                                  {
    prefetch_rule_statistics stats;
 
    auto rule = get_rule(rule_id);
    if (rule) {
        stats.triggered_count = rule->triggered_count;
        stats.studies_prefetched = rule->studies_prefetched;
    }
 
    return stats;
}

References get_rule().

Here is the call graph for this function:

◆ is_scheduler_running()

bool kcenon::pacs::client::prefetch_manager::is_scheduler_running ( ) const -> bool

nodiscardnoexcept

Check if scheduler is running.

Returns: true if the scheduler is active

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/prefetch_manager.h.

Definition at line 809 of file prefetch_manager.cpp.

                                                           {
    return impl_->scheduler_running.load();
}

References impl_, and kcenon::pacs::client::prefetch_manager::impl::scheduler_running.

◆ is_worklist_monitor_running()

bool kcenon::pacs::client::prefetch_manager::is_worklist_monitor_running ( ) const -> bool

nodiscardnoexcept

Check if worklist monitor is running.

Returns: true if the worklist monitor is active

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/prefetch_manager.h.

Definition at line 851 of file prefetch_manager.cpp.

                                                                  {
    return impl_->worklist_monitor_running.load();
}

References impl_, and kcenon::pacs::client::prefetch_manager::impl::worklist_monitor_running.

◆ list_rules()

std::vector< prefetch_rule > kcenon::pacs::client::prefetch_manager::list_rules ( ) const -> std::vector<prefetch_rule>

nodiscard

List all prefetch rules.

Returns: Vector of all rules

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/prefetch_manager.h.

Definition at line 599 of file prefetch_manager.cpp.

                                                            {
    std::shared_lock lock(impl_->rules_mutex);
    return impl_->rules_cache;
}

References impl_, kcenon::pacs::client::prefetch_manager::impl::rules_cache, and kcenon::pacs::client::prefetch_manager::impl::rules_mutex.

◆ operator=() [1/2]

auto kcenon::pacs::client::prefetch_manager::operator= ( const prefetch_manager & ) -> prefetch_manager &=delete

delete

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/prefetch_manager.h.

◆ operator=() [2/2]

auto kcenon::pacs::client::prefetch_manager::operator= ( prefetch_manager && ) -> prefetch_manager &=delete

delete

◆ pending_prefetches()

size_t kcenon::pacs::client::prefetch_manager::pending_prefetches ( ) const -> size_t

nodiscard

Get number of pending prefetch operations.

Returns: Number of prefetches currently queued

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/prefetch_manager.h.

Definition at line 859 of file prefetch_manager.cpp.

                                                  {
    return impl_->pending_count.load();
}

References impl_, and kcenon::pacs::client::prefetch_manager::impl::pending_count.

◆ prefetch_patient()

std::string kcenon::pacs::client::prefetch_manager::prefetch_patient	(	std::string_view	source_node_id,
		std::string_view	patient_id,
		std::chrono::hours	lookback = std::chrono::hours{8760} ) -> std::string

nodiscard

Prefetch all studies for a patient.

Parameters

source_node_id	Source node to retrieve from
patient_id	Patient ID to prefetch studies for
lookback	Lookback period (default: 1 year)

Returns: Job ID for tracking the prefetch operation

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/prefetch_manager.h.

Definition at line 754 of file prefetch_manager.cpp.

                             {
    (void)lookback;  // Reserved for future time-based filtering
    // Create prefetch job for the patient
    if (impl_->job_mgr) {
        auto job_id = impl_->job_mgr->create_prefetch_job(
            source_node_id, patient_id, job_priority::low);
 
        impl_->logger->info_fmt("Created prefetch job {} for patient {}",
            job_id, std::string(patient_id));
        return job_id;
    }
 
    return "";
}

References impl_, kcenon::pacs::client::prefetch_manager::impl::job_mgr, kcenon::pacs::client::prefetch_manager::impl::logger, and kcenon::pacs::client::low.

◆ prefetch_priors()

prefetch_result kcenon::pacs::client::prefetch_manager::prefetch_priors	(	std::string_view	patient_id,
		std::string_view	current_modality,
		std::optional< std::string_view >	body_part = std::nullopt ) -> prefetch_result

nodiscard

Prefetch prior studies for a patient.

Searches configured source nodes for prior studies matching the patient and modality criteria.

Parameters

patient_id	Patient ID to search for
current_modality	Current exam modality
body_part	Optional body part filter

Returns: Prefetch result with statistics

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/prefetch_manager.h.

Definition at line 649 of file prefetch_manager.cpp.

                                           {
    auto start_time = std::chrono::steady_clock::now();
    prefetch_result result;
    result.patient_id = std::string(patient_id);
 
    // Find matching prior study rules
    auto rules = impl_->get_matching_rules(
        prefetch_trigger::prior_studies,
        std::string(current_modality),
        body_part ? std::string(*body_part) : "",
        "");
 
    if (rules.empty()) {
        impl_->logger->debug_fmt("No prior study rules match for patient {} modality {}",
            std::string(patient_id), std::string(current_modality));
        return result;
    }
 
    // Use the first matching rule (or could combine multiple)
    const auto& rule = rules.front();
 
    // Query prior studies from each source node
    for (const auto& source_node_id : rule.source_node_ids) {
        auto node = impl_->node_manager->get_node(source_node_id);
        if (!node) {
            impl_->logger->warn_fmt("Source node {} not found", source_node_id);
            continue;
        }
 
        // Query for prior studies
        // In production, this would use query_scu to search for studies
        // For now, create prefetch jobs based on rule configuration
 
        // Record that we attempted prefetch
        impl_->logger->info_fmt("Prefetching priors for patient {} from node {}",
            std::string(patient_id), source_node_id);
    }
 
    auto end_time = std::chrono::steady_clock::now();
    result.elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
        end_time - start_time);
 
    return result;
}

References kcenon::pacs::client::body_part, kcenon::pacs::client::prefetch_result::elapsed, kcenon::pacs::client::prefetch_manager::impl::get_matching_rules(), impl_, kcenon::pacs::client::prefetch_manager::impl::logger, kcenon::pacs::client::prefetch_manager::impl::node_manager, kcenon::pacs::client::prefetch_result::patient_id, and kcenon::pacs::client::prior_studies.

Referenced by prefetch_priors_async(), and process_worklist().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ prefetch_priors_async()

std::future< prefetch_result > kcenon::pacs::client::prefetch_manager::prefetch_priors_async	(	std::string_view	patient_id,
		std::string_view	current_modality,
		std::optional< std::string_view >	body_part = std::nullopt ) -> std::future<prefetch_result>

nodiscard

Prefetch prior studies asynchronously.

Parameters

patient_id	Patient ID to search for
current_modality	Current exam modality
body_part	Optional body part filter

Returns: Future containing prefetch result

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/prefetch_manager.h.

Definition at line 697 of file prefetch_manager.cpp.

                                           {
    std::string pid(patient_id);
    std::string mod(current_modality);
    std::optional<std::string> bp = body_part ?
        std::optional<std::string>(std::string(*body_part)) : std::nullopt;
 
    return std::async(std::launch::async, [this, pid, mod, bp]() {
        return prefetch_priors(pid, mod, bp ? std::optional<std::string_view>(*bp) : std::nullopt);
    });
}

References kcenon::pacs::client::body_part, and prefetch_priors().

Here is the call graph for this function:

◆ prefetch_study()

std::string kcenon::pacs::client::prefetch_manager::prefetch_study	(	std::string_view	source_node_id,
		std::string_view	study_uid ) -> std::string

nodiscard

Prefetch a specific study.

Parameters

source_node_id	Source node to retrieve from
study_uid	Study Instance UID to prefetch

Returns: Job ID for tracking the prefetch operation

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/prefetch_manager.h.

Definition at line 715 of file prefetch_manager.cpp.

                              {
    // Check deduplication
    if (impl_->config.deduplicate_requests) {
        if (impl_->is_study_pending(std::string(study_uid))) {
            impl_->logger->debug_fmt("Study {} already pending", std::string(study_uid));
            return "";
        }
        if (impl_->is_study_local(study_uid)) {
            impl_->logger->debug_fmt("Study {} already local", std::string(study_uid));
            return "";
        }
    }
 
    // Mark as pending
    impl_->mark_study_pending(std::string(study_uid));
 
    // Create retrieve job
    if (impl_->job_mgr) {
        auto job_id = impl_->job_mgr->create_retrieve_job(
            source_node_id, study_uid, std::nullopt, job_priority::low);
 
        // Record history
        impl_->record_prefetch_history(
            "", // patient_id unknown
            std::string(study_uid),
            "", // no rule
            std::string(source_node_id),
            job_id,
            "pending");
 
        impl_->logger->info_fmt("Created prefetch job {} for study {}", job_id, std::string(study_uid));
        return job_id;
    }
 
    return "";
}

Here is the call graph for this function:

◆ process_worklist()

void kcenon::pacs::client::prefetch_manager::process_worklist ( const std::vector< core::dicom_dataset > & worklist_items )

Process worklist items and trigger prefetch.

Evaluates each worklist item against enabled rules and triggers appropriate prefetch operations.

Parameters

worklist_items Worklist items from MWL query

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/prefetch_manager.h.

Definition at line 608 of file prefetch_manager.cpp.

                                                        {
    for (const auto& item : worklist_items) {
        // Extract relevant fields from worklist item
        auto patient_id = get_dataset_value(item, core::tags::patient_id);
        auto modality_val = get_dataset_value(item, core::tags::modality);
        auto body_part = get_dataset_value(item, body_part_examined_tag);
        auto station_ae = get_dataset_value(item, core::tags::scheduled_station_ae_title);
 
        if (patient_id.empty()) {
            continue;
        }
 
        // Find matching rules
        auto rules = impl_->get_matching_rules(
            prefetch_trigger::worklist_match, modality_val, body_part, station_ae);
 
        for (const auto& rule : rules) {
            // Trigger prefetch for this patient
            auto result = prefetch_priors(patient_id, modality_val, body_part);
 
            // Update rule statistics
            impl_->increment_rule_stats(rule.rule_id, result.studies_prefetched);
 
            impl_->logger->debug_fmt("Worklist prefetch for patient {}: {} studies prefetched",
                patient_id, result.studies_prefetched);
        }
    }
}

References kcenon::pacs::client::body_part, kcenon::pacs::client::prefetch_manager::impl::get_matching_rules(), impl_, kcenon::pacs::client::prefetch_manager::impl::increment_rule_stats(), kcenon::pacs::client::prefetch_manager::impl::logger, kcenon::pacs::core::tags::modality, kcenon::pacs::core::tags::patient_id, prefetch_priors(), kcenon::pacs::core::tags::scheduled_station_ae_title, kcenon::pacs::client::station_ae, and kcenon::pacs::client::worklist_match.

Referenced by process_worklist_async().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_worklist_async()

std::future< void > kcenon::pacs::client::prefetch_manager::process_worklist_async ( const std::vector< core::dicom_dataset > & worklist_items ) -> std::future<void>

nodiscard

Process worklist items asynchronously.

Parameters

worklist_items Worklist items from MWL query

Returns: Future that completes when processing is done

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/prefetch_manager.h.

Definition at line 638 of file prefetch_manager.cpp.

                                                        {
    return std::async(std::launch::async, [this, worklist_items]() {
        process_worklist(worklist_items);
    });
}

References process_worklist().

Here is the call graph for this function:

◆ remove_rule()

kcenon::pacs::VoidResult kcenon::pacs::client::prefetch_manager::remove_rule ( std::string_view rule_id ) -> kcenon::pacs::VoidResult

nodiscard

Remove a prefetch rule.

Parameters

rule_id ID of the rule to remove

Returns: VoidResult indicating success or error

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/prefetch_manager.h.

Definition at line 553 of file prefetch_manager.cpp.

                                                                         {
    // Remove from repository
    #ifdef PACS_WITH_DATABASE_SYSTEM
    if (impl_->repositories.rules) {
        auto result = impl_->repositories.rules->remove(std::string(rule_id));
        if (result.is_err()) {
            return result;
        }
    } else if (impl_->compatibility_repo) {
        auto result = impl_->compatibility_repo->remove_rule(rule_id);
        if (result.is_err()) {
            return result;
        }
    }
    #else
    if (impl_->compatibility_repo) {
        auto result = impl_->compatibility_repo->remove_rule(rule_id);
        if (result.is_err()) {
            return result;
        }
    }
    #endif
 
    // Remove from cache
    {
        std::unique_lock lock(impl_->rules_mutex);
        impl_->rules_cache.erase(
            std::remove_if(impl_->rules_cache.begin(), impl_->rules_cache.end(),
                [&rule_id](const prefetch_rule& r) { return r.rule_id == rule_id; }),
            impl_->rules_cache.end());
    }
 
    impl_->logger->info_fmt("Removed prefetch rule: {}", std::string(rule_id));
    return kcenon::common::ok();
}

References kcenon::pacs::client::prefetch_manager::impl::compatibility_repo, impl_, kcenon::pacs::client::prefetch_manager::impl::logger, kcenon::pacs::client::prefetch_manager::impl::repositories, kcenon::pacs::client::prefetch_repositories::rules, kcenon::pacs::client::prefetch_manager::impl::rules_cache, and kcenon::pacs::client::prefetch_manager::impl::rules_mutex.

◆ set_config()

void kcenon::pacs::client::prefetch_manager::set_config ( prefetch_manager_config new_config )

Update configuration.

Parameters

new_config New configuration to apply

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/prefetch_manager.h.

Definition at line 912 of file prefetch_manager.cpp.

                                                                    {
    impl_->config = new_config;
}

References kcenon::pacs::client::prefetch_manager::impl::config, and impl_.

◆ start_scheduler()

void kcenon::pacs::client::prefetch_manager::start_scheduler ( )

Start the scheduler for cron-based rules.

Begins checking and executing scheduled prefetch rules. Does nothing if already running.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/prefetch_manager.h.

Definition at line 776 of file prefetch_manager.cpp.

                                       {
    if (impl_->scheduler_running.load()) {
        return;
    }
 
    impl_->scheduler_running.store(true);
    impl_->scheduler_thread = std::thread([this]() {
        impl_->scheduler_loop();
    });
 
    impl_->logger->info("Started prefetch scheduler");
}

References impl_, kcenon::pacs::client::prefetch_manager::impl::logger, kcenon::pacs::client::prefetch_manager::impl::scheduler_loop(), kcenon::pacs::client::prefetch_manager::impl::scheduler_running, and kcenon::pacs::client::prefetch_manager::impl::scheduler_thread.

Here is the call graph for this function:

◆ start_worklist_monitor()

void kcenon::pacs::client::prefetch_manager::start_worklist_monitor ( std::string_view worklist_node_id )

Start the worklist monitor.

Begins periodic polling of the worklist for new items.

Parameters

worklist_node_id Node ID for worklist queries

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/prefetch_manager.h.

Definition at line 817 of file prefetch_manager.cpp.

                                                                             {
    if (impl_->worklist_monitor_running.load()) {
        return;
    }
 
    impl_->worklist_node_id = std::string(worklist_node_id);
    impl_->worklist_monitor_running.store(true);
    impl_->worklist_monitor_thread = std::thread([this]() {
        impl_->worklist_monitor_loop();
    });
 
    impl_->logger->info_fmt("Started worklist monitor for node {}", std::string(worklist_node_id));
}

References impl_, kcenon::pacs::client::prefetch_manager::impl::logger, kcenon::pacs::client::prefetch_manager::impl::worklist_monitor_loop(), kcenon::pacs::client::prefetch_manager::impl::worklist_monitor_running, kcenon::pacs::client::prefetch_manager::impl::worklist_monitor_thread, and kcenon::pacs::client::prefetch_manager::impl::worklist_node_id.

Here is the call graph for this function:

◆ stop_scheduler()

void kcenon::pacs::client::prefetch_manager::stop_scheduler ( )

Stop the scheduler.

Stops the scheduler thread. Does nothing if not running.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/prefetch_manager.h.

Definition at line 789 of file prefetch_manager.cpp.

                                      {
    if (!impl_->scheduler_running.load()) {
        return;
    }
 
    impl_->scheduler_running.store(false);
 
    // Notify with lock held to ensure thread sees the flag change
    {
        std::lock_guard<std::mutex> lock(impl_->scheduler_mutex);
        impl_->scheduler_cv.notify_all();
    }
 
    if (impl_->scheduler_thread.joinable()) {
        impl_->scheduler_thread.join();
    }
 
    impl_->logger->info("Stopped prefetch scheduler");
}

References impl_, kcenon::pacs::client::prefetch_manager::impl::logger, kcenon::pacs::client::prefetch_manager::impl::scheduler_cv, kcenon::pacs::client::prefetch_manager::impl::scheduler_mutex, kcenon::pacs::client::prefetch_manager::impl::scheduler_running, and kcenon::pacs::client::prefetch_manager::impl::scheduler_thread.

Referenced by ~prefetch_manager().

Here is the caller graph for this function:

◆ stop_worklist_monitor()

void kcenon::pacs::client::prefetch_manager::stop_worklist_monitor ( )

Stop the worklist monitor.

Stops periodic worklist polling. Does nothing if not running.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/prefetch_manager.h.

Definition at line 831 of file prefetch_manager.cpp.

                                             {
    if (!impl_->worklist_monitor_running.load()) {
        return;
    }
 
    impl_->worklist_monitor_running.store(false);
 
    // Notify with lock held to ensure thread sees the flag change
    {
        std::lock_guard<std::mutex> lock(impl_->worklist_mutex);
        impl_->worklist_cv.notify_all();
    }
 
    if (impl_->worklist_monitor_thread.joinable()) {
        impl_->worklist_monitor_thread.join();
    }
 
    impl_->logger->info("Stopped worklist monitor");
}

References impl_, kcenon::pacs::client::prefetch_manager::impl::logger, kcenon::pacs::client::prefetch_manager::impl::worklist_cv, kcenon::pacs::client::prefetch_manager::impl::worklist_monitor_running, kcenon::pacs::client::prefetch_manager::impl::worklist_monitor_thread, and kcenon::pacs::client::prefetch_manager::impl::worklist_mutex.

Referenced by ~prefetch_manager().

Here is the caller graph for this function:

◆ update_rule()

kcenon::pacs::VoidResult kcenon::pacs::client::prefetch_manager::update_rule ( const prefetch_rule & rule ) -> kcenon::pacs::VoidResult

nodiscard

Update an existing prefetch rule.

Parameters

rule	The rule to update (rule_id must match existing)

Returns: VoidResult indicating success or error

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/prefetch_manager.h.

Definition at line 511 of file prefetch_manager.cpp.

                                                                            {
    if (rule.rule_id.empty()) {
        return kcenon::pacs::pacs_void_error(-1, "Rule ID is required for update");
    }
 
    // Save to repository
    #ifdef PACS_WITH_DATABASE_SYSTEM
    if (impl_->repositories.rules) {
        auto result = impl_->repositories.rules->save(rule);
        if (result.is_err()) {
            return result.error();
        }
    } else if (impl_->compatibility_repo) {
        auto result = impl_->compatibility_repo->save_rule(rule);
        if (result.is_err()) {
            return result;
        }
    }
    #else
    if (impl_->compatibility_repo) {
        auto result = impl_->compatibility_repo->save_rule(rule);
        if (result.is_err()) {
            return result;
        }
    }
    #endif
 
    // Update cache
    {
        std::unique_lock lock(impl_->rules_mutex);
        for (auto& cached_rule : impl_->rules_cache) {
            if (cached_rule.rule_id == rule.rule_id) {
                cached_rule = rule;
                break;
            }
        }
    }
 
    impl_->logger->info_fmt("Updated prefetch rule: {}", rule.rule_id);
    return kcenon::common::ok();
}

References kcenon::pacs::client::prefetch_manager::impl::compatibility_repo, impl_, kcenon::pacs::client::prefetch_manager::impl::logger, kcenon::pacs::pacs_void_error(), kcenon::pacs::client::prefetch_manager::impl::repositories, kcenon::pacs::client::prefetch_rule::rule_id, kcenon::pacs::client::prefetch_repositories::rules, kcenon::pacs::client::prefetch_manager::impl::rules_cache, and kcenon::pacs::client::prefetch_manager::impl::rules_mutex.

Here is the call graph for this function:

Member Data Documentation

◆ impl_

std::unique_ptr<impl> kcenon::pacs::client::prefetch_manager::impl_

private

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

include/kcenon/pacs/client/prefetch_manager.h
src/client/prefetch_manager.cpp

Classes

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ prefetch_manager() [1/6]

◆ prefetch_manager() [2/6]

◆ prefetch_manager() [3/6]

◆ prefetch_manager() [4/6]

◆ ~prefetch_manager()

◆ prefetch_manager() [5/6]

◆ prefetch_manager() [6/6]

Member Function Documentation

◆ add_rule()

◆ completed_today()

◆ config()

◆ failed_today()

◆ get_rule()

◆ get_rule_statistics()

◆ is_scheduler_running()

◆ is_worklist_monitor_running()

◆ list_rules()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ pending_prefetches()

◆ prefetch_patient()

◆ prefetch_priors()

◆ prefetch_priors_async()

◆ prefetch_study()

◆ process_worklist()

◆ process_worklist_async()

◆ remove_rule()

◆ set_config()

◆ start_scheduler()

◆ start_worklist_monitor()

◆ stop_scheduler()

◆ stop_worklist_monitor()

◆ update_rule()

Member Data Documentation

◆ impl_