error_handling_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 <kcenon/logger/core/error_codes.h>
#include <kcenon/common/config/feature_flags.h>
#include <filesystem>
#include <system_error>
#include <chrono>
#include <sstream>
#include <iostream>
 
#if KCENON_HAS_SOURCE_LOCATION
#  include <source_location>
#endif
 
// Legacy alias for backward compatibility
#ifndef LOGGER_HAS_SOURCE_LOCATION
#  define LOGGER_HAS_SOURCE_LOCATION KCENON_HAS_SOURCE_LOCATION
#endif
 
namespace kcenon::logger::utils {
 
struct error_context {
    logger_error_code code;
    std::string message;
    std::string operation;     // Operation being performed
    std::string source_file;   // Source file where error occurred
    int source_line;           // Line number where error occurred
    std::string function_name; // Function where error occurred
    std::chrono::system_clock::time_point timestamp;
 
#if KCENON_HAS_SOURCE_LOCATION
    error_context(
        logger_error_code error_code,
        std::string error_message,
        std::string op = "",
        std::source_location loc = std::source_location::current()
    ) : code(error_code),
        message(std::move(error_message)),
        operation(std::move(op)),
        source_file(loc.file_name()),
        source_line(static_cast<int>(loc.line())),
        function_name(loc.function_name()),
        timestamp(std::chrono::system_clock::now()) {}
#else
    error_context(
        logger_error_code error_code,
        std::string error_message,
        std::string op = "",
        std::string file = "",
        int line = 0
    ) : code(error_code),
        message(std::move(error_message)),
        operation(std::move(op)),
        source_file(std::move(file)),
        source_line(line),
        function_name(""),
        timestamp(std::chrono::system_clock::now()) {}
#endif
 
    std::string to_string() const {
        std::ostringstream oss;
        oss << "[" << logger_error_to_string(code) << "]";
        if (!message.empty()) {
            oss << " " << message;
        }
        if (!operation.empty()) {
            oss << " (during: " << operation << ")";
        }
        if (!source_file.empty()) {
            oss << " at " << source_file;
            if (source_line > 0) {
                oss << ":" << source_line;
            }
        }
        if (!function_name.empty()) {
            oss << " in " << function_name << "()";
        }
        return oss.str();
    }
};
 
inline void log_error_context(const error_context& context) {
    std::cerr << "[logger_system] Error: " << context.to_string() << std::endl;
}
 
template<typename F>
common::VoidResult try_write_operation(
    F&& operation,
    logger_error_code default_error_code = logger_error_code::file_write_failed
) {
    try {
        return operation();
    }
    catch (const std::filesystem::filesystem_error& e) {
        // Filesystem-specific errors (permission denied, disk full, etc.)
        return make_logger_void_result(
            logger_error_code::file_permission_denied,
            std::string("Filesystem error: ") + e.what()
        );
    }
    catch (const std::ios_base::failure& e) {
        // I/O operation failures (stream errors, write errors, etc.)
        return make_logger_void_result(
            logger_error_code::file_write_failed,
            std::string("I/O error: ") + e.what()
        );
    }
    catch (const std::system_error& e) {
        // System-level errors
        return make_logger_void_result(
            default_error_code,
            std::string("System error: ") + e.what()
        );
    }
    catch (const std::bad_alloc& e) {
        // Memory allocation failures
        return make_logger_void_result(
            logger_error_code::buffer_overflow,
            std::string("Memory allocation failed: ") + e.what()
        );
    }
    catch (const std::exception& e) {
        // Generic exception catch-all
        return make_logger_void_result(
            default_error_code,
            std::string("Unexpected error: ") + e.what()
        );
    }
    catch (...) {
        // Non-standard exception
        return make_logger_void_result(
            default_error_code,
            "Unknown error (non-standard exception)"
        );
    }
}
 
template<typename F>
common::VoidResult try_open_operation(F&& operation) {
    return try_write_operation(
        std::forward<F>(operation),
        logger_error_code::file_open_failed
    );
}
 
template<typename F>
common::VoidResult try_network_operation(F&& operation) {
    return try_write_operation(
        std::forward<F>(operation),
        logger_error_code::network_send_failed
    );
}
 
template<typename F>
common::VoidResult try_encryption_operation(F&& operation) {
    return try_write_operation(
        std::forward<F>(operation),
        logger_error_code::encryption_failed
    );
}
 
inline common::VoidResult check_condition(
    bool condition,
    logger_error_code error_code,
    const std::string& message
) {
    if (!condition) {
        return make_logger_void_result(error_code, message);
    }
    return common::ok();
}
 
template<typename Stream>
inline common::VoidResult check_stream_state(
    const Stream& stream,
    const std::string& operation_name = "operation"
) {
    if (!stream.good()) {
        if (stream.eof()) {
            return make_logger_void_result(
                logger_error_code::file_write_failed,
                "Stream error: Unexpected end of file during " + operation_name
            );
        }
        if (stream.fail()) {
            return make_logger_void_result(
                logger_error_code::file_write_failed,
                "Stream error: Logical error during " + operation_name
            );
        }
        if (stream.bad()) {
            return make_logger_void_result(
                logger_error_code::file_write_failed,
                "Stream error: Read/write error during " + operation_name
            );
        }
        return make_logger_void_result(
            logger_error_code::file_write_failed,
            "Stream is in an error state after " + operation_name
        );
    }
    return common::ok();
}
 
inline common::VoidResult check_file_exists(const std::filesystem::path& path) {
    try {
        if (!std::filesystem::exists(path)) {
            return make_logger_void_result(
                logger_error_code::file_open_failed,
                "File does not exist: " + path.string()
            );
        }
        return common::ok();
    } catch (const std::filesystem::filesystem_error& e) {
        return make_logger_void_result(
            logger_error_code::file_permission_denied,
            std::string("Cannot access file: ") + e.what()
        );
    }
}
 
inline common::VoidResult ensure_directory_exists(const std::filesystem::path& dir) {
    if (dir.empty()) {
        return common::ok(); // Empty path is valid (current directory)
    }
 
    return try_open_operation([&]() -> common::VoidResult {
        if (!std::filesystem::exists(dir)) {
            if (!std::filesystem::create_directories(dir)) {
                return make_logger_void_result(
                    logger_error_code::file_permission_denied,
                    "Failed to create directory: " + dir.string()
                );
            }
        }
        return common::ok();
    });
}
 
template<typename F>
inline void safe_destructor_operation(
    const std::string& operation_name,
    F&& operation
) noexcept {
    try {
        operation();
    }
    catch (const std::exception& e) {
        error_context ctx(
            logger_error_code::destructor_cleanup_failed,
            e.what(),
            operation_name
        );
        log_error_context(ctx);
    }
    catch (...) {
        error_context ctx(
            logger_error_code::destructor_cleanup_failed,
            "Unknown exception",
            operation_name
        );
        log_error_context(ctx);
    }
}
 
template<typename F>
inline void safe_destructor_result_operation(
    const std::string& operation_name,
    F&& operation
) noexcept {
    try {
        auto result = operation();
        if (result.is_err()) {
            error_context ctx(
                get_logger_error_code(result),
                result.error().message,
                operation_name
            );
            log_error_context(ctx);
        }
    }
    catch (const std::exception& e) {
        error_context ctx(
            logger_error_code::destructor_cleanup_failed,
            e.what(),
            operation_name
        );
        log_error_context(ctx);
    }
    catch (...) {
        error_context ctx(
            logger_error_code::destructor_cleanup_failed,
            "Unknown exception",
            operation_name
        );
        log_error_context(ctx);
    }
}
 
} // namespace kcenon::logger::utils