#include <config_loader.h>

Collaboration diagram for kcenon::pacs::samples::config_loader:

Static Public Member Functions
static auto	load (const std::filesystem::path &path) -> kcenon::common::Result< production_config >
	Load configuration from a YAML file.

static auto	load_from_string (std::string_view yaml_content) -> kcenon::common::Result< production_config >
	Load configuration from a YAML string.

static auto	create_default () -> production_config
	Create a default configuration.

static auto	validate (const production_config &config) -> kcenon::common::VoidResult
	Validate a configuration.

Static Private Member Functions
static auto	parse_value (std::string_view value) -> std::string
	Parse a YAML value (simple types)

static auto	parse_bool (std::string_view value) -> bool
	Parse a boolean value.

static auto	parse_int (std::string_view value) -> int
	Parse an integer value.

static auto	parse_anonymization_profile (std::string_view value) -> security::anonymization_profile
	Parse anonymization profile.

static auto	trim (std::string_view str) -> std::string
	Trim whitespace from string.

Detailed Description

Definition at line 248 of file config_loader.h.

Member Function Documentation

◆ create_default()

auto kcenon::pacs::samples::config_loader::create_default ( ) -> production_config

staticnodiscard

Create a default configuration.

Returns: Default production configuration

Examples: /home/runner/work/pacs_system/pacs_system/examples/tutorials/05_production_pacs/config_loader.h.

Definition at line 263 of file config_loader.cpp.

                                                        {
    production_config config;
 
    // Server defaults
    config.server.ae_title = "PROD_PACS";
    config.server.port = 11112;
    config.server.max_associations = 100;
    config.server.idle_timeout = std::chrono::seconds{300};
    config.server.tls.enabled = false;
 
    // Storage defaults
    config.storage.root_path = "./pacs_data";
    config.storage.naming_scheme = "uid_hierarchical";
    config.storage.duplicate_policy = "replace";
    config.storage.database.path = "./pacs_data/index.db";
 
    // Security defaults
    config.security.access_control.enabled = true;
    config.security.access_control.default_role = "viewer";
    config.security.anonymization.auto_anonymize = false;
    config.security.anonymization.profile = security::anonymization_profile::basic;
 
    // REST API defaults
    config.rest_api.enabled = true;
    config.rest_api.port = 8080;
    config.rest_api.cors_enabled = true;
 
    // Monitoring defaults
    config.monitoring.health_check_interval = std::chrono::seconds{30};
    config.monitoring.metrics_enabled = true;
 
    // Logging defaults
    config.logging.level = "info";
 
    return config;
}

Referenced by main().

Here is the caller graph for this function:

◆ load()

auto kcenon::pacs::samples::config_loader::load ( const std::filesystem::path & path ) -> kcenon::common::Result<production_config>

staticnodiscard

Load configuration from a YAML file.

Parameters

path	Path to the YAML configuration file

Returns: Result containing configuration or error message

Examples: /home/runner/work/pacs_system/pacs_system/examples/tutorials/05_production_pacs/config_loader.h.

Definition at line 170 of file config_loader.cpp.

                                             {
    std::ifstream file(path);
    if (!file.is_open()) {
        return kcenon::common::Result<production_config>::err(
            kcenon::common::error_info("Failed to open configuration file: " + path.string()));
    }
 
    std::stringstream buffer;
    buffer << file.rdbuf();
    return load_from_string(buffer.str());
}

References buffer.

Referenced by main().

Here is the caller graph for this function:

◆ load_from_string()

auto kcenon::pacs::samples::config_loader::load_from_string ( std::string_view yaml_content ) -> kcenon::common::Result<production_config>

staticnodiscard

Load configuration from a YAML string.

Parameters

yaml_content YAML content as a string

Returns: Result containing configuration or error message

Examples: /home/runner/work/pacs_system/pacs_system/examples/tutorials/05_production_pacs/config_loader.h.

