Logger< L, ASSERTS > Class Template Reference

the Logger class is the main class of the logger implementation. It holds all the functions which invoke certain methods to create messages based on input parameter deductions. More...

#include <Logger.h>

Public Member Functions
	Logger (const std::string name)
	constructor More...
	~Logger ()=default
	destructor More...
template<Log LOGLEVEL, typename ... Args>
std::enable_if<!((L< LOGLEVEL) &&(MERCURYDPM_LOGLEVEL< LOGLEVEL)), void >::type	operator() (const LL< LOGLEVEL > log, const char *format UNUSED, Args &&... arg UNUSED)
	Log implementation of this function. More...
template<Log LOGLEVEL, typename... Args>
std::enable_if< L< LOGLEVEL &&MERCURYDPM_LOGLEVEL< LOGLEVEL, void >::type operator()(const LL< LOGLEVEL > log, const char *format UNUSED, Args &&... arg UNUSED) { } 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) { } 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_)
	Empty body function utilized to suppress logger messages above a certain user defined loglevel L. More...
else	if (loglevel<=Log::ERROR)
else	if (loglevel<=Log::WARN)
else	if (loglevel<=Log::INFO)
else	if (loglevel<=Log::VERBOSE)

Public Attributes
	else
	doFlush_ = Flusher::FLUSH

Private Member Functions
template<typename Arg1 , typename... Args>
void	createMessage (std::stringstream &msg, const char *fmt, Arg1 &&arg, Args &&... args)
	Edits the message to a certain format and writes it to a stringstream by recursively replacing all % characters with the arguments values. More...
template<typename... Args>
void	createMessage (std::stringstream &msg, const char *fmt, Flusher arg, Args &&... args)
	Overloaded version of createMessage to catch arguments of Flusher and suppress input flushing via std::endl. If there is an argument which should be catched from the logger, overloading the function is the way to go. More...
template<typename Arg1 >
void	createMessage (std::stringstream &msg, const char *fmt, Arg1 &&arg)
	Terminating case / Argument call. Overloaded function for a logger message with only one argument or where only one argument is left. More...
void	createMessage (std::stringstream &msg, const char *message)
	Terminating case / no argument call Overloaded function for a logger message without arguments. More...

Private Attributes
const std::string	module
	The module name of this actual logger. More...
Flusher	doFlush_ = Flusher::FLUSH
	Can prevent the logger from flushing the buffer via std::endl. doFlush_ is set automatically based on build and loglevel settings. More...

Detailed Description

template<Log L, bool ASSERTS>
class Logger< L, ASSERTS >

the Logger class is the main class of the logger implementation. It holds all the functions which invoke certain methods to create messages based on input parameter deductions.

Template Parameters

L	The log level defined in cMake configuration. Messages of higher level than L are ignored.

Usage: logger(FATAL, "Error in (here) because % < %!\n", var1, var2) OUTPUT: Error in (here) because 2 < 1!

Define custom loggers by: ifndef HG_LOGLEVEL_CUSTOMMOD define HG_LOGLEVEL_CUSTOMMOD Log::Debug endif Logger<HG_LOGLEVEL_CUSTOMMOD> customLogger;

Constructor & Destructor Documentation

Logger()

template<Log L, bool ASSERTS>

Logger< L, ASSERTS >::Logger ( const std::string  name )

inlineexplicit

constructor

Parameters

[in]

name

The name in this module used in output messages.

            : module(name)
    {
    }

~Logger()

template<Log L, bool ASSERTS>

Logger< L, ASSERTS >::~Logger ( )

default

destructor

Member Function Documentation

createMessage() [1/4]

template<Log L, bool ASSERTS>

template<typename Arg1 >

void Logger< L, ASSERTS >::createMessage ( std::stringstream &  msg, const char *  fmt, Arg1 &&  arg  )

inlineprivate

Terminating case / Argument call. Overloaded function for a logger message with only one argument or where only one argument is left.

Parameters

[in]	msg	stringstream which represents the output message.
[in]	fmt	char array of the yet unformatted message.
[in]	arg	argument to replace the next % character.

    {
        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;
        }
    }

createMessage() [2/4]

template<Log L, bool ASSERTS>

template<typename Arg1 , typename... Args>

void Logger< L, ASSERTS >::createMessage ( std::stringstream &  msg, const char *  fmt, Arg1 &&  arg, Args &&...  args  )

inlineprivate

Edits the message to a certain format and writes it to a stringstream by recursively replacing all % characters with the arguments values.

The creation of messages is divided into three different overloaded functions. the function createMessage is recursively called and each of the functions below is called for a certain case dependent on the amount and type of parameters.

Parameters

[in]	msg	stringstream which represents the output message.
[in]	fmt	char array of the yet unformatted message.
[in]	arg	argument to replace the next % character.
[in]	args	parameter pack of the remaining arguments.

    {
        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.
    }

References compute_granudrum_aor::args.

Referenced by Logger< L, ASSERTS >::createMessage(), and Logger< L, ASSERTS >::operator()().

createMessage() [3/4]

template<Log L, bool ASSERTS>

template<typename... Args>

void Logger< L, ASSERTS >::createMessage ( std::stringstream &  msg, const char *  fmt, Flusher  arg, Args &&...  args  )

inlineprivate

Overloaded version of createMessage to catch arguments of Flusher and suppress input flushing via std::endl. If there is an argument which should be catched from the logger, overloading the function is the way to go.

Parameters

