glogger.h

Go to the documentation of this file.

#ifndef GLOGGER_H
#define GLOGGER_H
 
// Color conventions and logging macros
#include "gutsConventions.h"
#include "goptions.h"
 
// Geant4
#include "G4UIsession.hh"
#include <atomic>
#include <string>
#include <cstdlib>
#include <sstream>
#include <utility>
 
 enum debug_type { NORMAL, CONSTRUCTOR, DESTRUCTOR };
 
class GLogger {
public:
    explicit GLogger(GOptions* gopts, std::string vname)
            : name(std::move(vname)), log_counter(0) {
        verbosity_level = gopts->getVerbosityFor(name);
        debug_level = gopts->getDebugFor(name);
        debug(CONSTRUCTOR,name, " logger");
    }
 
    // default constructor
    GLogger() = default;
 
    ~GLogger() {
        debug(DESTRUCTOR, name, " logger");
    }
 
    template <typename... Args>
    void debug(debug_type type, Args&&... args) const {
        if (debug_level == 0) return;
 
        std::ostringstream oss;
        (oss << ... << std::forward<Args>(args));
 
        switch (type) {
            case NORMAL:
                G4cout << KYEL << header_string() << oss.str() << RST << G4endl;
                break;
            case CONSTRUCTOR:
                G4cout << KCYN << header_string() << CONSTRUCTORLOG << " constructor " << CONSTRUCTORLOG << " " << RST << oss.str() << G4endl;
                break;
            case DESTRUCTOR:
                G4cout << KCYN << header_string() << DESTRUCTORLOG << " destructor " << DESTRUCTORLOG << " " << RST << oss.str() << G4endl;
                break;
        }
    }
 
    template <typename... Args>
    void info(int level, Args&&... args) const {
 
        // error if level is not 0, 1 or 2
        if (level != 0 && level != 1  && level != 2 ) {
            G4cerr << FATALERRORL << header_string() << GWARNING <<  " Invalid verbosity level requested: " << level << RST << G4endl;
            exit(EC_WRONG_VERBOSITY_LEVEL);
        }
 
        if (level == 0 || (level == 1 && verbosity_level > 0) || (level == 2 && verbosity_level > 1)) {
            std::ostringstream oss;
            (oss << ... << std::forward<Args>(args));
            G4cout << header_string() << oss.str() << G4endl;
        }
    }
 
    template <typename... Args>
    void info(Args&&... args) const {
        info(0, std::forward<Args>(args)...);
    }
 
    template <typename... Args>
    void warning(Args&&... args) const {
        std::ostringstream oss;
        (oss << ... << std::forward<Args>(args));
        G4cout << KYEL << header_string() << GWARNING << oss.str() << RST << G4endl;
    }
 
    template <typename... Args>
    [[noreturn]] void error(int exit_code, Args&&... args) const {
        std::ostringstream oss;
        (oss << ... << std::forward<Args>(args));
        G4cerr << FATALERRORL << header_string() << KRED << oss.str() << RST << G4endl;
        std::exit(exit_code);
    }
 
    template <typename... Args>
    void critical(Args&&... args) const {
        std::ostringstream oss;
        (oss << ... << std::forward<Args>(args));
        G4cout << KBOLD << header_string() << RST << oss.str() << G4endl;
    }
 
private:
    std::string name;       
    int verbosity_level;          
    int debug_level;              
 
    mutable std::atomic<int> log_counter; 
 
    [[nodiscard]] std::string header_string() const {
        log_counter++;
        return name + " [" + std::to_string(log_counter.load()) + "] ";
    }
};
 
#endif // GLOGGER_H