#include <routing_manager.h>

Collaboration diagram for kcenon::pacs::client::routing_manager:

Public Member Functions
	routing_manager (std::shared_ptr< storage::routing_repository > repo, std::shared_ptr< job_manager > job_manager, std::shared_ptr< di::ILogger > logger=nullptr)
	Construct a routing manager with default configuration.

	routing_manager (const routing_manager_config &config, std::shared_ptr< storage::routing_repository > repo, std::shared_ptr< job_manager > job_manager, std::shared_ptr< di::ILogger > logger=nullptr)
	Construct a routing manager with custom configuration.

	~routing_manager ()
	Destructor.

	routing_manager (const routing_manager &)=delete

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

	routing_manager (routing_manager &&)=delete

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

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

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

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

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

auto	list_rules () const -> std::vector< routing_rule >
	List all routing rules.

auto	list_enabled_rules () const -> std::vector< routing_rule >
	List only enabled routing rules.

auto	set_rule_priority (std::string_view rule_id, int priority) -> kcenon::pacs::VoidResult
	Set the priority of a rule.

auto	reorder_rules (const std::vector< std::string > &rule_ids) -> kcenon::pacs::VoidResult
	Reorder rules by specifying the desired order.

auto	evaluate (const core::dicom_dataset &dataset) -> std::vector< routing_action >
	Evaluate rules against a dataset.

auto	evaluate_with_rule_ids (const core::dicom_dataset &dataset) -> std::vector< std::pair< std::string, std::vector< routing_action > > >
	Evaluate rules and return with matched rule IDs.

void	route (const core::dicom_dataset &dataset)
	Route a DICOM dataset based on matching rules.

void	route (std::string_view sop_instance_uid)
	Route a stored instance by SOP Instance UID.

void	enable ()
	Enable routing globally.

void	disable ()
	Disable routing globally.

auto	is_enabled () const noexcept -> bool
	Check if routing is enabled.

void	attach_to_storage_scp (services::storage_scp &scp)
	Attach to a Storage SCP for automatic routing.

void	detach_from_storage_scp ()
	Detach from the currently attached Storage SCP.

void	set_routing_callback (routing_event_callback callback)
	Set callback for routing events.

auto	test_rules (const core::dicom_dataset &dataset) const -> routing_test_result
	Test rules against a dataset without executing actions.

auto	get_statistics () const -> routing_statistics
	Get overall routing statistics.

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

void	reset_statistics ()
	Reset all statistics.

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

Private Member Functions
auto	match_condition (const routing_condition &condition, const core::dicom_dataset &dataset) const -> bool
	Check if a condition matches a dataset.

auto	match_pattern (std::string_view pattern, std::string_view value, bool case_sensitive) const -> bool
	Match a wildcard pattern against a value.

auto	get_field_value (routing_field field, const core::dicom_dataset &dataset) const -> std::string
	Get DICOM field value from dataset.

void	execute_actions (const std::string &sop_instance_uid, const std::vector< routing_action > &actions)
	Execute routing actions.

void	load_rules ()
	Load rules from repository into cache.

Private Attributes
routing_manager_config	config_

std::shared_ptr< storage::routing_repository >	repo_

std::shared_ptr< job_manager >	job_manager_

std::shared_ptr< di::ILogger >	logger_

std::vector< routing_rule >	rules_

std::shared_mutex	rules_mutex_

std::atomic< bool >	enabled_ {true}

routing_event_callback	routing_callback_

std::atomic< size_t >	total_evaluated_ {0}

std::atomic< size_t >	total_matched_ {0}

std::atomic< size_t >	total_forwarded_ {0}

std::atomic< size_t >	total_failed_ {0}

services::storage_scp *	attached_scp_ {nullptr}

Detailed Description

Definition at line 93 of file routing_manager.h.

Constructor & Destructor Documentation

◆ routing_manager() [1/4]

kcenon::pacs::client::routing_manager::routing_manager	(	std::shared_ptr< storage::routing_repository >	repo,
		std::shared_ptr< job_manager >	job_manager,
		std::shared_ptr< di::ILogger >	logger = nullptr )