[in]	msg	stringstream which represents the output message.
[in]	fmt	char array of the yet unformatted message.
[in]	arg	argument of type Flusher which will be skipped and does not replace the next % character.
[in]	args	parameter pack of the remaining parameters.

    {
        // 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...);
    }

References compute_granudrum_aor::args, Logger< L, ASSERTS >::createMessage(), Logger< L, ASSERTS >::doFlush_, FLUSH, MERCURYDPM_LOGLEVEL, NO_FLUSH, and VERBOSE.

createMessage() [4/4]

template<Log L, bool ASSERTS>

void Logger< L, ASSERTS >::createMessage ( std::stringstream &  msg, const char *  message  )

inlineprivate

Terminating case / no argument call Overloaded function for a logger message without arguments.

Parameters

[in]	msg	stringstream which represents the output message.
[in]	message	char array of the message.

    {
        msg << message;
    }

if() [1/4]

template<Log L, bool ASSERTS>

else Logger< L, ASSERTS >::if ( loglevel<=Log::ERROR  )

inline

            {
                loggerOutput->onError(module, msgstream.str(), doFlush_);
            }

References Logger< L, ASSERTS >::doFlush_, loggerOutput, Logger< L, ASSERTS >::module, and LoggerOutput::onError.

if() [2/4]

template<Log L, bool ASSERTS>

else Logger< L, ASSERTS >::if ( loglevel<=Log::INFO  )

inline

            {
                loggerOutput->onInfo(module, msgstream.str(), doFlush_);
                doFlush_ = Flusher::FLUSH;
            }

References Logger< L, ASSERTS >::doFlush_, FLUSH, loggerOutput, Logger< L, ASSERTS >::module, and LoggerOutput::onInfo.

if() [3/4]

template<Log L, bool ASSERTS>

else Logger< L, ASSERTS >::if ( loglevel<=Log::VERBOSE  )

inline

            {
                loggerOutput->onVerbose(module, msgstream.str(), doFlush_);
                doFlush_ = Flusher::FLUSH;
            }

References Logger< L, ASSERTS >::doFlush_, FLUSH, loggerOutput, Logger< L, ASSERTS >::module, and LoggerOutput::onVerbose.

if() [4/4]

template<Log L, bool ASSERTS>

else Logger< L, ASSERTS >::if ( loglevel<=Log::WARN  )

inline

            {
                loggerOutput->onWarn(module, msgstream.str(), doFlush_);
                doFlush_ = Flusher::FLUSH;
            }

References Logger< L, ASSERTS >::doFlush_, FLUSH, loggerOutput, Logger< L, ASSERTS >::module, and LoggerOutput::onWarn.

onFatal()

template<Log L, bool ASSERTS>

template<Log LOGLEVEL, typename... Args>

std::enable_if<L < LOGLEVEL && MERCURYDPM_LOGLEVEL < LOGLEVEL, void>::type operator()(const LL<LOGLEVEL> log, const char* format UNUSED, Args&& ... arg UNUSED) { } 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) { } 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-> Logger< L, ASSERTS >::onFatal	(	module	,
		msgstream.	str(),
		doFlush_
	)

Empty body function utilized to suppress logger messages above a certain user defined loglevel L.

operator()()

template<Log L, bool ASSERTS>

template<Log LOGLEVEL, typename ... Args>

std::enable_if<!((L < LOGLEVEL) && (MERCURYDPM_LOGLEVEL < LOGLEVEL)), void>::type Logger< L, ASSERTS >::operator() ( const LL< LOGLEVEL >  log, const char *format  UNUSED, Args &&... arg  UNUSED  )

inline

Log implementation of this function.

Actual implementation of the log function. If the user defined loglevel L is lower than the called LOGLEVEL it will evaluate to an empty body function below. If L is greater than the called LOGLEVEL it will invoke this function.

Parameters

[in]	log	Loglevel, either FATAL, ERROR, WARN, INFO, VERBOSE, DEBUG
[in]	format	Message format, where % can be used as a placeholder for arguments.
[in]	arg	Any arguments which replace all the % characters.

    {
        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;
        }
    }

References Logger< L, ASSERTS >::createMessage(), Logger< L, ASSERTS >::doFlush_, ERROR, FATAL, FLUSH, format(), INFO, loggerOutput, Logger< L, ASSERTS >::module, LoggerOutput::onDebug, LoggerOutput::onError, LoggerOutput::onFatal, LoggerOutput::onInfo, LoggerOutput::onVerbose, LoggerOutput::onWarn, VERBOSE, and WARN.

Member Data Documentation

doFlush_ [1/2]

template<Log L, bool ASSERTS>

Flusher Logger< L, ASSERTS >::doFlush_ = Flusher::FLUSH

private

Can prevent the logger from flushing the buffer via std::endl. doFlush_ is set automatically based on build and loglevel settings.

Referenced by Logger< L, ASSERTS >::createMessage(), Logger< L, ASSERTS >::if(), and Logger< L, ASSERTS >::operator()().

doFlush_ [2/2]

template<Log L, bool ASSERTS>

Logger< L, ASSERTS >::doFlush_ = Flusher::FLUSH

else

template<Log L, bool ASSERTS>

Logger< L, ASSERTS >::else

Initial value:

{
                loggerOutput->onDebug(module, msgstream.str(), doFlush_ = Flusher::FLUSH)

module

template<Log L, bool ASSERTS>

const std::string Logger< L, ASSERTS >::module

private

The module name of this actual logger.

Referenced by Logger< L, ASSERTS >::if(), and Logger< L, ASSERTS >::operator()().

---

The documentation for this class was generated from the following file:

• Logger.h