Definition at line 183 of file config_loader.cpp.

                                             {
    try {
        simple_yaml_parser parser(yaml_content);
        production_config config = create_default();
 
        // Server configuration
        config.server.ae_title = parser.get_string("server.ae_title", config.server.ae_title);
        config.server.port = static_cast<std::uint16_t>(
            parser.get_int("server.port", config.server.port));
        config.server.max_associations = static_cast<std::size_t>(
            parser.get_int("server.max_associations",
                           static_cast<int>(config.server.max_associations)));
        config.server.idle_timeout = std::chrono::seconds(
            parser.get_int("server.idle_timeout_seconds",
                           static_cast<int>(config.server.idle_timeout.count())));
 
        // TLS configuration
        config.server.tls.enabled = parser.get_bool("server.tls.enabled",
                                                     config.server.tls.enabled);
        config.server.tls.certificate = parser.get_string("server.tls.certificate");
        config.server.tls.private_key = parser.get_string("server.tls.private_key");
        config.server.tls.ca_certificate = parser.get_string("server.tls.ca_certificate");
        config.server.tls.require_client_cert =
            parser.get_bool("server.tls.require_client_cert", false);
        config.server.tls.min_version = parser.get_string("server.tls.min_version", "1.2");
 
        // Storage configuration
        config.storage.root_path = parser.get_string("storage.root_path",
                                                      config.storage.root_path.string());
        config.storage.naming_scheme = parser.get_string("storage.naming_scheme",
                                                          config.storage.naming_scheme);
        config.storage.duplicate_policy = parser.get_string("storage.duplicate_policy",
                                                             config.storage.duplicate_policy);
        config.storage.database.path = parser.get_string("storage.database.path",
                                                          config.storage.database.path.string());
 
        // Security configuration
        config.security.access_control.enabled =
            parser.get_bool("security.access_control.enabled", true);
        config.security.access_control.default_role =
            parser.get_string("security.access_control.default_role", "viewer");
        config.security.allowed_ae_titles =
            parser.get_list("security.allowed_ae_titles");
        config.security.anonymization.auto_anonymize =
            parser.get_bool("security.anonymization.auto_anonymize", false);
 
        auto profile_str = parser.get_string("security.anonymization.profile", "basic");
        config.security.anonymization.profile = parse_anonymization_profile(profile_str);
 
        // REST API configuration
        config.rest_api.enabled = parser.get_bool("rest_api.enabled", true);
        config.rest_api.port = static_cast<std::uint16_t>(
            parser.get_int("rest_api.port", config.rest_api.port));
        config.rest_api.cors_enabled = parser.get_bool("rest_api.cors_enabled", true);
 
        // Monitoring configuration
        config.monitoring.health_check_interval = std::chrono::seconds(
            parser.get_int("monitoring.health_check_interval_seconds", 30));
        config.monitoring.metrics_enabled = parser.get_bool("monitoring.metrics_enabled", true);
 
        // Logging configuration
        config.logging.level = parser.get_string("logging.level", "info");
        config.logging.audit_log_path = parser.get_string("logging.audit_log_path");
 
        // Validate configuration
        auto validation = validate(config);
        if (!validation.is_ok()) {
            return kcenon::common::Result<production_config>::err(
                kcenon::common::error_info(validation.error().message));
        }
 
        return kcenon::common::Result<production_config>::ok(std::move(config));
 
    } catch (const std::exception& e) {
        return kcenon::common::Result<production_config>::err(
            kcenon::common::error_info(std::string("Configuration parsing error: ") + e.what()));
    }
}

◆ parse_anonymization_profile()

auto kcenon::pacs::samples::config_loader::parse_anonymization_profile ( std::string_view value ) -> security::anonymization_profile

staticprivate

Parse anonymization profile.

Examples: /home/runner/work/pacs_system/pacs_system/examples/tutorials/05_production_pacs/config_loader.h.

Definition at line 378 of file config_loader.cpp.

                                     {
    auto v = trim(value);
    std::transform(v.begin(), v.end(), v.begin(), ::tolower);
 
    if (v == "basic" || v == "basic_profile") {
        return security::anonymization_profile::basic;
    }
    if (v == "hipaa" || v == "hipaa_safe_harbor") {
        return security::anonymization_profile::hipaa_safe_harbor;
    }
    if (v == "retain_longitudinal" || v == "retain_longitudinal_full_dates") {
        return security::anonymization_profile::retain_longitudinal;
    }
    if (v == "retain_device" || v == "retain_device_identity" ||
        v == "retain_patient" || v == "retain_patient_characteristics") {
        return security::anonymization_profile::retain_patient_characteristics;
    }
    if (v == "gdpr") {
        return security::anonymization_profile::gdpr_compliant;
    }
 
    // Default to basic
    return security::anonymization_profile::basic;
}

References kcenon::pacs::security::basic, kcenon::pacs::security::gdpr_compliant, kcenon::pacs::security::hipaa_safe_harbor, kcenon::pacs::security::retain_longitudinal, and kcenon::pacs::security::retain_patient_characteristics.

◆ parse_bool()

auto kcenon::pacs::samples::config_loader::parse_bool ( std::string_view value ) -> bool

staticprivate

Parse a boolean value.

Examples: /home/runner/work/pacs_system/pacs_system/examples/tutorials/05_production_pacs/config_loader.h.