explicit

Construct a routing manager with default configuration.

Parameters

repo	Routing repository for persistence (required)
job_manager	Job manager for executing forward jobs (required)
logger	Logger instance (optional, defaults to NullLogger)

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

Definition at line 58 of file routing_manager.cpp.

    : config_{}
    , repo_(std::move(repo))
    , job_manager_(std::move(job_mgr))
    , logger_(logger ? std::move(logger) : di::null_logger()) {
 
    load_rules();
 
    if (logger_) {
        logger_->info_fmt("routing_manager: Initialized with {} rules", rules_.size());
    }
}

References load_rules(), logger_, and rules_.

Here is the call graph for this function:

◆ routing_manager() [2/4]

kcenon::pacs::client::routing_manager::routing_manager	(	const routing_manager_config &	config,
		std::shared_ptr< storage::routing_repository >	repo,
		std::shared_ptr< job_manager >	job_manager,
		std::shared_ptr< di::ILogger >	logger = nullptr )

explicit

Construct a routing manager with custom configuration.

Parameters

config	Manager configuration
repo	Routing repository for persistence (required)
job_manager	Job manager for executing forward jobs (required)
logger	Logger instance (optional, defaults to NullLogger)

Definition at line 74 of file routing_manager.cpp.

    : config_(config)
    , repo_(std::move(repo))
    , job_manager_(std::move(job_mgr))
    , logger_(logger ? std::move(logger) : di::null_logger()) {
 
    enabled_.store(config_.enabled);
    load_rules();
 
    if (logger_) {
        logger_->info_fmt("routing_manager: Initialized with {} rules (enabled={})",
                         rules_.size(), enabled_.load());
    }
}

References config_, kcenon::pacs::client::routing_manager_config::enabled, enabled_, load_rules(), logger_, and rules_.

Here is the call graph for this function:

◆ ~routing_manager()

kcenon::pacs::client::routing_manager::~routing_manager ( )

Destructor.

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

Definition at line 93 of file routing_manager.cpp.

                                  {
    detach_from_storage_scp();
}

References detach_from_storage_scp().

Here is the call graph for this function:

◆ routing_manager() [3/4]

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

delete

◆ routing_manager() [4/4]

kcenon::pacs::client::routing_manager::routing_manager ( routing_manager && )

delete

Member Function Documentation

◆ add_rule()

kcenon::pacs::VoidResult kcenon::pacs::client::routing_manager::add_rule ( const routing_rule & rule ) -> kcenon::pacs::VoidResult

nodiscard

Add a new routing 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/routing_manager.h.

Definition at line 101 of file routing_manager.cpp.

                                                                       {
    // Validate
    if (rule.rule_id.empty()) {
        return kcenon::pacs::pacs_void_error(-1, "Rule ID cannot be empty");
    }
 
    {
        std::shared_lock lock(rules_mutex_);
        if (rules_.size() >= config_.max_rules) {
            return kcenon::pacs::pacs_void_error(-1, "Maximum number of rules reached");
        }
    }
 
    // Save to repository
    auto result = repo_->save(rule);
    if (result.is_err()) {
        return kcenon::pacs::pacs_void_error(
            result.error().code,
            "Failed to save rule: " + result.error().message);
    }
 
    // Update cache
    {
        std::unique_lock lock(rules_mutex_);
        rules_.push_back(rule);
 
        // Sort by priority (descending)
        std::sort(rules_.begin(), rules_.end(),
                  [](const routing_rule& a, const routing_rule& b) {
                      return a.priority > b.priority;
                  });
    }
 
    if (logger_) {
        logger_->info_fmt("routing_manager: Added rule: {} ({})", rule.rule_id, rule.name);
    }
 
    return kcenon::pacs::ok();
}

References config_, logger_, kcenon::pacs::client::routing_manager_config::max_rules, kcenon::pacs::client::routing_rule::name, kcenon::pacs::pacs_void_error(), repo_, kcenon::pacs::client::routing_rule::rule_id, rules_, and rules_mutex_.

Here is the call graph for this function:

◆ attach_to_storage_scp()

