String utility functions for log formatting and conversion. More...

#include <string_utils.h>

Collaboration diagram for kcenon::logger::utils::string_utils:

Static Public Member Functions
static std::string	level_to_string (log_level level)
	Convert log level to human-readable string.

static std::string	level_to_color (log_level level, bool use_colors=true)
	Convert log level to ANSI color code.

static const char *	color_reset ()
	ANSI color reset sequence.

static std::string	escape_json (const std::string &str)
	Escape special characters for JSON.

static std::string	escape_xml (const std::string &str)
	Escape special characters for XML.

static std::string	extract_filename (const std::string &file_path)
	Extract filename from full file path.

static std::string	trim (const std::string &str)
	Trim whitespace from both ends of string.

static std::string	to_lower (const std::string &str)
	Convert string to lowercase.

static std::string	to_upper (const std::string &str)
	Convert string to uppercase.

static std::string	replace_all (const std::string &str, const std::string &from, const std::string &to)
	Replace all occurrences of a substring.

Detailed Description

String utility functions for log formatting and conversion.

Provides common string manipulation functions used across formatters and writers, including escaping, conversion, and extraction utilities.

Definition at line 31 of file string_utils.h.

Member Function Documentation

◆ color_reset()

static const char * kcenon::logger::utils::string_utils::color_reset ( )

inlinestatic

ANSI color reset sequence.

Returns: ANSI escape sequence to reset colors

Note: Use after colored output to reset terminal colors.

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/formatters/template_formatter.h.

Definition at line 95 of file string_utils.h.

                                     {
        return "\033[0m";
    }

Referenced by kcenon::logger::timestamp_formatter::format(), and kcenon::logger::template_formatter::resolve_placeholder().

Here is the caller graph for this function:

◆ escape_json()

static std::string kcenon::logger::utils::string_utils::escape_json ( const std::string & str )

inlinestatic

Escape special characters for JSON.

Parameters

str	String to escape

Returns: JSON-escaped string safe for inclusion in JSON documents

Escaped characters:

" → \"
\ → \
/ → \/
, \f,
, \r, \t → respective escape sequences
Control characters (0x00-0x1F) → \uXXXX

Note: Thread-safe. Creates a new string with escaped content.; Compatible with JSON parsers and log aggregation systems.

Definition at line 114 of file string_utils.h.

                                                       {
        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();
    }

Referenced by kcenon::logger::json_formatter::format(), and kcenon::logger::json_formatter::format_value().

Here is the caller graph for this function:

◆ escape_xml()

static std::string kcenon::logger::utils::string_utils::escape_xml ( const std::string & str )

inlinestatic

Escape special characters for XML.

Parameters

str	String to escape

Returns: XML-escaped string safe for inclusion in XML documents

Escaped characters:

& → &
< → <
> → >
" → "
' → '

Note: Thread-safe. Creates a new string with escaped content.

Definition at line 155 of file string_utils.h.

                                                      {
        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();
    }

◆ extract_filename()

static std::string kcenon::logger::utils::string_utils::extract_filename ( const std::string & file_path )

inlinestatic

Extract filename from full file path.

Parameters

file_path Full path to file (may include directories)

Returns: Just the filename without directory components

Examples:

"/path/to/file.cpp" → "file.cpp"
"C:\\path\\to\\file.cpp" → "file.cpp"
"file.cpp" → "file.cpp"

Note: Works with both Unix (/) and Windows () path separators.; Thread-safe.

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/formatters/template_formatter.h.

Definition at line 183 of file string_utils.h.

                                                                  {
        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;
    }

Referenced by kcenon::logger::timestamp_formatter::format(), and kcenon::logger::template_formatter::resolve_placeholder().

Here is the caller graph for this function:

◆ level_to_color()

static std::string kcenon::logger::utils::string_utils::level_to_color	(	log_level	level,
		bool	use_colors = true )

inlinestatic

Convert log level to ANSI color code.

