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

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 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, 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)

loggerOutput

LoggerOutput * loggerOutput

Declaration of the output functions.

Definition: Logger.cc:283

◆ 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

Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Detailed Description

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

Constructor & Destructor Documentation

◆ Logger()

◆ ~Logger()

Member Function Documentation

◆ createMessage() [1/4]

◆ createMessage() [2/4]

◆ createMessage() [3/4]

◆ createMessage() [4/4]

◆ if() [1/4]

◆ if() [2/4]

◆ if() [3/4]

◆ if() [4/4]

◆ onFatal()

◆ operator()()

Member Data Documentation

◆ doFlush_ [1/2]

◆ doFlush_ [2/2]

◆ else

◆ module

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