void kcenon::pacs::client::routing_manager::attach_to_storage_scp ( services::storage_scp & scp )

Attach to a Storage SCP for automatic routing.

Registers a post-store handler to automatically route received images.

Parameters

scp	The Storage SCP to attach to

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

Definition at line 443 of file routing_manager.cpp.

                                                                    {
    detach_from_storage_scp();
 
    attached_scp_ = &scp;
 
    // Register post-store handler
    scp.set_post_store_handler(
        [this](const core::dicom_dataset& dataset,
               const std::string& /*patient_id*/,
               const std::string& /*study_uid*/,
               const std::string& /*series_uid*/,
               const std::string& /*sop_instance_uid*/) {
            this->route(dataset);
        });
 
    if (logger_) {
        logger_->info("routing_manager: Attached to Storage SCP");
    }
}

References attached_scp_, detach_from_storage_scp(), logger_, route(), and kcenon::pacs::services::storage_scp::set_post_store_handler().

Here is the call graph for this function:

◆ config()

const routing_manager_config & kcenon::pacs::client::routing_manager::config ( ) const -> const routing_manager_config&

nodiscardnoexcept

Get current configuration.

Returns: Current manager configuration

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

Definition at line 574 of file routing_manager.cpp.

                                                                     {
    return config_;
}

References config_.

◆ detach_from_storage_scp()

void kcenon::pacs::client::routing_manager::detach_from_storage_scp ( )

Detach from the currently attached Storage SCP.

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

Definition at line 463 of file routing_manager.cpp.

                                              {
    if (attached_scp_) {
        attached_scp_->set_post_store_handler(nullptr);
        attached_scp_ = nullptr;
 
        if (logger_) {
            logger_->info("routing_manager: Detached from Storage SCP");
        }
    }
}

References attached_scp_, logger_, and kcenon::pacs::services::storage_scp::set_post_store_handler().

Referenced by attach_to_storage_scp(), and ~routing_manager().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ disable()

void kcenon::pacs::client::routing_manager::disable ( )

Disable routing globally.

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

Definition at line 428 of file routing_manager.cpp.

                              {
    enabled_.store(false);
    if (logger_) {
        logger_->info("routing_manager: Routing disabled");
    }
}

References enabled_, and logger_.

◆ enable()

void kcenon::pacs::client::routing_manager::enable ( )

Enable routing globally.

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

Definition at line 421 of file routing_manager.cpp.

                             {
    enabled_.store(true);
    if (logger_) {
        logger_->info("routing_manager: Routing enabled");
    }
}

References enabled_, and logger_.

◆ evaluate()

std::vector< routing_action > kcenon::pacs::client::routing_manager::evaluate ( const core::dicom_dataset & dataset ) -> std::vector<routing_action>

nodiscard

Evaluate rules against a dataset.

Returns all actions that should be executed based on matching rules.

Parameters

dataset The DICOM dataset to evaluate

Returns: Vector of actions to execute

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

Definition at line 291 of file routing_manager.cpp.

                                                                                    {
    std::vector<routing_action> result;
 
    if (!enabled_.load()) {
        return result;
    }
 
    ++total_evaluated_;
 
    std::shared_lock lock(rules_mutex_);
 
    for (const auto& rule : rules_) {
        if (!rule.is_effective_now()) {
            continue;
        }
 
        // Check all conditions (AND logic)
        bool all_match = !rule.conditions.empty();
        for (const auto& condition : rule.conditions) {
            if (!match_condition(condition, dataset)) {
                all_match = false;
                break;
            }
        }
 
        if (all_match) {
            ++total_matched_;
 
            // Add all actions from this rule
            for (const auto& action : rule.actions) {
                result.push_back(action);
            }
 
            // Only first matching rule is executed (stop after first match)
            // Uncomment the break below if you want first-match-only behavior
            // break;
        }
    }
 
    return result;
}

References enabled_, match_condition(), rules_, rules_mutex_, total_evaluated_, and total_matched_.

Here is the call graph for this function:

◆ evaluate_with_rule_ids()

