Logger.h

Go to the documentation of this file.

//Copyright (c) 2013-2014, The MercuryDPM Developers Team. All rights reserved.
//For the list of developers, see <http://www.MercuryDPM.org/Team>.
//
//Redistribution and use in source and binary forms, with or without
//modification, are permitted provided that the following conditions are met:
//  * Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//  * Neither the name MercuryDPM nor the
//    names of its contributors may be used to endorse or promote products
//    derived from this software without specific prior written permission.
//
//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
//ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
//WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
//DISCLAIMED. IN NO EVENT SHALL THE MERCURYDPM DEVELOPERS TEAM BE LIABLE FOR ANY
//DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
//(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
//LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
//ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
//(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#ifndef LOGGER_H
#define LOGGER_H

#include <string>
#include <sstream>
#include <functional>
#include <type_traits>
#include "GeneralDefine.h"

#ifndef MERCURY_LOGLEVEL
#define MERCURY_LOGLEVEL Log::DEFAULT
#endif

#ifdef assert
#undef assert
//#error You included assert before the logger. Please use logger.assert() instead.
#endif

#ifdef MERCURY_FORCE_ASSERTS
#define MERCURY_ASSERTS true
#else
#ifdef MERCURY_NO_ASSERTS
#define MERCURY_ASSERTS false
#else
#ifdef NDEBUG
#define MERCURY_ASSERTS false
#else
#define MERCURY_ASSERTS true
#endif
#endif
#endif

/* IMPLEMENTATION DETAIL
 *    - by dducks
 * 
 * A brief explanation how this class works. Beware, there is black magic
 * going on here.
 *
 * So, the previous version of the Logger used the syntax
 * Logger<Log::LEVEL> logger;
 * logger.log(Log::LEVEL, "Message", args...);
 * However, people didn't like the slightly large amount of log's in a single
 * statement. Therefore, the operator() has been chosen. The next problem I
 * personally had with the logger is the fact that it relied on a compile-time
 * resolvable if-statement which could often (always) be optimised out. The
 * problem however is that you would need optimisation enabled to have no
 * speed penalty for loglevels below visibility.
 *
 * The problem however, is that we want to generate different code based on
 * the first parameter; the loglevel. Because we actually want to generate
 * code and people don't like the preprocessor, we have to use the template
 * system to do this.
 *
 * One of the caveats of the template system is that it is only able to
 * resolve templates based on parameters, not on values. It also allows you
 * to ommit template parameters in case where the template parameters can be
 * deduced.
 *
 * Based on these two rules, we now need not a value per loglevel, but a type.
 * Therefore we use tagging, in which we use the class LL with a template argument
 * to create the different tags. Our loglevel, the enum class Log, is considered
 * to be a valid non-type template parameter - it must be either integral, enum
 * (which is integral) or a pointer - so we can use it to tag a class to create
 * diffent types.
 *
 * Now, our Logger instance has a template argument which is the loglevel
 * associated with our Logger; anything of lesser priority is ignored; It
 * also honours the symbol MERCURY_LOGLEVEL, and compares it to the lesser of
 * the template argument and the preprocessor define.
 *
 * The operator() function now should be based on the template parameter of the
 * logger class (or MERCURY_LOGLEVEL), and the loglevel of the current message.
 * Because we can't depend on the value but just on the type, we have to do some
 * magic. Now, we want the function to resolve to something that produces output
 * if the level is high enough, or nothing at all if the level is of a too low
 * priority for the current loglevel. For this we utilize std::enable_if<>
 * to select the right function.
 *
 * Because in C++ a templated function which leads to ill-formed code upon
 * instantiation is rejected and does NOT result in a compile error,
 * std::enable_if allows us to make either the version WITH output or
 * WITHOUT output, based on template parameters.
 *
 * As you can see below, the class LL is completely empty; However,
 * there are a few instances; one for every loglevel. Now, remember,
 * when using the logger, Log::DEFAULT resolves to the enum class value
 * while DEFAULT resolves to the instance of class LL with template
 * argument Log::DEFAULT.
 *
 * However, LL<Log::DEFAULT> differs in type from LL<Log::ERROR>, as the
 * template argument is different. Because of deduction, the compiler can
 * figure out the actual values for the template arguments. In case of
 * operator(), the first argument is Log loglevel, which is deduced from
 * the declaration;
 *
 * template<Log LogLevel, typename... Args>
 * void operator(const LL<LogLevel> ll, std::string text, Args... args);
 *
 * Now, the template parameter LogLevel gets filled with Log::ERROR in case
 * we give ERROR as the first argument, or Log::DEBUG with DEBUG as the first
 * argument. Now, we want to resolve to two different functions, so as the
 * return type we use std::enable_if which would lead to ill-formed code
 * in case the predicate of the std::enable_if is false. So, based on the
 * tag ll we now can select the different implementations.
 *
 * It then buffers everything into a stringstream. so as long as operator<<
 * is defined properly for your object,. This then gets redirected towards the
 * correct output channel.
 *
 * Please note that operator() is an inline, templated function. In case the
 * function body is empty, this code is very, very likely to not emit any
 * instructions at all. If you don't give arguments which have only non-const
 * functions, the function call can be considered invariant which means it
 * can completely be taken out, in the case it's a seperate function it just lowers
 * the cost.
 *
 * As said, black magic below.
 * END OF IMPLEMENTATION DETAIL
 */

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)> onFatal;
    std::function<void(std::string, std::string)> onError;
    std::function<void(std::string, std::string)> onWarn;
    std::function<void(std::string, std::string)> onInfo;
    std::function<void(std::string, std::string)> onVerbose;
    std::function<void(std::string, std::string)> onDebug;
};

extern LoggerOutput* loggerOutput;

