Logger.h

Go to the documentation of this file.

// This file is part of the MercuryDPM project (https://www.mercurydpm.org).
// Copyright (c), The MercuryDPM Developers Team. All rights reserved.
// License: BSD 3-Clause License; see the LICENSE file in the root directory.
 
#ifndef LOGGER_H
#define LOGGER_H
 
#include <string>
#include <sstream>
#include <functional>
#include <type_traits>
#include <iomanip>
#include "GeneralDefine.h"
#include <iostream>
 
#ifndef MERCURYDPM_LOGLEVEL
#define MERCURYDPM_LOGLEVEL Log::DEFAULT
#endif
 
#ifndef CG_LOGLEVEL
#define CG_LOGLEVEL Log::DEFAULT
#endif
 
#ifdef assert
#undef assert
//#error You included assert before the logger. Please use logger.assert_debug() instead.
#endif
 
#ifdef MERCURYDPM_FORCE_ASSERTS
#define MERCURYDPM_ASSERTS true
#else
#ifdef MERCURYDPM_NO_ASSERTS
#define MERCURYDPM_ASSERTS false
#else
#ifdef NDEBUG
#define MERCURYDPM_ASSERTS false
#else
#define MERCURYDPM_ASSERTS true
#endif
#endif
#endif
 
enum class Flusher
{
    FLUSH,
    NO_FLUSH
};
 
enum class Log
        : signed char
{
    FATAL = -20, ERROR = -15, WARN = -10, INFO = -5, DEFAULT = 0, VERBOSE = 5, DEBUG = 10
};
 
constexpr bool operator<=(const Log rhs, const Log lhs)
{
    return ((static_cast<signed char>(rhs)) <= (static_cast<signed char>(lhs)));
}
 
class LoggerOutput
{
public:
    std::function<void(std::string, std::string, Flusher)> onFatal;
    std::function<void(std::string, std::string, Flusher)> onError;
    std::function<void(std::string, std::string, Flusher)> onWarn;
    std::function<void(std::string, std::string, Flusher)> onInfo;
    std::function<void(std::string, std::string, Flusher)> onVerbose;
    std::function<void(std::string, std::string, Flusher)> onDebug;
};
 
extern LoggerOutput* loggerOutput;
 
// Forward declaration..
template<Log L = Log::DEFAULT, bool ASSERTS = MERCURYDPM_ASSERTS>
class Logger;
 
template<Log Level>
class LL
{
public:
};
 
extern LL<Log::FATAL> FATAL;
 
extern LL<Log::ERROR> ERROR;
 
extern LL<Log::WARN> WARN;
 
extern LL<Log::INFO> INFO;
 
extern LL<Log::DEFAULT> DEFAULT;
 
extern LL<Log::VERBOSE> VERBOSE;
 
extern LL<Log::DEBUG> DEBUG;
 
template<Log L, bool ASSERTS>
class Logger
{
 
private:
    const std::string module;
    Flusher doFlush_ = Flusher::FLUSH;
 
public:
    
    explicit Logger(const std::string name)
            : module(name)
    {
    }
    
    ~Logger()
    = default;
    
    template<Log LOGLEVEL, typename ... Args>
    typename std::enable_if<!((L < LOGLEVEL) && (MERCURYDPM_LOGLEVEL < LOGLEVEL)), void>::type
    operator()(const LL<LOGLEVEL> log, const char* format UNUSED, Args&& ... arg UNUSED)
    {
        std::stringstream msgstream;
        createMessage(msgstream, format, arg...);
        if (LOGLEVEL <= Log::FATAL)
        {
            loggerOutput->onFatal(module, msgstream.str(), doFlush_);
        }
        else if (LOGLEVEL <= Log::ERROR)
        {
            loggerOutput->onError(module, msgstream.str(), doFlush_);
        }
        else if (LOGLEVEL <= Log::WARN)
        {
            loggerOutput->onWarn(module, msgstream.str(), doFlush_);
            doFlush_ = Flusher::FLUSH;
        }
        else if (LOGLEVEL <= Log::INFO)
        {
            loggerOutput->onInfo(module, msgstream.str(), doFlush_);
            doFlush_ = Flusher::FLUSH;
        }
        else if (LOGLEVEL <= Log::VERBOSE)
        {
            loggerOutput->onVerbose(module, msgstream.str(), doFlush_);
            doFlush_ = Flusher::FLUSH;
        }
        else
        {
            loggerOutput->onDebug(module, msgstream.str(), doFlush_ = Flusher::FLUSH);
            doFlush_ = Flusher::FLUSH;
        }
    }
    