std::vector< std::pair< std::string, std::vector< routing_action > > > kcenon::pacs::client::routing_manager::evaluate_with_rule_ids ( const core::dicom_dataset & dataset ) -> std::vector<std::pair<std::string, std::vector<routing_action>>>

nodiscard

Evaluate rules and return with matched rule IDs.

Parameters

dataset The DICOM dataset to evaluate

Returns: Vector of pairs (rule_id, actions)

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

Definition at line 334 of file routing_manager.cpp.

                                                                        {
    std::vector<std::pair<std::string, std::vector<routing_action>>> result;
 
    if (!enabled_.load()) {
        return result;
    }
 
    ++total_evaluated_;
 
    std::shared_lock lock(rules_mutex_);
 
    for (const auto& rule : rules_) {
        if (!rule.is_effective_now()) {
            continue;
        }
 
        bool all_match = !rule.conditions.empty();
        for (const auto& condition : rule.conditions) {
            if (!match_condition(condition, dataset)) {
                all_match = false;
                break;
            }
        }
 
        if (all_match) {
            ++total_matched_;
            result.emplace_back(rule.rule_id, rule.actions);
        }
    }
 
    return result;
}

References enabled_, match_condition(), rules_, rules_mutex_, total_evaluated_, and total_matched_.

Referenced by route().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ execute_actions()

void kcenon::pacs::client::routing_manager::execute_actions	(	const std::string &	sop_instance_uid,
		const std::vector< routing_action > &	actions )

private

Execute routing actions.

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

Definition at line 672 of file routing_manager.cpp.

                                                                                {
    for (const auto& action : actions) {
        if (action.destination_node_id.empty()) {
            if (logger_) {
                logger_->warn_fmt("routing_manager: Skipping action with empty destination for UID: {}",
                                 sop_instance_uid);
            }
            continue;
        }
 
        // Create a store job via job_manager
        std::vector<std::string> instance_uids{sop_instance_uid};
 
        auto job_id = job_manager_->create_store_job(
            action.destination_node_id,
            instance_uids,
            action.priority);
 
        ++total_forwarded_;
 
        if (logger_) {
            logger_->info_fmt("routing_manager: Created forward job {} for UID {} -> {}",
                             job_id, sop_instance_uid, action.destination_node_id);
        }
 
        // Note: Delayed forwarding would require a scheduler/timer
        // For now, jobs are created immediately
        if (action.delay.count() > 0 && logger_) {
            logger_->debug_fmt("routing_manager: Delayed forwarding ({} min) not yet implemented",
                              action.delay.count());
        }
    }
}

References job_manager_, logger_, and total_forwarded_.

Referenced by route().

Here is the caller graph for this function:

◆ get_field_value()

std::string kcenon::pacs::client::routing_manager::get_field_value	(	routing_field	field,
		const core::dicom_dataset &	dataset ) const -> std::string

nodiscardprivate

Get DICOM field value from dataset.

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

Definition at line 634 of file routing_manager.cpp.

                                                                                     {
    switch (field) {
        case routing_field::modality:
            return dataset.get_string(core::tags::modality);
 
        case routing_field::station_ae:
            return dataset.get_string(core::tags::station_name);
 
        case routing_field::institution:
            return dataset.get_string(core::tags::institution_name);
 
        case routing_field::department:
            return dataset.get_string(institutional_department_name);
 
        case routing_field::referring_physician:
            return dataset.get_string(core::tags::referring_physician_name);
 
        case routing_field::study_description:
            return dataset.get_string(core::tags::study_description);
 
        case routing_field::series_description:
            return dataset.get_string(core::tags::series_description);
 
        case routing_field::body_part:
            return dataset.get_string(body_part_examined);
 
        case routing_field::patient_id_pattern:
            return dataset.get_string(core::tags::patient_id);
 
        case routing_field::sop_class_uid:
            return dataset.get_string(core::tags::sop_class_uid);
 
        default:
            return "";
    }
}

Referenced by match_condition().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_rule()

std::optional< routing_rule > kcenon::pacs::client::routing_manager::get_rule ( std::string_view rule_id ) const -> std::optional<routing_rule>

nodiscard

Get a routing rule by ID.