// Forward declaration..
template<Log L = Log::DEFAULT, bool ASSERTS = MERCURY_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;

public:
    
    Logger(const std::string name)
            : module(name)
    {
    }
     ~Logger() {}

    /*
     *
     * \brief Log implementation of this function
     *
     * Actual implementation of the log function.
     * At compile time evaluates to this implementation,
     * or an empty body implementation, depending on the
     * loglevel parameter of the Logger itself.
     *
     * \arg log Loglevel, either FATAL, ERROR, WARN, INFO, VERBOSE, DEBUG
     * \arg format Message format, where % can be used as a placeholder for arguments.
     * \arg arg... Any arguments which needs to be replaced.
     */
    template<Log LOGLEVEL, typename ... Args>
    typename std::enable_if<!((L < LOGLEVEL) && (MERCURY_LOGLEVEL < LOGLEVEL)), void>::type
    operator()(const LL<LOGLEVEL> log, const char* format, Args&&... arg)
    {   
        std::stringstream msgstream;
        createMessage(msgstream, format, arg...);
        if (LOGLEVEL <= Log::FATAL)
        {   
            loggerOutput->onFatal(module, msgstream.str());
        }
        else if (LOGLEVEL <= Log::ERROR)
        {   
            loggerOutput->onError(module, msgstream.str());
        }
        else if (LOGLEVEL <= Log::WARN)
        {   
            loggerOutput->onWarn(module, msgstream.str());
        }
        else if (LOGLEVEL <= Log::INFO)
        {   
            loggerOutput->onInfo(module, msgstream.str());
        }
        else if (LOGLEVEL <= Log::VERBOSE)
        {   
            loggerOutput->onVerbose(module, msgstream.str());
        }
        else
        {   
            loggerOutput->onDebug(module, msgstream.str());
        }
    }


     template<Log LOGLEVEL, typename... Args>
     typename std::enable_if<L < LOGLEVEL || MERCURY_LOGLEVEL < LOGLEVEL, void>::type
     operator()(const LL<LOGLEVEL> log UNUSED, const std::string& format UNUSED, Args&&... arg UNUSED) {
         
     }
     
     template<Log LOGLEVEL, typename... Args>
     typename std::enable_if<L < LOGLEVEL || MERCURY_LOGLEVEL < LOGLEVEL, void>::type
     operator()(const LL<LOGLEVEL> log UNUSED, const char * format UNUSED, Args&&... arg UNUSED) {
         
     }

/*    template<Log LOGLEVEL, typename... Args>
    typename std::enable_if<L < LOGLEVEL && MERCURY_LOGLEVEL < LOGLEVEL, void>::type
    operator()(const LL<LOGLEVEL> log, const char* format, Args&&... arg)
    {   

    }

    //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, std::string& format, Args&&... arg)
    {
        (*this)(log, format.c_str(), arg...);
    }*/


    /*
     *
     * \brief Asserts on this logger
     *
     * Evaluates an assertion, prints an error message and aborts
     * in case of a failure. This message can be redirected,
     * and will be send to loggerOuptput->onFatal.
     *
     * \arg assertion An assertion, which must be true
     * \arg format Message format, where % can be used as a placeholder for arguments.
     * \arg arg... Any arguments which needs to be replaced.
     */

    
    //the conversion from "" to a std::sting is so slow, it takes 50% of the total run time for a release build...
    template<typename... Args>
    typename std::enable_if<(ASSERTS) && (sizeof...(Args) >= 0), void>::type
    assert(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(bool assertion, const char* format, Args&&... arg)
    {   
    }
    
    template<typename... Args>
    void assert(bool assertion, const std::string format, Args&&... arg)
    {
        assert(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());
        }

    }
    
    template<typename... Args>
    void assert_always(bool assertion, const std::string format, Args&&... arg)
    {
        assert_always(assertion, format.c_str(), arg...);
    }

    template<typename... Args>
    void log(const Log loglevel, const std::string& format, Args&&... arg)
    {   
        if (loglevel <= L || loglevel <= MERCURY_LOGLEVEL)
        {   
            std::stringstream msgstream;
            createMessage(msgstream, format.c_str(), arg...);
            if (loglevel <= Log::FATAL)
            {   
                loggerOutput->onFatal(module, msgstream.str());
            }
            else if (loglevel <= Log::ERROR)
            {   
                loggerOutput->onError(module, msgstream.str());
            }
            else if (loglevel <= Log::WARN)
            {   
                loggerOutput->onWarn(module, msgstream.str());
            }
            else if (loglevel <= Log::INFO)
            {   
                loggerOutput->onInfo(module, msgstream.str());
            }
            else if (loglevel <= Log::VERBOSE)
            {   
                loggerOutput->onVerbose(module, msgstream.str());
            }
            else
            {   
                loggerOutput->onDebug(module, msgstream.str());
            }
        }
    }
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 %sign
                doSkipNext = true;
                fmt++;
            }
            else
            {   
                msg << *fmt;
                fmt++;
                doSkipNext = false;
            }
        }

        fmt++; //Consume the % sign
        msg << arg;
        createMessage(msg, fmt, args...);//and recursively call ourselve / the method below.
    }

    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 %sign and the \sign
                doSkipNext = true;
                fmt++;
            }
            else
            { //invoke the replacement
                msg << *fmt;
                fmt++;
                doSkipNext = false;
            }
        }
        fmt++; //Consume the % sign
        msg << arg << fmt;
    }

    void createMessage(std::stringstream& msg, const char* message)
    {   
        msg << message;
    }
};

extern Logger<MERCURY_LOGLEVEL> logger;

//just emptying the functions is not sufficiently aggressive in disabling the actual (costly) comparison
#if !MERCURY_ASSERTS
#define assert(e,...) assert(true,"")
#endif
        
#endif