glogger.h

Go to the documentation of this file.

#pragma once
 
// Color conventions and logging macros
#include <gemc/guts/gutsConventions.h>
#include <gemc/goptions/goptions.h>
#include <gemc/glogging/gmessageCatalog.h>
 
// Geant4
#include "G4UIsession.hh"
#include <array>
#include <atomic>
#include <stdexcept>
#include <string>
#include <string_view>
#include <sstream>
#include <type_traits>
#include <utility>
 

#if defined(__clang__) || defined(__GNUC__)
#define FUNCTION_NAME std::string(__PRETTY_FUNCTION__) + std::string(" > ")
#elif defined(_MSC_VER)
#define FUNCTION_NAME std::string(__FUNCSIG__) + std::string(" > ")
#else
#define FUNCTION_NAME std::string(__func__) + std::string(" > ")
#endif

#define SFUNCTION_NAME std::string(__func__) + std::string(" > ")

enum debug_type { NORMAL, CONSTRUCTOR, DESTRUCTOR };

class GLogger
{
public:
    explicit GLogger(const std::shared_ptr<GOptions>& gopts, const std::string& cname,
                     const std::string& lname = "")
        : class_name(cname), logger_name(lname), log_counter{0}, catalog(GMessageCatalog::load(gopts.get())) {
        // Resolve the runtime policy for this subsystem name from the global options.
        verbosity_level = gopts->getVerbosityFor(logger_name);
        debug_level     = gopts->getDebugFor(logger_name);
 
        // Optional lifetime trace to help identify logger ownership and construction order.
        debug(CONSTRUCTOR, "%1 logger", logger_name);
    }

    GLogger() : catalog(GMessageCatalog::load()) {}

    ~GLogger();

    template <typename... Args>
    void debug(debug_type type, std::string_view message, Args&&... args) const {
        if (debug_level == 0) return; // Debug disabled for this logger instance.
        const auto text = format_message(message, std::forward<Args>(args)...);
 
        switch (type) {
        case NORMAL:
            G4cout << guts::KCYN << header_string() << "DEBUG: " << text << guts::RST << G4endl;
            break;
        case CONSTRUCTOR:
            G4cout << guts::KCYN << header_string() << "DEBUG: " <<
                guts::CONSTRUCTORLOG << " " << text << " " << guts::CONSTRUCTORLOG << guts::RST << G4endl;
            break;
        case DESTRUCTOR:
            G4cout << guts::KCYN << header_string() << "DEBUG: " <<
                guts::DESTRUCTORLOG << " " << text << " " << guts::DESTRUCTORLOG << guts::RST << G4endl;
            break;
        }
    }

    template <typename... Args>
    void info(int level, std::string_view message, Args&&... args) const {
        if (info_enabled(level)) {
            const auto text = format_message(message, std::forward<Args>(args)...);
            G4cout << header_string() << "INFO L" << level << ": " << text << G4endl;
        }
    }

    template <typename Message, typename... Args>
        requires std::is_convertible_v<Message, std::string_view>
    void info(Message&& message, Args&&... args) const {
        info(0, std::string_view(std::forward<Message>(message)), std::forward<Args>(args)...);
    }

    template <typename... Args>
    void warning(std::string_view message, Args&&... args) const {
        const auto text = format_message(message, std::forward<Args>(args)...);
        G4cout << guts::KYEL << header_string() << guts::GWARNING << guts::KYEL << text
               << guts::RST << G4endl;
    }

    template <typename... Args>
    [[noreturn]] void error(int exit_code, std::string_view message, Args&&... args) const {
        const auto text = format_message(message, std::forward<Args>(args)...);
        G4cerr << guts::FATALERRORL << header_string() << guts::KRED << text << guts::RST << G4endl;
        G4cerr << guts::FATALERRORL << header_string() << guts::KRED << "Exit Code: " << exit_code << guts::RST
               << G4endl;
        std::exit(exit_code);
    }

    template <typename... Args>
    void critical(std::string_view message, Args&&... args) const {
        const auto text = format_message(message, std::forward<Args>(args)...);
        G4cout << guts::KBOLD << header_string() << guts::RST << text << G4endl;
    }

    template <typename... Args>
    void infoTemplate(int level, std::string_view message, Args&&... args) const {
        info(level, message, std::forward<Args>(args)...);
    }

    template <typename Message, typename... Args>
        requires std::is_convertible_v<Message, std::string_view>
    void infoTemplate(Message&& message, Args&&... args) const {
        info(0, std::string_view(std::forward<Message>(message)), std::forward<Args>(args)...);
    }

    template <typename... Args>
    void debugTemplate(debug_type type, std::string_view message, Args&&... args) const {
        debug(type, message, std::forward<Args>(args)...);
    }

    template <typename... Args>
    void warningTemplate(std::string_view message, Args&&... args) const {
        warning(message, std::forward<Args>(args)...);
    }

    template <typename... Args>
    [[noreturn]] void errorTemplate(int exit_code, std::string_view message, Args&&... args) const {
        error(exit_code, message, std::forward<Args>(args)...);
    }

    template <typename... Args>
    void criticalTemplate(std::string_view message, Args&&... args) const {
        critical(message, std::forward<Args>(args)...);
    }

    [[nodiscard]] std::string get_class_name() const { return class_name; }

    [[nodiscard]] const std::string& get_language() const { return catalog->language(); }
 
private:
    std::string class_name; 
    std::string logger_name;
    int verbosity_level{}; 
    int debug_level{};     
 
    mutable std::atomic<int> log_counter{}; 
    std::shared_ptr<const GMessageCatalog> catalog; 

    [[nodiscard]] bool info_enabled(int level) const {
        if (level != 0 && level != 1 && level != 2) {
            G4cerr << guts::FATALERRORL << header_string() << guts::GWARNING
                   << " Invalid verbosity level requested: " << level << guts::RST << G4endl;
            std::exit(goptions::EC_WRONG_VERBOSITY_LEVEL);
        }
        return level == 0 || (level == 1 && verbosity_level > 0) || (level == 2 && verbosity_level > 1);
    }

    template <typename... Args>
    [[nodiscard]] std::string format_message(std::string_view message, Args&&... args) const {
        return catalog->format(message, std::forward<Args>(args)...);
    }

    [[nodiscard]] std::string header_string() const {
        ++log_counter; // Increment first so the first emitted message is "1" rather than "0".
        return " [ " + logger_name + " - " + std::to_string(log_counter.load()) + " ] ";
    }
};