Parameters

rule_id The rule ID to retrieve

Returns: Optional containing the rule if found

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

Definition at line 202 of file routing_manager.cpp.

                                                                                {
    std::shared_lock lock(rules_mutex_);
    auto it = std::find_if(rules_.begin(), rules_.end(),
                           [&](const routing_rule& r) {
                               return r.rule_id == rule_id;
                           });
    if (it != rules_.end()) {
        return *it;
    }
    return std::nullopt;
}

References rules_, and rules_mutex_.

◆ get_rule_statistics()

routing_statistics kcenon::pacs::client::routing_manager::get_rule_statistics ( std::string_view rule_id ) const -> routing_statistics

nodiscard

Get statistics for a specific rule.

Parameters

rule_id The rule ID

Returns: Statistics for the specified rule

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

Definition at line 528 of file routing_manager.cpp.

                                                                                    {
    routing_statistics stats;
 
#ifdef PACS_WITH_DATABASE_SYSTEM
    auto rule_result = repo_->find_by_id(std::string(rule_id));
    if (rule_result.is_ok()) {
        const auto& rule = rule_result.value();
        stats.total_evaluated = 0;  // Not tracked per-rule
        stats.total_matched = rule.triggered_count;
        stats.total_forwarded = rule.success_count;
        stats.total_failed = rule.failure_count;
    }
#else
    auto rule = repo_->find_by_id(rule_id);
    if (rule) {
        stats.total_evaluated = 0;  // Not tracked per-rule
        stats.total_matched = rule->triggered_count;
        stats.total_forwarded = rule->success_count;
        stats.total_failed = rule->failure_count;
    }
#endif
 
    return stats;
}

References repo_.

◆ get_statistics()

routing_statistics kcenon::pacs::client::routing_manager::get_statistics ( ) const -> routing_statistics

nodiscard

Get overall routing statistics.

Returns: Aggregate statistics for all routing operations

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

Definition at line 519 of file routing_manager.cpp.

                                                         {
    routing_statistics stats;
    stats.total_evaluated = total_evaluated_.load();
    stats.total_matched = total_matched_.load();
    stats.total_forwarded = total_forwarded_.load();
    stats.total_failed = total_failed_.load();
    return stats;
}

References total_evaluated_, total_failed_, total_forwarded_, and total_matched_.

◆ is_enabled()

bool kcenon::pacs::client::routing_manager::is_enabled ( ) const -> bool

nodiscardnoexcept

Check if routing is enabled.

Returns: true if routing is enabled

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

Definition at line 435 of file routing_manager.cpp.

                                                {
    return enabled_.load();
}

References enabled_.

◆ list_enabled_rules()

std::vector< routing_rule > kcenon::pacs::client::routing_manager::list_enabled_rules ( ) const -> std::vector<routing_rule>

nodiscard

List only enabled routing rules.

Returns: Vector of enabled rules

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

Definition at line 219 of file routing_manager.cpp.

                                                                  {
    std::shared_lock lock(rules_mutex_);
    std::vector<routing_rule> result;
    std::copy_if(rules_.begin(), rules_.end(), std::back_inserter(result),
                 [](const routing_rule& r) { return r.enabled; });
    return result;
}

References rules_, and rules_mutex_.

◆ list_rules()

std::vector< routing_rule > kcenon::pacs::client::routing_manager::list_rules ( ) const -> std::vector<routing_rule>

nodiscard

List all routing rules.

Returns: Vector of all rules

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

Definition at line 214 of file routing_manager.cpp.

                                                          {
    std::shared_lock lock(rules_mutex_);
    return rules_;
}

References rules_, and rules_mutex_.

◆ load_rules()

void kcenon::pacs::client::routing_manager::load_rules ( )

private

Load rules from repository into cache.

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

