config_parser.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2021-2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <cctype>
#include <chrono>
#include <functional>
#include <optional>
#include <regex>
#include <string>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
namespace kcenon::monitoring {
 
using config_map = std::unordered_map<std::string, std::string>;
 
class config_parser {
   public:
    template <typename T>
    static T get(const config_map& config, const std::string& key, const T& default_value) {
        auto it = config.find(key);
        if (it == config.end()) {
            return default_value;
        }
        return parse_value<T>(it->second, default_value);
    }
 
    template <typename T>
    static std::optional<T> get_optional(const config_map& config, const std::string& key) {
        auto it = config.find(key);
        if (it == config.end()) {
            return std::nullopt;
        }
        return parse_value_optional<T>(it->second);
    }
 
    static bool has_key(const config_map& config, const std::string& key) {
        return config.find(key) != config.end();
    }
 
    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) {
        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;
    }
 
    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) {
        T value = get<T>(config, key, default_value);
        if (allowed_values.find(value) != allowed_values.end()) {
            return value;
        }
        return default_value;
    }
 
    static std::string get_matching(const config_map& config, const std::string& key,
                                     const std::string& default_value, const std::string& pattern) {
        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;
    }
 
    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) {
        T value = get<T>(config, key, default_value);
        if (validator(value)) {
            return value;
        }
        return default_value;
    }
 
    template <typename Duration>
    static Duration get_duration(const config_map& config, const std::string& key,
                                  const Duration& default_value) {
        auto it = config.find(key);
        if (it == config.end()) {
            return default_value;
        }
        return parse_duration<Duration>(it->second, default_value);
    }
 
    template <typename T>
    static std::vector<T> get_list(const config_map& config, const std::string& key,
                                    const std::vector<T>& default_values) {
        auto it = config.find(key);
        if (it == config.end()) {
            return default_values;
        }
        return parse_list<T>(it->second, default_values);
    }
 
   private:
    template <typename T>
    static T parse_value(const std::string& str, const T& default_value) {
        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;
        }
    }
 
    template <typename T>
    static std::optional<T> parse_value_optional(const std::string& str) {
        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;
        }
    }
 
    static bool parse_bool(const std::string& str) {
        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";
    }
 
    template <typename T>
    static T parse_integral(const std::string& str) {
        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);
        }
    }
 
    template <typename T>
    static T parse_floating(const std::string& str) {
        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));
        }
    }
 
    template <typename Duration>
    static Duration parse_duration(const std::string& str, const Duration& default_value) {
        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;
        }
    }
 
    template <typename T>
    static std::vector<T> parse_list(const std::string& str, const std::vector<T>& default_values) {
        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;
        }
    }
};
 
}  // namespace kcenon::monitoring