Unified configuration parsing utility. More...

#include <config_parser.h>

Collaboration diagram for kcenon::monitoring::config_parser:

Static Public Member Functions
template<typename T >
static T	get (const config_map &config, const std::string &key, const T &default_value)
	Get a configuration value with type conversion.

template<typename T >
static std::optional< T >	get_optional (const config_map &config, const std::string &key)
	Get a configuration value as optional.

static bool	has_key (const config_map &config, const std::string &key)
	Check if a configuration key exists.

template<typename T >
static T	get_clamped (const config_map &config, const std::string &key, const T &default_value, const T &min_value, const T &max_value)
	Get a configuration value with validation.

template<typename T >
static T	get_enum (const config_map &config, const std::string &key, const T &default_value, const std::unordered_set< T > &allowed_values)
	Get a configuration value from a set of allowed values.

static std::string	get_matching (const config_map &config, const std::string &key, const std::string &default_value, const std::string &pattern)
	Get a string configuration value matching a regex pattern.

template<typename T >
static T	get_validated (const config_map &config, const std::string &key, const T &default_value, std::function< bool(const T &)> validator)
	Get a configuration value with custom validation.

template<typename Duration >
static Duration	get_duration (const config_map &config, const std::string &key, const Duration &default_value)
	Get a duration value from configuration.

template<typename T >
static std::vector< T >	get_list (const config_map &config, const std::string &key, const std::vector< T > &default_values)
	Get a list of values from a comma-separated string.

Static Private Member Functions
template<typename T >
static T	parse_value (const std::string &str, const T &default_value)
	Parse a string value to target type with default fallback.

template<typename T >
static std::optional< T >	parse_value_optional (const std::string &str)
	Parse a string value to target type as optional.

static bool	parse_bool (const std::string &str)
	Parse boolean value from string.

template<typename T >
static T	parse_integral (const std::string &str)
	Parse integral value from string.

template<typename T >
static T	parse_floating (const std::string &str)
	Parse floating-point value from string.

template<typename Duration >
static Duration	parse_duration (const std::string &str, const Duration &default_value)
	Parse duration string with optional suffix Supported suffixes: ms (milliseconds), s (seconds), m (minutes), h (hours)

template<typename T >
static std::vector< T >	parse_list (const std::string &str, const std::vector< T > &default_values)
	Parse comma-separated list of values.

Detailed Description

Unified configuration parsing utility.

Provides type-safe parsing of configuration values with default value support. Handles boolean, integer, floating-point, and string types consistently.

Definition at line 52 of file config_parser.h.

Member Function Documentation

◆ get()

template<typename T >

static T kcenon::monitoring::config_parser::get	(	const config_map &	config,
		const std::string &	key,
		const T &	default_value )

inlinestatic

Get a configuration value with type conversion.

Template Parameters

T	The target type (bool, int, size_t, double, std::string, etc.)

Parameters

config	The configuration map
key	The configuration key to look up
default_value	The default value if key is not found or parsing fails

Returns: The parsed value or default

Definition at line 63 of file config_parser.h.

                                                                                         {
        auto it = config.find(key);
        if (it == config.end()) {
            return default_value;
        }
        return parse_value<T>(it->second, default_value);
    }

References parse_value().

Referenced by get_clamped(), get_enum(), and get_validated().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_clamped()

template<typename T >

static T kcenon::monitoring::config_parser::get_clamped	(	const config_map &	config,
		const std::string &	key,
		const T &	default_value,
		const T &	min_value,
		const T &	max_value )

inlinestatic

Get a configuration value with validation.

Template Parameters

T	The target type

Parameters

config	The configuration map
key	The configuration key to look up
default_value	The default value if key is not found
min_value	Minimum allowed value
max_value	Maximum allowed value

Returns: The parsed value clamped to [min_value, max_value] or default

Definition at line 108 of file config_parser.h.

                                                                 {
        static_assert(std::is_arithmetic_v<T>, "get_clamped requires arithmetic type");
        T value = get<T>(config, key, default_value);
        if (value < min_value) {
            return min_value;
        }
        if (value > max_value) {
            return max_value;
        }
        return value;
    }

References get().

Here is the call graph for this function:

◆ get_duration()