Parameters

level	Log level to convert
use_colors	Whether to return colors (if false, returns empty string)

Returns: ANSI escape sequence for the log level color

Color mapping:

CRITICAL/FATAL: Bright Magenta
ERROR: Bright Red
WARNING: Bright Yellow
INFO: Bright Green
DEBUG: Bright Cyan
TRACE: White

Note: Use with "\033[0m" to reset color after output.; Thread-safe and stateless.

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/formatters/template_formatter.h.

Definition at line 72 of file string_utils.h.

                                                                             {
        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 "";
    }

Referenced by kcenon::logger::timestamp_formatter::format(), and kcenon::logger::template_formatter::resolve_placeholder().

Here is the caller graph for this function:

◆ level_to_string()

static std::string kcenon::logger::utils::string_utils::level_to_string ( log_level level )

inlinestatic

Convert log level to human-readable string.

Parameters

level Log level to convert

Returns: String representation of log level

Output format: "CRITICAL", "ERROR", "WARNING", "INFO", "DEBUG", "TRACE", "OFF"

Note: Thread-safe and stateless.

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/formatters/template_formatter.h.

Definition at line 42 of file string_utils.h.

                                                      {
        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";
    }

Referenced by kcenon::logger::json_formatter::format(), kcenon::logger::timestamp_formatter::format(), kcenon::logger::network_writer::format_for_network(), and kcenon::logger::template_formatter::resolve_placeholder().

Here is the caller graph for this function:

◆ replace_all()

static std::string kcenon::logger::utils::string_utils::replace_all	(	const std::string &	str,
		const std::string &	from,
		const std::string &	to )

inlinestatic

Replace all occurrences of a substring.

Parameters

str	Source string
from	Substring to replace
to	Replacement substring

Returns: String with all replacements made

Note: If 'from' is empty, returns original string.; Thread-safe. Creates a new string.

Definition at line 262 of file string_utils.h.

      {
        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;
    }

◆ to_lower()

static std::string kcenon::logger::utils::string_utils::to_lower ( const std::string & str )

inlinestatic

Convert string to lowercase.

Parameters

str	String to convert

Returns: Lowercase version of string

Note: Only converts ASCII characters (A-Z → a-z).; Thread-safe. Creates a new string.

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/formatters/template_formatter.h.

Definition at line 224 of file string_utils.h.

                                                    {
        std::string result = str;
        for (char& c : result) {
            if (c >= 'A' && c <= 'Z') {
                c = c + ('a' - 'A');
            }
        }
        return result;
    }

Referenced by kcenon::logger::template_formatter::resolve_placeholder().

Here is the caller graph for this function:

◆ to_upper()

static std::string kcenon::logger::utils::string_utils::to_upper ( const std::string & str )

inlinestatic

Convert string to uppercase.

Parameters

str	String to convert

Returns: Uppercase version of string

Note: Only converts ASCII characters (a-z → A-Z).; Thread-safe. Creates a new string.

Definition at line 242 of file string_utils.h.

                                                    {
        std::string result = str;
        for (char& c : result) {
            if (c >= 'a' && c <= 'z') {
                c = c - ('a' - 'A');
            }
        }
        return result;
    }

◆ trim()

static std::string kcenon::logger::utils::string_utils::trim ( const std::string & str )

inlinestatic

Trim whitespace from both ends of string.

Parameters

str	String to trim

Returns: Trimmed string

Note: Removes spaces, tabs, newlines, and other whitespace characters.; Thread-safe. Creates a new string.

Definition at line 204 of file string_utils.h.

                                                {
        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);
    }

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

include/kcenon/logger/utils/string_utils.h

Static Public Member Functions

Detailed Description

Member Function Documentation

◆ color_reset()

◆ escape_json()

◆ escape_xml()

◆ extract_filename()

◆ level_to_color()

◆ level_to_string()

◆ replace_all()

◆ to_lower()

◆ to_upper()

◆ trim()