Definition at line 363 of file config_loader.cpp.

                                                           {
    auto v = trim(value);
    std::transform(v.begin(), v.end(), v.begin(), ::tolower);
    return v == "true" || v == "yes" || v == "on" || v == "1";
}

◆ parse_int()

auto kcenon::pacs::samples::config_loader::parse_int ( std::string_view value ) -> int

staticprivate

Parse an integer value.

Examples: /home/runner/work/pacs_system/pacs_system/examples/tutorials/05_production_pacs/config_loader.h.

Definition at line 369 of file config_loader.cpp.

                                                         {
    auto v = trim(value);
    try {
        return std::stoi(v);
    } catch (...) {
        return 0;
    }
}

◆ parse_value()

auto kcenon::pacs::samples::config_loader::parse_value ( std::string_view value ) -> std::string

staticprivate

Parse a YAML value (simple types)

Examples: /home/runner/work/pacs_system/pacs_system/examples/tutorials/05_production_pacs/config_loader.h.

Definition at line 359 of file config_loader.cpp.

                                                                 {
    return trim(value);
}

◆ trim()

auto kcenon::pacs::samples::config_loader::trim ( std::string_view str ) -> std::string

staticprivate

Trim whitespace from string.

Examples: /home/runner/work/pacs_system/pacs_system/examples/tutorials/05_production_pacs/config_loader.h.

Definition at line 404 of file config_loader.cpp.

                                                        {
    auto start = str.find_first_not_of(" \t\r\n");
    if (start == std::string::npos) return "";
    auto end = str.find_last_not_of(" \t\r\n");
    return std::string(str.substr(start, end - start + 1));
}

◆ validate()

auto kcenon::pacs::samples::config_loader::validate ( const production_config & config ) -> kcenon::common::VoidResult

staticnodiscard

Validate a configuration.

Parameters

config Configuration to validate

Returns: Result indicating success or error

Examples: /home/runner/work/pacs_system/pacs_system/examples/tutorials/05_production_pacs/config_loader.h.

Definition at line 300 of file config_loader.cpp.

                              {
    // Validate AE Title (max 16 characters, no leading/trailing spaces)
    if (config.server.ae_title.empty()) {
        return kcenon::common::VoidResult::err(
            kcenon::common::error_info("AE Title cannot be empty"));
    }
    if (config.server.ae_title.length() > 16) {
        return kcenon::common::VoidResult::err(
            kcenon::common::error_info("AE Title exceeds maximum length of 16 characters"));
    }
 
    // Validate port
    if (config.server.port == 0) {
        return kcenon::common::VoidResult::err(
            kcenon::common::error_info("Server port cannot be 0"));
    }
 
    // Validate REST API port
    if (config.rest_api.enabled && config.rest_api.port == 0) {
        return kcenon::common::VoidResult::err(
            kcenon::common::error_info("REST API port cannot be 0"));
    }
 
    // Validate TLS configuration
    if (config.server.tls.enabled) {
        if (config.server.tls.certificate.empty()) {
            return kcenon::common::VoidResult::err(
                kcenon::common::error_info("TLS enabled but no certificate specified"));
        }
        if (config.server.tls.private_key.empty()) {
            return kcenon::common::VoidResult::err(
                kcenon::common::error_info("TLS enabled but no private key specified"));
        }
    }
 
    // Validate naming scheme
    const std::vector<std::string> valid_schemes = {
        "uid_flat", "uid_hierarchical", "date_based"
    };
    auto scheme_it = std::find(valid_schemes.begin(), valid_schemes.end(),
                               config.storage.naming_scheme);
    if (scheme_it == valid_schemes.end()) {
        return kcenon::common::VoidResult::err(
            kcenon::common::error_info("Invalid naming scheme: " + config.storage.naming_scheme));
    }
 
    // Validate duplicate policy
    const std::vector<std::string> valid_policies = {"reject", "replace", "rename"};
    auto policy_it = std::find(valid_policies.begin(), valid_policies.end(),
                               config.storage.duplicate_policy);
    if (policy_it == valid_policies.end()) {
        return kcenon::common::VoidResult::err(
            kcenon::common::error_info("Invalid duplicate policy: " + config.storage.duplicate_policy));
    }
 
    return kcenon::common::VoidResult::ok(std::monostate{});
}

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

examples/tutorials/05_production_pacs/config_loader.h
examples/tutorials/05_production_pacs/config_loader.cpp

Static Public Member Functions

Static Private Member Functions

Detailed Description

Member Function Documentation

◆ create_default()

◆ load()

◆ load_from_string()

◆ parse_anonymization_profile()

◆ parse_bool()

◆ parse_int()

◆ parse_value()

◆ trim()

◆ validate()