template<typename Duration >

static Duration kcenon::monitoring::config_parser::get_duration	(	const config_map &	config,
		const std::string &	key,
		const Duration &	default_value )

inlinestatic

Get a duration value from configuration.

Template Parameters

Duration The chrono duration type (e.g., std::chrono::milliseconds)

Parameters

config	The configuration map
key	The configuration key to look up
default_value	The default duration if key is not found

Returns: The parsed duration value

Supported formats:

Plain number: interpreted as the Duration's unit (e.g., 1000 = 1000ms for milliseconds)
With suffix: 100ms, 5s, 2m, 1h (milliseconds, seconds, minutes, hours)

Definition at line 197 of file config_parser.h.

                                                                 {
        auto it = config.find(key);
        if (it == config.end()) {
            return default_value;
        }
        return parse_duration<Duration>(it->second, default_value);
    }

References parse_duration().

Here is the call graph for this function:

◆ get_enum()

template<typename T >

static T kcenon::monitoring::config_parser::get_enum	(	const config_map &	config,
		const std::string &	key,
		const T &	default_value,
		const std::unordered_set< T > &	allowed_values )

inlinestatic

Get a configuration value from a set of allowed values.

Template Parameters

T	The target type

Parameters

config	The configuration map
key	The configuration key to look up
default_value	The default value if key is not found or invalid
allowed_values	Set of valid values

Returns: The parsed value if valid, otherwise default

Definition at line 131 of file config_parser.h.

                                                                 {
        T value = get<T>(config, key, default_value);
        if (allowed_values.find(value) != allowed_values.end()) {
            return value;
        }
        return default_value;
    }

References get().

Here is the call graph for this function:

◆ get_list()

template<typename T >

static std::vector< T > kcenon::monitoring::config_parser::get_list	(	const config_map &	config,
		const std::string &	key,
		const std::vector< T > &	default_values )

inlinestatic

Get a list of values from a comma-separated string.

Template Parameters

T	The element type

Parameters

config	The configuration map
key	The configuration key to look up
default_values	The default list if key is not found

Returns: Vector of parsed values

Definition at line 215 of file config_parser.h.

                                                                        {
        auto it = config.find(key);
        if (it == config.end()) {
            return default_values;
        }
        return parse_list<T>(it->second, default_values);
    }

References parse_list().

Here is the call graph for this function:

◆ get_matching()

static std::string kcenon::monitoring::config_parser::get_matching	(	const config_map &	config,
		const std::string &	key,
		const std::string &	default_value,
		const std::string &	pattern )

inlinestatic

Get a string configuration value matching a regex pattern.

Parameters

config	The configuration map
key	The configuration key to look up
default_value	The default value if key is not found or invalid
pattern	The regex pattern to match against

Returns: The value if it matches the pattern, otherwise default

Definition at line 148 of file config_parser.h.

                                                                                               {
        auto it = config.find(key);
        if (it == config.end()) {
            return default_value;
        }
        try {
            std::regex regex(pattern);
            if (std::regex_match(it->second, regex)) {
                return it->second;
            }
        } catch (...) {
            // Invalid regex or no match
        }
        return default_value;
    }

◆ get_optional()

template<typename T >

static std::optional< T > kcenon::monitoring::config_parser::get_optional	(	const config_map &	config,
		const std::string &	key )

inlinestatic

Get a configuration value as optional.

Template Parameters

T	The target type

Parameters

config	The configuration map
key	The configuration key to look up

Returns: Optional containing the value if found and parseable, empty otherwise

Definition at line 79 of file config_parser.h.

                                                                                       {
        auto it = config.find(key);
        if (it == config.end()) {
            return std::nullopt;
        }
        return parse_value_optional<T>(it->second);
    }

References parse_value_optional().

Here is the call graph for this function:

◆ get_validated()

template<typename T >

static T kcenon::monitoring::config_parser::get_validated	(	const config_map &	config,
		const std::string &	key,
		const T &	default_value,
		std::function< bool(const T &)>	validator )

inlinestatic

Get a configuration value with custom validation.

Template Parameters

T	The target type

Parameters

config	The configuration map
key	The configuration key to look up
default_value	The default value if key is not found or validation fails
validator	A function that returns true if the value is valid