    template<Log LOGLEVEL, typename... Args>
    typename std::enable_if<L < LOGLEVEL && MERCURYDPM_LOGLEVEL < LOGLEVEL, void>::type
    operator()(const LL<LOGLEVEL> log, const char* format UNUSED, Args&& ... arg UNUSED)
    {
    }
    
    //std::string is sometimes convenient, but always slow, so where possible, don't convert the const char* to a string
    //before converting it back
    template<Log LOGLEVEL, typename... Args>
    void operator()(const LL<LOGLEVEL> log, const std::string& format UNUSED, Args&& ... arg
    UNUSED)
    {
        (*this)(log, format.c_str(), arg...);
    }
    
    template<typename... Args>
    typename std::enable_if<(ASSERTS) && (sizeof...(Args) >= 0), void>::type
    assert_debug(bool assertion, const char* format, Args&& ... arg)
    {
        assert_always(assertion, format, arg...);
    }
    
    template<typename... Args>
    typename std::enable_if<!((ASSERTS) && sizeof...(Args) >= 0), void>::type
    assert_debug(bool assertion, const char* format, Args&& ... arg)
    {
    }
    
    //the conversion from "" to a std::string is so slow, it takes 50% of the total run time for a release build...
    template<typename... Args>
    void assert_debug(bool assertion, const std::string format, Args&& ... arg)
    {
        assert_debug(assertion, format.c_str(), arg...);
    }
    
    template<typename... Args>
    void assert_always(bool assertion, const char* format, Args&& ... arg)
    {
        if (!assertion)
        {
            std::stringstream msgstream;
            createMessage(msgstream, format, arg...);
            loggerOutput->onFatal(module, msgstream.str(), doFlush_);
        }
        
    }
    
    template<typename... Args>
    void assert_always(bool assertion, const std::string format, Args&& ... arg)
    {
        assert_always(assertion, format.c_str(), arg...);
    }
    
    template<typename... Args>
    MERCURYDPM_DEPRECATED
    void log(const Log loglevel, const std::string& format, Args&& ... arg)
    {
        if (loglevel <= L || loglevel <= MERCURYDPM_LOGLEVEL)
        {
            std::stringstream msgstream;
            createMessage(msgstream, format.c_str(), arg...);
            if (loglevel <= Log::FATAL)
            {
                loggerOutput->onFatal(module, msgstream.str(), doFlush_);
            }
            else if (loglevel <= Log::ERROR)
            {
                loggerOutput->onError(module, msgstream.str(), doFlush_);
            }
            else if (loglevel <= Log::WARN)
            {
                loggerOutput->onWarn(module, msgstream.str(), doFlush_);
                doFlush_ = Flusher::FLUSH;
            }
            else if (loglevel <= Log::INFO)
            {
                loggerOutput->onInfo(module, msgstream.str(), doFlush_);
                doFlush_ = Flusher::FLUSH;
            }
            else if (loglevel <= Log::VERBOSE)
            {
                loggerOutput->onVerbose(module, msgstream.str(), doFlush_);
                doFlush_ = Flusher::FLUSH;
            }
            else
            {
                loggerOutput->onDebug(module, msgstream.str(), doFlush_ = Flusher::FLUSH);
                doFlush_ = Flusher::FLUSH;
            }
        }
    }
 
private:
    
