string_utils.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <string>
#include <sstream>
#include <iomanip>
 
// Use common_system's standard interface
#include <kcenon/common/interfaces/logger_interface.h>
 
namespace kcenon::logger::utils {
 
// Type alias for log_level
using log_level = common::interfaces::log_level;
 
class string_utils {
public:
    static std::string level_to_string(log_level level) {
        switch (level) {
            case log_level::critical:  return "CRITICAL";
            case log_level::error:     return "ERROR";
            case log_level::warning:   return "WARNING";
            case log_level::info:      return "INFO";
            case log_level::debug:     return "DEBUG";
            case log_level::trace:     return "TRACE";
            case log_level::off:       return "OFF";
        }
        return "UNKNOWN";
    }
 
    static std::string level_to_color(log_level level, bool use_colors = true) {
        if (!use_colors) {
            return "";
        }
 
        switch (level) {
            case log_level::critical:  return "\033[1;35m"; // Bright Magenta
            case log_level::error:     return "\033[1;31m"; // Bright Red
            case log_level::warning:   return "\033[1;33m"; // Bright Yellow
            case log_level::info:      return "\033[1;32m"; // Bright Green
            case log_level::debug:     return "\033[1;36m"; // Bright Cyan
            case log_level::trace:     return "\033[37m";   // White
            case log_level::off:       return "\033[90m";   // Dark Gray
        }
        return "";
    }
 
    static const char* color_reset() {
        return "\033[0m";
    }
 
    static std::string escape_json(const std::string& str) {
        std::ostringstream oss;
        for (char c : str) {
            switch (c) {
                case '"':  oss << "\\\""; break;
                case '\\': oss << "\\\\"; break;
                case '/':  oss << "\\/"; break;
                case '\b': oss << "\\b"; break;
                case '\f': oss << "\\f"; break;
                case '\n': oss << "\\n"; break;
                case '\r': oss << "\\r"; break;
                case '\t': oss << "\\t"; break;
                default:
                    // Handle control characters
                    if (c >= 0 && c < 0x20) {
                        oss << "\\u"
                            << std::hex << std::setw(4) << std::setfill('0')
                            << static_cast<int>(c);
                    } else {
                        oss << c;
                    }
                    break;
            }
        }
        return oss.str();
    }
 
    static std::string escape_xml(const std::string& str) {
        std::ostringstream oss;
        for (char c : str) {
            switch (c) {
                case '&':  oss << "&amp;"; break;
                case '<':  oss << "&lt;"; break;
                case '>':  oss << "&gt;"; break;
                case '"':  oss << "&quot;"; break;
                case '\'': oss << "&apos;"; break;
                default:   oss << c; break;
            }
        }
        return oss.str();
    }
 
    static std::string extract_filename(const std::string& file_path) {
        if (file_path.empty()) {
            return file_path;
        }
 
        size_t pos = file_path.find_last_of("/\\");
        if (pos != std::string::npos) {
            return file_path.substr(pos + 1);
        }
 
        return file_path;
    }
 
    static std::string trim(const std::string& str) {
        const char* whitespace = " \t\n\r\f\v";
 
        size_t start = str.find_first_not_of(whitespace);
        if (start == std::string::npos) {
            return "";  // String is all whitespace
        }
 
        size_t end = str.find_last_not_of(whitespace);
        return str.substr(start, end - start + 1);
    }
 
    static std::string to_lower(const std::string& str) {
        std::string result = str;
        for (char& c : result) {
            if (c >= 'A' && c <= 'Z') {
                c = c + ('a' - 'A');
            }
        }
        return result;
    }
 
    static std::string to_upper(const std::string& str) {
        std::string result = str;
        for (char& c : result) {
            if (c >= 'a' && c <= 'z') {
                c = c - ('a' - 'A');
            }
        }
        return result;
    }
 
    static std::string replace_all(
        const std::string& str,
        const std::string& from,
        const std::string& to
    ) {
        if (from.empty()) {
            return str;
        }
 
        std::string result = str;
        size_t pos = 0;
 
        while ((pos = result.find(from, pos)) != std::string::npos) {
            result.replace(pos, from.length(), to);
            pos += to.length();
        }
 
        return result;
    }
};
 
} // namespace kcenon::logger::utils