Logger wrapper continued

So, we have our logger all figured out, and now we want to use it. We also want to control the inclusion/exclusion of logging code in our build, like this:

#if WANT_LOGGING

    // Logging code

#endif

And, as I said in the previous post, we'd like this to be centralized somewhere, so that we don't have to spread these #ifs all over our code. Since the logging code requires the #include of lib_logger.h, that's a good candidate for this centralization:

#if WANT_LOGGING

#define CREATE_LOGGER(logger_name, config_file) \

    LibLogger::CreateLogger(logger_name, config_file)

#define GET_LOGGER(logger_name) LibLogger LIB_LOGGER(logger_name)

#define LOG_INFORMATION(msg) LIB_LOGGER.Information(msg)

#define LOG_DEBUG(msg) LIB_LOGGER.Debug(msg)

#else

#define CREATE_LOGGER(logger_name, config_file) ((void)0)

#define GET_LOGGER(logger_name) ((void)0)

#define LOG_INFORMATION(msg) ((void)0)

#define LOG_DEBUG(msg) ((void)0)

#endif

So, all we have to do is use CREATE_LOGGER, GET_LOGGER, etc. in our code, and it'll be automatically taken care of with a single #define.

There's a certain comfort in the use of macros, when it comes to code inclusion/exclusion, since the rules are simple. Still, I've always wanted to try some simple template meta-programming (TMP), and this looked like the perfect opportunity.

So, let's change our template class to this:

template <bool condition, typename LoggerImpl>

class LoggerBridge

{

public:

    explicit LoggerBridge(std::string const& loggerName);

    static void CreateLogger(std::string const& loggerName, 

        std::string const& configFile);

    void Critical(std::string const& msg);

    void Debug(std::string const& msg);

    void Error(std::string const& msg);

    void Fatal(std::string const& msg);

    void Information(std::string const& msg);

    void Notice(std::string const& msg);

    void Trace(std::string const& msg);

    void Warning(std::string const& msg);

private:

    LoggerImpl l;

};

We've added a bool argument to our template. Our goal is that when that argument is true, the compiler generates logging code; and when it's false, it doesn't. In order to achieve that, we'll add a specialization.

template <typename LoggerImpl>

class LoggerBridge<false, LoggerImpl>

{

public:

    explicit LoggerBridge(std::string /*const& loggerName*/) {}

    static void CreateLogger(std::string /*const& loggerName*/,  

        std::string const& /*configFile*/) {}

    void Critical(std::string const& /*msg*/) {}

    void Debug(std::string const& /*msg*/) {}

    void Error(std::string const& /*msg*/) {}

    void Fatal(std::string const& /*msg*/) {}

    void Information(std::string const& /*msg*/) {}

    void Notice(std::string const& /*msg*/) {}

    void Trace(std::string const& /*msg*/) {}

    void Warning(std::string const& /*msg*/) {}

};

When the bool parameter is false, our class will contain nothing, and it will do - quite unsurprisingly - nothing.

So, if we change lib_logger.h to this

#include "logger.h"

#include "loggerbridge.h"

typedef Lib::LoggerBridge<false, Lib::Logger> LibLogger;

and rebuild, running the .o files through nm will show no sign of Logger. You'll still find Logger symbols on the .exe because we didn't exclude Logger.h and Logger.cpp from the build, but if you do it (e.g., commenting their lines on the SOURCES and HEADERS variables, in Qt Creator's .pro file), then this: nm Logger.exe | grep -i 3lib6logger will produce no results.

The funny-looking 3lib6logger identifies Lib::Logger symbols, after mangling occurs. E.g.:

00403c70 T __ZN3Lib6Logger12CreateLoggerERKSsS2_

00403a60 T __ZN3Lib6LoggerC1Ev

You can run these symbols through c++filt, to demangle them

>c++filt __ZN3Lib6Logger12CreateLoggerERKSsS2_

Lib::Logger::CreateLogger(std::basic_string<char, std::char_traits<char>, 

    std::allocator<char> > const&, std::basic_string<char, std::char_traits<char>, 

    std::allocator<char> > const&)

>c++filt __ZN3Lib6LoggerC1Ev

Lib::Logger::Logger()

BTW, when running c++filt on valid mangled names (say, a name you got from nm's output or out of the disassembly window in a debugging session), if you're getting no results and if the name has leading underscores, use the -n option.

So, compiling LoggerBridge with false gives us the same result as using macros, and with an amount of TMP small enough not to overwhelm a beginner like me.

Now, we can do something like this in lib_logger.h:

#include "logger.h"

#include "loggerbridge.h"

typedef Lib::LoggerBridge<WANT_LOGGING, Lib::Logger> LibLogger;

According to the value we #define for WANT_LOGGING, 1 (true) or 0 (false), we'll instantiate the general LoggerBridge template (with logging functionality) or our specialization (with no functionality).

We could add further complexity to these rules. If we used a char instead of a bool, we could define specializations based on logging level - logging levels 0 and MAX would be the false and true cases above, and the levels in-between would require further specializations, with some methods having empty bodies and others performing actual logging. E.g. (assuming 1 is Fatal and 8 is Trace):

template <typename LoggerImpl>

class LoggerBridge<4, LoggerImpl>

{

public:

    explicit LoggerBridge(std::string /*const& loggerName*/) {}

    static void CreateLogger(std::string /*const& loggerName*/, 

        std::string const& /*configFile*/) {}

    void Critical(std::string const& msg);

    void Debug(std::string const& /*msg*/) {}

    void Error(std::string const& msg);

    void Fatal(std::string const& msg);

    void Information(std::string const& /*msg*/) {}

    void Notice(std::string const& /*msg*/) {}

    void Trace(std::string const& /*msg*/) {}

    void Warning(std::string const& msg);

private:

    LoggerImpl l;

};

So, we get logging code for Fatal, Critical, Error, and Warning, and all other functions are empty. I don't see much use for this, so I'll stick with the bool version.

You can find the code here.