Definition at line 707 of file routing_manager.cpp.

                                 {
#ifdef PACS_WITH_DATABASE_SYSTEM
    auto loaded_result = repo_->find_enabled_rules();
    if (loaded_result.is_err()) {
        if (logger_) {
            logger_->warn_fmt("routing_manager: Failed to load rules: {}",
                             loaded_result.error().message);
        }
        return;
    }
 
    std::unique_lock lock(rules_mutex_);
    rules_ = std::move(loaded_result.value());
#else
    auto loaded = repo_->find_enabled_rules();
 
    std::unique_lock lock(rules_mutex_);
    rules_ = std::move(loaded);
#endif
 
    // Sort by priority (descending)
    std::sort(rules_.begin(), rules_.end(),
              [](const routing_rule& a, const routing_rule& b) {
                  return a.priority > b.priority;
              });
}

References logger_, repo_, rules_, and rules_mutex_.

Referenced by routing_manager(), and routing_manager().

Here is the caller graph for this function:

◆ match_condition()

bool kcenon::pacs::client::routing_manager::match_condition	(	const routing_condition &	condition,
		const core::dicom_dataset &	dataset ) const -> bool

nodiscardprivate

Check if a condition matches a dataset.

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

Definition at line 582 of file routing_manager.cpp.

                                                                              {
    auto value = get_field_value(condition.match_field, dataset);
    bool matched = match_pattern(condition.pattern, value, condition.case_sensitive);
 
    // Apply negation if needed
    if (condition.negate) {
        matched = !matched;
    }
 
    return matched;
}

References kcenon::pacs::client::routing_condition::case_sensitive, get_field_value(), kcenon::pacs::client::routing_condition::match_field, match_pattern(), kcenon::pacs::client::routing_condition::negate, and kcenon::pacs::client::routing_condition::pattern.

Referenced by evaluate(), evaluate_with_rule_ids(), and test_rules().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ match_pattern()

bool kcenon::pacs::client::routing_manager::match_pattern	(	std::string_view	pattern,
		std::string_view	value,
		bool	case_sensitive ) const -> bool

nodiscardprivate

Match a wildcard pattern against a value.

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

Definition at line 595 of file routing_manager.cpp.

                                                               {
    // Convert to lowercase if case-insensitive
    std::string pat_str = case_sensitive ? std::string(pattern) : to_lower(pattern);
    std::string val_str = case_sensitive ? std::string(value) : to_lower(value);
 
    // Simple wildcard matching (* and ?)
    // * matches any sequence of characters
    // ? matches any single character
 
    const char* p = pat_str.c_str();
    const char* v = val_str.c_str();
 
    const char* star_p = nullptr;
    const char* star_v = nullptr;
 
    while (*v) {
        if (*p == '*') {
            star_p = p++;
            star_v = v;
        } else if (*p == '?' || *p == *v) {
            ++p;
            ++v;
        } else if (star_p) {
            p = star_p + 1;
            v = ++star_v;
        } else {
            return false;
        }
    }
 
    while (*p == '*') {
        ++p;
    }
 
    return *p == '\0';
}

Referenced by match_condition().

Here is the caller graph for this function:

◆ operator=() [1/2]

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

delete

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

◆ operator=() [2/2]

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

delete

◆ remove_rule()

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

nodiscard

Remove a routing rule.

Parameters

rule_id The ID of the rule to remove

Returns: VoidResult indicating success or error

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

Definition at line 177 of file routing_manager.cpp.

                                                                        {
    // Remove from repository
    auto result = repo_->remove(std::string(rule_id));
    if (!result.is_ok()) {
        return result;
    }
 
    // Remove from cache
    {
        std::unique_lock lock(rules_mutex_);
        rules_.erase(
            std::remove_if(rules_.begin(), rules_.end(),
                           [&](const routing_rule& r) {
                               return r.rule_id == rule_id;
                           }),
            rules_.end());
    }
 
    if (logger_) {
        logger_->info_fmt("routing_manager: Removed rule: {}", rule_id);
    }
 
    return kcenon::pacs::ok();
}

References logger_, repo_, rules_, and rules_mutex_.

◆ reorder_rules()

kcenon::pacs::VoidResult kcenon::pacs::client::routing_manager::reorder_rules ( const std::vector< std::string > & rule_ids ) -> kcenon::pacs::VoidResult

nodiscard

Reorder rules by specifying the desired order.

Parameters