    template<typename Arg1, typename... Args>
    void createMessage(std::stringstream& msg, const char* fmt,
                       Arg1&& arg, Args&& ... args)
    {
        bool doSkipNext = false;
        while (*fmt != '%' || doSkipNext)
        {
            //Make sure we're not running past the end of our formatting string.
            if (*fmt == '\0')
                return;
            
            if (*fmt == '\\' && !doSkipNext)
            { //Escape for the % character
                doSkipNext = true;
                fmt++;
            }
            else
            {
                msg << *fmt;
                fmt++;
                doSkipNext = false;
            }
        }
        fmt++; //Consume the % character
        int precision = 0;
        int width = 0;
        // if precision and width or only precision is defined
        if (isdigit(*fmt))
        {
            precision = std::atoi(fmt);
            while (isdigit(*fmt))
            {
                fmt++;
            }
            if (std::ispunct(*fmt))
            {
                fmt++;
                if (std::isdigit(*fmt))
                {
                    width = std::atoi(fmt);
                    while (isdigit(*fmt))
                    {
                        fmt++;
                    }
                }
                    // else the char is a real full stop so set the pointer back to full stop.
                else
                {
                    fmt--;
                }
            }
        }
            // if only a width and no precision defined
        else if (std::ispunct(*fmt))
        {
            fmt++;
            if (std::isdigit(*fmt))
            {
                width = std::atoi(fmt);
                while (isdigit(*fmt))
                {
                    fmt++;
                }
            }
                // else the char is a real full stop so set the pointer back to full stop.
            else
            {
                fmt--;
            }
        }
        if (width != 0 && precision != 0)
        {
            msg << std::setprecision(precision) << std::left << std::setw(width) << arg;
        }
        else if (precision != 0)
        {
            msg << std::setprecision(precision) << arg;
        }
        else if (width != 0)
        {
            msg << std::left << std::setw(width) << arg;
        }
        else
        {
            msg << arg;
        } //include args somehow..
        createMessage(msg, fmt, args...);//and recursively call ourselve / the method below.
    }
    
    
    //terminating case for Flusher not needed. This function is also called when the parameter pack Args&& args is
    // empty
    template<typename... Args>
    void createMessage(std::stringstream& msg, const char* fmt,
                       Flusher arg, Args&& ... args)
    {
        // only suppress flushing if Mercury is not in CMAKE_BUILD_TYPE "Debug" and if the user defined loglevel from
        // cMake is below VERBOSE/DEBUG (<=5)
#ifndef MERCURYDPM_DEBUG
        if (arg != Flusher::FLUSH && MERCURYDPM_LOGLEVEL <= Log::VERBOSE)
        {
            doFlush_ = Flusher::NO_FLUSH;
        }
#endif
        // skip this argument by recursively calling this function again
        createMessage(msg, fmt, args...);
    }
    
    
    // faster than above function and non recursive that is why it is good to have it
    template<typename Arg1>
    void createMessage(std::stringstream& msg, const char* fmt, Arg1&& arg)
    {
        bool doSkipNext = false;
        while (*fmt != '%' || doSkipNext)
        {
            if (*fmt == '\0') // End of string
                return;
            
            if (*fmt == '\\' && !doSkipNext)
            { //Escape for the % character and the \ character
                doSkipNext = true;
                fmt++;
            }
            else
            { //invoke the replacement
                msg << *fmt;
                fmt++;
                doSkipNext = false;
            }
        }
        fmt++; //Consume the % character
        int precision = 0;
        int width = 0;
        // if precision and width or only precision is defined
        if (isdigit(*fmt))
        {
            precision = std::atoi(fmt);
            while (isdigit(*fmt))
            {
                fmt++;
            }
            if (std::ispunct(*fmt))
            {
                fmt++;
                if (std::isdigit(*fmt))
                {
                    width = std::atoi(fmt);
                    while (isdigit(*fmt))
                    {
                        fmt++;
                    }
                }
                    // else the char is a real full stop so set the pointer back to full stop.
                else
                {
                    fmt--;
                }
            }
        }
            // if only a width and no precision defined
        else if (std::ispunct(*fmt))
        {
            fmt++;
            if (std::isdigit(*fmt))
            {
                width = std::atoi(fmt);
                while (isdigit(*fmt))
                {
                    fmt++;
                }
            }
                // else the char is a real full stop so set the pointer back to full stop.
            else
            {
                fmt--;
            }
        }
        if (width != 0 && precision != 0)
        {
            msg << std::setprecision(precision) << std::left << std::setw(width) << arg << fmt;
        }
        else if (precision != 0)
        {
            msg << std::setprecision(precision) << arg << fmt;
        }
        else if (width != 0)
        {
            msg << std::left << std::setw(width) << arg << fmt;
        }
        else
        {
            msg << arg << fmt;
        }
    }
    
    
    void createMessage(std::stringstream& msg, const char* message)
    {
        msg << message;
    }
};
 
extern Logger<MERCURYDPM_LOGLEVEL> logger;
 
extern Logger<CG_LOGLEVEL> cgLogger;
 
//just emptying the functions is not sufficiently aggressive in disabling the actual (costly) comparison
#if !MERCURYDPM_ASSERTS
#define assert(e,...) assert(true,"")
#endif
 
#ifdef MERCURYDPM_USE_MPI
#include "MpiContainer.h"
#endif
 
#endif