Returns: The parsed value if valid, otherwise default

Definition at line 175 of file config_parser.h.

                                                                  {
        T value = get<T>(config, key, default_value);
        if (validator(value)) {
            return value;
        }
        return default_value;
    }

References get().

Here is the call graph for this function:

◆ has_key()

static bool kcenon::monitoring::config_parser::has_key	(	const config_map &	config,
		const std::string &	key )

inlinestatic

Check if a configuration key exists.

Parameters

config	The configuration map
key	The configuration key to check

Returns: true if the key exists

Definition at line 93 of file config_parser.h.

                                                                        {
        return config.find(key) != config.end();
    }

◆ parse_bool()

static bool kcenon::monitoring::config_parser::parse_bool ( const std::string & str )

inlinestaticprivate

Parse boolean value from string.

Parameters

str	String to parse ("true", "1", "yes", "on" -> true)

Returns: Parsed boolean value

Definition at line 274 of file config_parser.h.

                                                 {
        if (str.empty()) {
            return false;
        }
        // Case-insensitive comparison
        std::string lower = str;
        for (auto& c : lower) {
            c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
        }
        return lower == "true" || lower == "1" || lower == "yes" || lower == "on";
    }

Referenced by parse_value(), and parse_value_optional().

Here is the caller graph for this function:

◆ parse_duration()

template<typename Duration >

static Duration kcenon::monitoring::config_parser::parse_duration	(	const std::string &	str,
		const Duration &	default_value )

inlinestaticprivate

Parse duration string with optional suffix Supported suffixes: ms (milliseconds), s (seconds), m (minutes), h (hours)

Definition at line 321 of file config_parser.h.

                                                                                        {
        try {
            if (str.empty()) {
                return default_value;
            }
 
            // Find where the number ends and suffix begins
            size_t suffix_start = str.find_first_not_of("0123456789.-");
 
            if (suffix_start == std::string::npos) {
                // Plain number, interpret as Duration's unit
                long long value = std::stoll(str);
                return Duration(value);
            }
 
            // Parse the numeric part
            long long value = std::stoll(str.substr(0, suffix_start));
            std::string suffix = str.substr(suffix_start);
 
            // Trim whitespace from suffix
            while (!suffix.empty() && std::isspace(static_cast<unsigned char>(suffix.front()))) {
                suffix.erase(0, 1);
            }
 
            // Convert to lowercase
            for (auto& c : suffix) {
                c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
            }
 
            // Parse suffix and convert to Duration
            if (suffix == "ms" || suffix == "millisecond" || suffix == "milliseconds") {
                return std::chrono::duration_cast<Duration>(std::chrono::milliseconds(value));
            } else if (suffix == "s" || suffix == "sec" || suffix == "second" || suffix == "seconds") {
                return std::chrono::duration_cast<Duration>(std::chrono::seconds(value));
            } else if (suffix == "m" || suffix == "min" || suffix == "minute" || suffix == "minutes") {
                return std::chrono::duration_cast<Duration>(std::chrono::minutes(value));
            } else if (suffix == "h" || suffix == "hr" || suffix == "hour" || suffix == "hours") {
                return std::chrono::duration_cast<Duration>(std::chrono::hours(value));
            } else {
                // Unknown suffix, treat as plain number
                return Duration(value);
            }
        } catch (...) {
            return default_value;
        }
    }

Referenced by get_duration().

Here is the caller graph for this function:

◆ parse_floating()

template<typename T >

static T kcenon::monitoring::config_parser::parse_floating ( const std::string & str )

inlinestaticprivate

Parse floating-point value from string.

Definition at line 305 of file config_parser.h.

                                                  {
        static_assert(std::is_floating_point_v<T>, "parse_floating requires floating point type");
        if constexpr (std::is_same_v<T, float>) {
            return std::stof(str);
        } else if constexpr (std::is_same_v<T, double>) {
            return std::stod(str);
        } else {
            return static_cast<T>(std::stold(str));
        }
    }

Referenced by parse_value(), and parse_value_optional().

Here is the caller graph for this function:

◆ parse_integral()

template<typename T >

static T kcenon::monitoring::config_parser::parse_integral ( const std::string & str )