rule_ids Vector of rule IDs in desired order (first = highest priority)

Returns: VoidResult indicating success or error

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

Definition at line 257 of file routing_manager.cpp.

                                                                                        {
    std::unique_lock lock(rules_mutex_);
 
    // Assign priorities based on order (first = highest)
    int priority = static_cast<int>(rule_ids.size());
    for (const auto& rule_id : rule_ids) {
        auto repo_result = repo_->update_priority(rule_id, priority);
        if (!repo_result.is_ok()) {
            return repo_result;
        }
 
        auto it = std::find_if(rules_.begin(), rules_.end(),
                               [&](const routing_rule& r) {
                                   return r.rule_id == rule_id;
                               });
        if (it != rules_.end()) {
            it->priority = priority;
        }
        --priority;
    }
 
    // Re-sort
    std::sort(rules_.begin(), rules_.end(),
              [](const routing_rule& a, const routing_rule& b) {
                  return a.priority > b.priority;
              });
 
    return kcenon::pacs::ok();
}

References repo_, rules_, and rules_mutex_.

◆ reset_statistics()

void kcenon::pacs::client::routing_manager::reset_statistics ( )

Reset all statistics.

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

Definition at line 553 of file routing_manager.cpp.

                                       {
    total_evaluated_.store(0);
    total_matched_.store(0);
    total_forwarded_.store(0);
    total_failed_.store(0);
 
    // Reset per-rule statistics
    std::shared_lock lock(rules_mutex_);
    for (const auto& rule : rules_) {
        auto result = repo_->reset_statistics(rule.rule_id);
        if (!result.is_ok() && logger_) {
            logger_->warn_fmt("routing_manager: Failed to reset statistics for rule: {}",
                             rule.rule_id);
        }
    }
}

References logger_, repo_, rules_, rules_mutex_, total_evaluated_, total_failed_, total_forwarded_, and total_matched_.

◆ route() [1/2]

void kcenon::pacs::client::routing_manager::route ( const core::dicom_dataset & dataset )

Route a DICOM dataset based on matching rules.

Evaluates rules and creates forward jobs for matching actions.

Parameters

dataset The DICOM dataset to route

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

Definition at line 371 of file routing_manager.cpp.

                                                            {
    if (!enabled_.load()) {
        return;
    }
 
    auto sop_instance_uid = dataset.get_string(core::tags::sop_instance_uid);
    if (sop_instance_uid.empty()) {
        if (logger_) {
            logger_->warn("routing_manager: Cannot route dataset without SOP Instance UID");
        }
        return;
    }
 
    auto matches = evaluate_with_rule_ids(dataset);
 
    for (const auto& [rule_id, actions] : matches) {
        // Update statistics
        auto stat_result = repo_->increment_triggered(rule_id);
        if (!stat_result.is_ok() && logger_) {
            logger_->warn_fmt("routing_manager: Failed to update statistics for rule: {}",
                             rule_id);
        }
 
        // Notify callback
        if (routing_callback_) {
            routing_callback_(rule_id, sop_instance_uid, actions);
        }
 
        // Execute actions
        execute_actions(sop_instance_uid, actions);
    }
}

References enabled_, evaluate_with_rule_ids(), execute_actions(), kcenon::pacs::core::dicom_dataset::get_string(), logger_, repo_, routing_callback_, and kcenon::pacs::core::tags::sop_instance_uid.

Referenced by attach_to_storage_scp().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ route() [2/2]

void kcenon::pacs::client::routing_manager::route ( std::string_view sop_instance_uid )

Route a stored instance by SOP Instance UID.

Parameters

sop_instance_uid The SOP Instance UID to route

Definition at line 404 of file routing_manager.cpp.

                                                           {
    if (!enabled_.load()) {
        return;
    }
 
    // Note: This would require loading the dataset from storage
    // For now, log a warning as this requires additional infrastructure
    if (logger_) {
        logger_->warn_fmt("routing_manager: route(sop_instance_uid) not fully implemented - "
                         "use route(dataset) instead. UID: {}", sop_instance_uid);
    }
}

References enabled_, and logger_.

◆ set_routing_callback()

