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

Public Member Functions
void	load_rules_from_repo ()

void	save_rule_to_repo (const prefetch_rule &rule)

bool	is_study_pending (const std::string &study_uid)

void	mark_study_pending (const std::string &study_uid)

void	mark_study_complete (const std::string &study_uid)

bool	is_study_local (std::string_view study_uid) const

std::vector< prefetch_rule >	get_matching_rules (prefetch_trigger trigger, const std::string &modality, const std::string &body_part, const std::string &station_ae)

void	record_prefetch_history (const std::string &patient_id, const std::string &study_uid, const std::string &rule_id, const std::string &source_node_id, const std::string &job_id, const std::string &status)

void	increment_rule_stats (const std::string &rule_id, size_t studies)

void	scheduler_loop ()

void	check_scheduled_rules ()

void	worklist_monitor_loop ()

void	query_and_process_worklist ()

Public Attributes
prefetch_manager_config	config

prefetch_repositories	repositories

std::shared_ptr< storage::prefetch_repository >	compatibility_repo

std::shared_ptr< remote_node_manager >	node_manager

std::shared_ptr< job_manager >	job_mgr

std::shared_ptr< services::worklist_scu >	worklist_scu

std::shared_ptr< di::ILogger >	logger

std::vector< prefetch_rule >	rules_cache

std::shared_mutex	rules_mutex

std::thread	scheduler_thread

std::atomic< bool >	scheduler_running {false}

std::condition_variable	scheduler_cv

std::mutex	scheduler_mutex

std::thread	worklist_monitor_thread

std::atomic< bool >	worklist_monitor_running {false}

std::string	worklist_node_id

std::condition_variable	worklist_cv

std::mutex	worklist_mutex

std::unordered_set< std::string >	pending_study_uids

std::mutex	pending_mutex

std::atomic< size_t >	pending_count {0}

Detailed Description

Definition at line 120 of file prefetch_manager.cpp.

Member Function Documentation

◆ check_scheduled_rules()

void kcenon::pacs::client::prefetch_manager::impl::check_scheduled_rules ( )

inline

Definition at line 340 of file prefetch_manager.cpp.

                                 {
        std::shared_lock lock(rules_mutex);
        for (const auto& rule : rules_cache) {
            if (!rule.enabled) continue;
            if (rule.trigger != prefetch_trigger::scheduled_exam) continue;
            if (rule.schedule_cron.empty()) continue;
 
            // Simple cron check - in production would use proper cron parsing
            // For now, just check if rule should run
            // This is a placeholder for actual cron implementation
        }
    }

References rules_cache, rules_mutex, and kcenon::pacs::client::scheduled_exam.

Referenced by scheduler_loop().

Here is the caller graph for this function:

◆ get_matching_rules()

std::vector< prefetch_rule > kcenon::pacs::client::prefetch_manager::impl::get_matching_rules	(	prefetch_trigger	trigger,
		const std::string &	modality,
		const std::string &	body_part,
		const std::string &	station_ae )

inline

Definition at line 230 of file prefetch_manager.cpp.

                                     {
        std::vector<prefetch_rule> matches;
 
        std::shared_lock lock(rules_mutex);
        for (const auto& rule : rules_cache) {
            if (!rule.enabled) continue;
            if (rule.trigger != trigger) continue;
 
            if (!matches_filter(modality, rule.modality_filter)) continue;
            if (!matches_filter(body_part, rule.body_part_filter)) continue;
            if (!matches_filter(station_ae, rule.station_ae_filter)) continue;
 
            matches.push_back(rule);
        }
 
        return matches;
    }

References kcenon::pacs::client::body_part, kcenon::pacs::client::modality, rules_cache, rules_mutex, and kcenon::pacs::client::station_ae.

Referenced by kcenon::pacs::client::prefetch_manager::prefetch_priors(), and kcenon::pacs::client::prefetch_manager::process_worklist().

Here is the caller graph for this function:

◆ increment_rule_stats()

void kcenon::pacs::client::prefetch_manager::impl::increment_rule_stats	(	const std::string &	rule_id,
		size_t	studies )

inline