inlinestaticprivate

Parse integral value from string.

Definition at line 290 of file config_parser.h.

                                                  {
        static_assert(std::is_integral_v<T>, "parse_integral requires integral type");
        if constexpr (std::is_signed_v<T>) {
            long long value = std::stoll(str);
            return static_cast<T>(value);
        } else {
            unsigned long long value = std::stoull(str);
            return static_cast<T>(value);
        }
    }

Referenced by parse_value(), and parse_value_optional().

Here is the caller graph for this function:

◆ parse_list()

template<typename T >

static std::vector< T > kcenon::monitoring::config_parser::parse_list	(	const std::string &	str,
		const std::vector< T > &	default_values )

inlinestaticprivate

Parse comma-separated list of values.

Definition at line 372 of file config_parser.h.

                                                                                             {
        try {
            if (str.empty()) {
                return default_values;
            }
 
            std::vector<T> result;
            std::string current;
 
            for (char c : str) {
                if (c == ',') {
                    // Trim whitespace
                    size_t start = current.find_first_not_of(" \t");
                    size_t end = current.find_last_not_of(" \t");
                    if (start != std::string::npos) {
                        std::string trimmed = current.substr(start, end - start + 1);
                        auto parsed = parse_value_optional<T>(trimmed);
                        if (parsed) {
                            result.push_back(*parsed);
                        }
                    }
                    current.clear();
                } else {
                    current += c;
                }
            }
 
            // Handle last element
            if (!current.empty()) {
                size_t start = current.find_first_not_of(" \t");
                size_t end = current.find_last_not_of(" \t");
                if (start != std::string::npos) {
                    std::string trimmed = current.substr(start, end - start + 1);
                    auto parsed = parse_value_optional<T>(trimmed);
                    if (parsed) {
                        result.push_back(*parsed);
                    }
                }
            }
 
            return result.empty() ? default_values : result;
        } catch (...) {
            return default_values;
        }
    }

References parse_value_optional().

Referenced by get_list().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parse_value()

template<typename T >

static T kcenon::monitoring::config_parser::parse_value	(	const std::string &	str,
		const T &	default_value )

inlinestaticprivate

Parse a string value to target type with default fallback.

Definition at line 229 of file config_parser.h.

                                                                       {
        try {
            if constexpr (std::is_same_v<T, bool>) {
                return parse_bool(str);
            } else if constexpr (std::is_same_v<T, std::string>) {
                return str;
            } else if constexpr (std::is_integral_v<T>) {
                return parse_integral<T>(str);
            } else if constexpr (std::is_floating_point_v<T>) {
                return parse_floating<T>(str);
            } else {
                return default_value;
            }
        } catch (...) {
            return default_value;
        }
    }

References parse_bool(), parse_floating(), and parse_integral().

Referenced by get().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parse_value_optional()

template<typename T >

static std::optional< T > kcenon::monitoring::config_parser::parse_value_optional ( const std::string & str )

inlinestaticprivate

Parse a string value to target type as optional.

Definition at line 251 of file config_parser.h.

                                                                     {
        try {
            if constexpr (std::is_same_v<T, bool>) {
                return parse_bool(str);
            } else if constexpr (std::is_same_v<T, std::string>) {
                return str;
            } else if constexpr (std::is_integral_v<T>) {
                return parse_integral<T>(str);
            } else if constexpr (std::is_floating_point_v<T>) {
                return parse_floating<T>(str);
            } else {
                return std::nullopt;
            }
        } catch (...) {
            return std::nullopt;
        }
    }

References parse_bool(), parse_floating(), and parse_integral().

Referenced by get_optional(), and parse_list().

Here is the call graph for this function:

Here is the caller graph for this function:

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

include/kcenon/monitoring/utils/config_parser.h

Static Public Member Functions

Static Private Member Functions

Detailed Description

Member Function Documentation

◆ get()

◆ get_clamped()

◆ get_duration()

◆ get_enum()

◆ get_list()

◆ get_matching()

◆ get_optional()

◆ get_validated()

◆ has_key()

◆ parse_bool()

◆ parse_duration()

◆ parse_floating()

◆ parse_integral()

◆ parse_list()

◆ parse_value()

◆ parse_value_optional()