void kcenon::pacs::client::routing_manager::set_routing_callback ( routing_event_callback callback )

Set callback for routing events.

Called when a rule matches and actions are triggered.

Parameters

callback The callback function

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

Definition at line 478 of file routing_manager.cpp.

                                                                          {
    routing_callback_ = std::move(callback);
}

References routing_callback_.

◆ set_rule_priority()

kcenon::pacs::VoidResult kcenon::pacs::client::routing_manager::set_rule_priority	(	std::string_view	rule_id,
		int	priority ) -> kcenon::pacs::VoidResult

nodiscard

Set the priority of a rule.

Parameters

rule_id	The rule ID to update
priority	The new priority (higher = evaluated first)

Returns: VoidResult indicating success or error

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

Definition at line 231 of file routing_manager.cpp.

                                                                                            {
    auto result = repo_->update_priority(rule_id, priority);
    if (!result.is_ok()) {
        return result;
    }
 
    {
        std::unique_lock lock(rules_mutex_);
        auto it = std::find_if(rules_.begin(), rules_.end(),
                               [&](const routing_rule& r) {
                                   return r.rule_id == rule_id;
                               });
        if (it != rules_.end()) {
            it->priority = priority;
        }
 
        // Re-sort
        std::sort(rules_.begin(), rules_.end(),
                  [](const routing_rule& a, const routing_rule& b) {
                      return a.priority > b.priority;
                  });
    }
 
    return kcenon::pacs::ok();
}

References repo_, rules_, and rules_mutex_.

◆ test_rules()

routing_test_result kcenon::pacs::client::routing_manager::test_rules ( const core::dicom_dataset & dataset ) const -> routing_test_result

nodiscard

Test rules against a dataset without executing actions.

Parameters

dataset The DICOM dataset to test

Returns: Test result showing matches

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

Definition at line 486 of file routing_manager.cpp.

                                                                                      {
    routing_test_result result;
 
    std::shared_lock lock(rules_mutex_);
 
    for (const auto& rule : rules_) {
        if (!rule.is_effective_now()) {
            continue;
        }
 
        bool all_match = !rule.conditions.empty();
        for (const auto& condition : rule.conditions) {
            if (!match_condition(condition, dataset)) {
                all_match = false;
                break;
            }
        }
 
        if (all_match) {
            result.matched = true;
            result.matched_rule_id = rule.rule_id;
            result.actions = rule.actions;
            break;  // Return first match for test
        }
    }
 
    return result;
}

References kcenon::pacs::client::routing_test_result::actions, match_condition(), kcenon::pacs::client::routing_test_result::matched, kcenon::pacs::client::routing_test_result::matched_rule_id, rules_, and rules_mutex_.

Here is the call graph for this function:

◆ update_rule()

kcenon::pacs::VoidResult kcenon::pacs::client::routing_manager::update_rule ( const routing_rule & rule ) -> kcenon::pacs::VoidResult

nodiscard

Update an existing routing rule.

Parameters

rule	The rule to update (identified by rule_id)

Returns: VoidResult indicating success or error

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

Definition at line 141 of file routing_manager.cpp.

                                                                          {
    // Save to repository
    auto result = repo_->save(rule);
    if (result.is_err()) {
        return kcenon::pacs::pacs_void_error(
            result.error().code,
            "Failed to update rule: " + result.error().message);
    }
 
    // Update cache
    {
        std::unique_lock lock(rules_mutex_);
        auto it = std::find_if(rules_.begin(), rules_.end(),
                               [&](const routing_rule& r) {
                                   return r.rule_id == rule.rule_id;
                               });
        if (it != rules_.end()) {
            *it = rule;
        } else {
            rules_.push_back(rule);
        }
 
        // Re-sort by priority
        std::sort(rules_.begin(), rules_.end(),
                  [](const routing_rule& a, const routing_rule& b) {
                      return a.priority > b.priority;
                  });
    }
 
    if (logger_) {
        logger_->info_fmt("routing_manager: Updated rule: {} ({})", rule.rule_id, rule.name);
    }
 
    return kcenon::pacs::ok();
}