Definition at line 289 of file prefetch_manager.cpp.

                                                                        {
        #ifdef PACS_WITH_DATABASE_SYSTEM
        if (!repositories.rules && !compatibility_repo) return;
        #else
        if (!compatibility_repo) return;
        #endif
 
        #ifdef PACS_WITH_DATABASE_SYSTEM
        if (repositories.rules) {
            [[maybe_unused]] auto result1 =
                repositories.rules->increment_triggered(rule_id);
            if (studies > 0) {
                [[maybe_unused]] auto result2 =
                    repositories.rules->increment_studies_prefetched(rule_id, studies);
            }
        } else if (compatibility_repo) {
            [[maybe_unused]] auto result1 =
                compatibility_repo->increment_triggered(rule_id);
            if (studies > 0) {
                [[maybe_unused]] auto result2 =
                    compatibility_repo->increment_studies_prefetched(rule_id, studies);
            }
        }
        #else
        [[maybe_unused]] auto result1 =
            compatibility_repo->increment_triggered(rule_id);
        if (studies > 0) {
            [[maybe_unused]] auto result2 =
                compatibility_repo->increment_studies_prefetched(rule_id, studies);
        }
        #endif
    }

References compatibility_repo, repositories, and kcenon::pacs::client::prefetch_repositories::rules.

Referenced by kcenon::pacs::client::prefetch_manager::process_worklist().

Here is the caller graph for this function:

◆ is_study_local()

bool kcenon::pacs::client::prefetch_manager::impl::is_study_local ( std::string_view study_uid ) const

inline

Definition at line 216 of file prefetch_manager.cpp.

                                                        {
        // Check history for completed prefetch
        #ifdef PACS_WITH_DATABASE_SYSTEM
        if (repositories.history) {
            auto result = repositories.history->is_study_prefetched(study_uid);
            return result.is_ok() && result.value();
        }
        #endif
        if (compatibility_repo) {
            return compatibility_repo->is_study_prefetched(study_uid);
        }
        return false;
    }

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

Referenced by kcenon::pacs::client::prefetch_manager::prefetch_study().

Here is the caller graph for this function:

◆ is_study_pending()

bool kcenon::pacs::client::prefetch_manager::impl::is_study_pending ( const std::string & study_uid )

inline

Definition at line 196 of file prefetch_manager.cpp.

                                                      {
        std::lock_guard lock(pending_mutex);
        return pending_study_uids.count(study_uid) > 0;
    }

References pending_mutex, and pending_study_uids.

Referenced by kcenon::pacs::client::prefetch_manager::prefetch_study().

Here is the caller graph for this function:

◆ load_rules_from_repo()

void kcenon::pacs::client::prefetch_manager::impl::load_rules_from_repo ( )

inline

Definition at line 160 of file prefetch_manager.cpp.

                                {
        #ifdef PACS_WITH_DATABASE_SYSTEM
        if (repositories.rules) {
            auto result = repositories.rules->find_enabled();
            if (result.is_err()) {
                return;
            }
 
            std::unique_lock lock(rules_mutex);
            rules_cache = std::move(result.value());
            return;
        }
        #endif
 
        if (!compatibility_repo) {
            return;
        }
 
        std::unique_lock lock(rules_mutex);
        rules_cache = compatibility_repo->find_enabled_rules();
    }

References compatibility_repo, repositories, kcenon::pacs::client::prefetch_repositories::rules, rules_cache, and rules_mutex.

Referenced by kcenon::pacs::client::prefetch_manager::prefetch_manager(), and kcenon::pacs::client::prefetch_manager::prefetch_manager().

Here is the caller graph for this function:

◆ mark_study_complete()

void kcenon::pacs::client::prefetch_manager::impl::mark_study_complete ( const std::string & study_uid )

inline

Definition at line 207 of file prefetch_manager.cpp.

                                                         {
        std::lock_guard lock(pending_mutex);
        pending_study_uids.erase(study_uid);
        auto count = pending_count.load();
        if (count > 0) {
            pending_count.fetch_sub(1);
        }
    }

References pending_count, pending_mutex, and pending_study_uids.

◆ mark_study_pending()

void kcenon::pacs::client::prefetch_manager::impl::mark_study_pending ( const std::string & study_uid )

inline

Definition at line 201 of file prefetch_manager.cpp.

                                                        {
        std::lock_guard lock(pending_mutex);
        pending_study_uids.insert(study_uid);
        pending_count.fetch_add(1);
    }

References pending_count, pending_mutex, and pending_study_uids.

Referenced by kcenon::pacs::client::prefetch_manager::prefetch_study().

Here is the caller graph for this function:

◆ query_and_process_worklist()

void kcenon::pacs::client::prefetch_manager::impl::query_and_process_worklist ( )

inline

