Logger.h

Go to the documentation of this file.

#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

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

    
     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)
       {
         doSkipNext = false;
         //Make sure we're not running past the end of our formatting string.
         if (*fmt == '\0')
           return;
           
         if (*fmt == '\\')
         { //Escape for the %sign
           doSkipNext = true;
         }
         else
         {
           msg << *fmt;
           fmt++;
         }
       }

       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)
       {
         doSkipNext = false;
         if (*fmt == '\0') // End of string
           return;
         
         if (*fmt == '\\')
         { //Escape for the %sign
           doSkipNext = true;
         }
         else 
         { //invoke the replacement
           msg << *fmt;
           fmt++;
         }
       }
       fmt++; //Consume the % sign
       msg << arg;
       while (*fmt != '\0')
       { //And print the end of the message!
         msg << *fmt;
         fmt++;
       }
     }
     

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

extern Logger<MERCURY_LOGLEVEL> logger;

#endif