Definition at line 371 of file prefetch_manager.cpp.

                                      {
        if (!worklist_scu || !node_manager || worklist_node_id.empty()) {
            return;
        }
 
        // Get node configuration
        auto node = node_manager->get_node(worklist_node_id);
        if (!node) {
            logger->warn_fmt("Worklist node {} not found", worklist_node_id);
            return;
        }
 
        // Query today's worklist
        // Note: This would establish association and query in production
        // For now, this is a placeholder for the actual worklist query
        logger->debug_fmt("Checking worklist from node {}", worklist_node_id);
    }

References logger, node_manager, worklist_node_id, and worklist_scu.

Referenced by worklist_monitor_loop().

Here is the caller graph for this function:

◆ record_prefetch_history()

void kcenon::pacs::client::prefetch_manager::impl::record_prefetch_history	(	const std::string &	patient_id,
		const std::string &	study_uid,
		const std::string &	rule_id,
		const std::string &	source_node_id,
		const std::string &	job_id,
		const std::string &	status )

inline

Definition at line 252 of file prefetch_manager.cpp.

                                 {
        #ifdef PACS_WITH_DATABASE_SYSTEM
        if (!repositories.history && !compatibility_repo) return;
        #else
        if (!compatibility_repo) return;
        #endif
 
        prefetch_history history;
        history.patient_id = patient_id;
        history.study_uid = study_uid;
        history.rule_id = rule_id;
        history.source_node_id = source_node_id;
        history.job_id = job_id;
        history.status = status;
        history.prefetched_at = std::chrono::system_clock::now();
 
        #ifdef PACS_WITH_DATABASE_SYSTEM
        if (repositories.history) {
            [[maybe_unused]] auto result = repositories.history->save(history);
        } else if (compatibility_repo) {
            [[maybe_unused]] auto result =
                compatibility_repo->save_history(history);
        }
        #else
        if (compatibility_repo) {
            [[maybe_unused]] auto result =
                compatibility_repo->save_history(history);
        }
        #endif
    }

References compatibility_repo, kcenon::pacs::client::prefetch_repositories::history, kcenon::pacs::client::prefetch_history::job_id, kcenon::pacs::client::prefetch_history::patient_id, kcenon::pacs::client::prefetch_history::prefetched_at, repositories, kcenon::pacs::client::prefetch_history::rule_id, kcenon::pacs::client::prefetch_history::source_node_id, kcenon::pacs::client::prefetch_history::status, and kcenon::pacs::client::prefetch_history::study_uid.

Referenced by kcenon::pacs::client::prefetch_manager::prefetch_study().

Here is the caller graph for this function:

◆ save_rule_to_repo()

void kcenon::pacs::client::prefetch_manager::impl::save_rule_to_repo ( const prefetch_rule & rule )

inline

Definition at line 182 of file prefetch_manager.cpp.

                                                      {
        #ifdef PACS_WITH_DATABASE_SYSTEM
        if (repositories.rules) {
            [[maybe_unused]] auto result = repositories.rules->save(rule);
        } else if (compatibility_repo) {
            [[maybe_unused]] auto result = compatibility_repo->save_rule(rule);
        }
        #else
        if (compatibility_repo) {
            [[maybe_unused]] auto result = compatibility_repo->save_rule(rule);
        }
        #endif
    }

References compatibility_repo, repositories, and kcenon::pacs::client::prefetch_repositories::rules.

◆ scheduler_loop()

void kcenon::pacs::client::prefetch_manager::impl::scheduler_loop ( )

inline

Definition at line 326 of file prefetch_manager.cpp.

                          {
        while (scheduler_running.load()) {
            std::unique_lock lock(scheduler_mutex);
            scheduler_cv.wait_for(lock, std::chrono::minutes(1), [this] {
                return !scheduler_running.load();
            });
 
            if (!scheduler_running.load()) break;
 
            // Check scheduled rules
            check_scheduled_rules();
        }
    }

References check_scheduled_rules(), scheduler_cv, scheduler_mutex, and scheduler_running.

Referenced by kcenon::pacs::client::prefetch_manager::start_scheduler().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ worklist_monitor_loop()

void kcenon::pacs::client::prefetch_manager::impl::worklist_monitor_loop ( )

inline

Definition at line 357 of file prefetch_manager.cpp.

                                 {
        while (worklist_monitor_running.load()) {
            std::unique_lock lock(worklist_mutex);
            worklist_cv.wait_for(lock, config.worklist_check_interval, [this] {
                return !worklist_monitor_running.load();
            });
 
            if (!worklist_monitor_running.load()) break;
 
            // Query worklist and process items
            query_and_process_worklist();
        }
    }