LoggerBase.hxx

 
//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Commons/Diagnostics/Logging/LogLevel.hpp"
#include "Arp/System/Commons/Diagnostics/Logging/LogStream.hpp"
#include "Arp/System/Commons/Diagnostics/Logging/LogManager.hpp"
#include "Arp/System/Commons/Diagnostics/Logging/Internal/LogAdapter.hpp"
#include "Arp/System/Commons/Text/Formatter.hxx"
#include "Arp/System/Commons/Threading/LockGuard.hpp"
 
#include <atomic>
 
namespace Arp { namespace System { namespace Commons { namespace Diagnostics { namespace Logging
{
 
using namespace Arp::System::Commons::Text;
 
//forwards
template<typename T, bool, bool> class Loggable;
 
class LoggerBase
{
    template<typename T, bool, bool> friend class Loggable;
 
public: // usings
    using LockGuard = Arp::System::Commons::Threading::LockGuard;
 
protected: // construction/destruction
    LoggerBase(void);
    LoggerBase(const String& loggerName);
    LoggerBase(const char* pLoggerName);
    LoggerBase(const LoggerBase& arg) = default;
    ~LoggerBase(void) = default;
 
public: // log operations for function call style: Log::Info(format, arg1, arg2, arg3, ...)
    template<typename... Args> void Trace(const char* format, const Args& ... args);
    template<typename... Args> void Debug(const char* format, const Args& ... args);
    template<typename... Args> void Info(const char* format, const Args& ... args);
    template<typename... Args> void Warning(const char* format, const Args& ... args);
    template<typename... Args> void Critical(const char* format, const Args& ... args);
    template<typename... Args> void Error(const char* format, const Args& ... args);
    template<typename... Args> void Fatal(const char* format, const Args& ... args);
 
    template<typename... Args> void PrintTrace(const char* format, const Args& ... args);
    template<typename... Args> void PrintDebug(const char* format, const Args& ... args);
    template<typename... Args> void PrintInfo(const char* format, const Args& ... args);
    template<typename... Args> void PrintWarning(const char* format, const Args& ... args);
    template<typename... Args> void PrintCritical(const char* format, const Args& ... args);
    template<typename... Args> void PrintError(const char* format, const Args& ... args);
    template<typename... Args> void PrintFatal(const char* format, const Args& ... args);
 
public: // log operations for stream call style: Log::Info()<<".."<<arg1<<".."<<arg2<<".."<<arg3;
    LogStream   Trace(void);
    LogStream   Debug(void);
    LogStream   Info(void);
    LogStream   Warning(void);
    LogStream   Critical(void);
    LogStream   Error(void);
    LogStream   Fatal(void);
 
public: // generic log operations
    template<typename... Args>
    void Log(LogLevel logLevel, const char* format, const Args& ... args);
 
public: // setter/getter
    LogLevel    GetLogLevel(void);
 
protected: // methods
    void        Initialize(const String& loggerName);
    LogStream   GetLogStream(LogLevel logLevel);
    template<typename... Args>
    void LogCommonFormat(LogLevel logLevel, const char* format, const Args& ... args);
 
private: // fields
    LogAdapter        logAdapter;
    std::atomic<bool> initialized;
};
 
// inline methods of class LoggerBase
inline LoggerBase::LoggerBase()
    : logAdapter()
{
    this->initialized = false;
}
 
inline LoggerBase::LoggerBase(const String& loggerName)
    : LoggerBase(loggerName.CStr())
{
    //initialized is initialized to true in LoggerBase::LoggerBase(const char* pLoggerName)
}
 
inline LoggerBase::LoggerBase(const char* pLoggerName)
    : logAdapter(LogManager::GetInstance().CreateLogAdapter(pLoggerName))
{
    this->initialized = true;
}
 
inline void LoggerBase::Initialize(const String& loggerName)
{
    // implement this using "double checked locking" pattern
    if (!this->initialized)
    {
        LockGuard syncGuard(LogManager::GetInstance().GetSyncRoot());
        if (!this->initialized)
        {
            this->logAdapter = LogManager::GetInstance().CreateLogAdapter(loggerName);
            this->initialized = true;
        }
    }
}
 
inline LogLevel LoggerBase::GetLogLevel()
{
    return this->logAdapter.GetLogLevel();
}
 
inline LogStream LoggerBase::GetLogStream(LogLevel logLevel)
{
    return this->logAdapter.GetLogStream(logLevel);
}
 
template<typename... Args>
inline void LoggerBase::Log(LogLevel logLevel, const char* format, const Args& ...args)
{
    LogCommonFormat(logLevel, format, args...);
}
 
template<typename... Args>
inline void LoggerBase::LogCommonFormat(LogLevel logLevel, const char* format, const Args& ...args)
{
    if(this->GetLogLevel() < logLevel)
    {
        return;
    }
 
    String message;
    try
    {
        message = Formatter::FormatCommon(format, args...);
    }
    catch(const Arp::Exception& ex)
    {
        this->logAdapter.Log(LogLevel::Error, String("Exception occurs during format of log message: ") + ex.GetMessage());
        message = format;
    }
    catch(const std::exception& ex)
    {
        this->logAdapter.Log(LogLevel::Error, String("Exception occurs during format of log message: ") + ex.what());
        message = format;
    }
    catch(...)
    {
        this->logAdapter.Log(LogLevel::Error, "Exception occurs during format of log message: Unknown exception");
        message = format;
    }
    // else
    this->logAdapter.Log(logLevel, message);
}
 
inline LogStream LoggerBase::Trace()
{
    return (this->GetLogLevel() < LogLevel::Trace) ? LogStream::Null : this->GetLogStream(LogLevel::Trace);
}
 
inline LogStream LoggerBase::Debug()
{
    return (this->GetLogLevel() < LogLevel::Debug) ? LogStream::Null : this->GetLogStream(LogLevel::Debug);
}
 
inline LogStream LoggerBase::Info()
{
    return (this->GetLogLevel() < LogLevel::Info) ? LogStream::Null : this->GetLogStream(LogLevel::Info);
}
 
inline LogStream LoggerBase::Warning()
{
    return (this->GetLogLevel() < LogLevel::Warning) ? LogStream::Null : this->GetLogStream(LogLevel::Warning);
}
 
inline LogStream LoggerBase::Critical()
{
    return (this->GetLogLevel() < LogLevel::Critical) ? LogStream::Null : this->GetLogStream(LogLevel::Critical);
}
 
inline LogStream LoggerBase::Error()
{
    return (this->GetLogLevel() < LogLevel::Error) ? LogStream::Null : this->GetLogStream(LogLevel::Error);
}
 
inline LogStream LoggerBase::Fatal()
{
    return (this->GetLogLevel() < LogLevel::Fatal) ? LogStream::Null : this->GetLogStream(LogLevel::Fatal);
}
 
template<typename... Args>
inline void LoggerBase::Trace(const char* format, const Args& ... args)
{
    this->LogCommonFormat(LogLevel::Trace, format, args...);
}
 
template<typename... Args>
inline void LoggerBase::Debug(const char* format, const Args& ... args)
{
    this->LogCommonFormat(LogLevel::Debug, format, args...);
}
 
template<typename... Args>
inline void LoggerBase::Info(const char* format, const Args& ... args)
{
    this->LogCommonFormat(LogLevel::Info, format, args...);
}
 
template<typename... Args>
inline void LoggerBase::Warning(const char* format, const Args& ... args)
{
    this->LogCommonFormat(LogLevel::Warning, format, args...);
}
 
template<typename... Args>
inline void LoggerBase::Critical(const char* format, const Args& ... args)
{
    this->LogCommonFormat(LogLevel::Critical, format, args...);
}
 
template<typename... Args>
inline void LoggerBase::Error(const char* format, const Args& ... args)
{
    this->LogCommonFormat(LogLevel::Error, format, args...);
}
 
template<typename... Args>
inline void LoggerBase::Fatal(const char* format, const Args& ... args)
{
    if (this->GetLogLevel() < LogLevel::Fatal)
    {
        return;
    }
    // else
    this->LogCommonFormat(LogLevel::Fatal, format, args...);
}
 
template<typename... Args>
inline void LoggerBase::PrintTrace(const char* format, const Args& ... args)
{
    if (this->GetLogLevel() < LogLevel::Trace)
    {
        return;
    }
    // else
    this->logAdapter.Log(LogLevel::Trace, Formatter::FormatPrintf(format, args...));
}
 
template<typename... Args>
inline void LoggerBase::PrintDebug(const char* format, const Args& ... args)
{
    if (this->GetLogLevel() < LogLevel::Debug)
    {
        return;
    }
    // else
    this->logAdapter.Log(LogLevel::Debug, Formatter::FormatPrintf(format, args...));
}
 
template<typename... Args>
inline void LoggerBase::PrintInfo(const char* format, const Args& ... args)
{
    if (this->GetLogLevel() < LogLevel::Info)
    {
        return;
    }
    // else
    this->logAdapter.Log(LogLevel::Info, Formatter::FormatPrintf(format, args...));
}
 
template<typename... Args>
inline void LoggerBase::PrintWarning(const char* format, const Args& ... args)
{
    if (this->GetLogLevel() < LogLevel::Warning)
    {
        return;
    }
    // else
    this->logAdapter.Log(LogLevel::Warning, Formatter::FormatPrintf(format, args...));
}
 
template<typename... Args>
inline void LoggerBase::PrintCritical(const char* format, const Args& ... args)
{
    if (this->GetLogLevel() < LogLevel::Critical)
    {
        return;
    }
    // else
    this->logAdapter.Log(LogLevel::Critical, Formatter::FormatPrintf(format, args...));
}
 
template<typename... Args>
inline void LoggerBase::PrintError(const char* format, const Args& ... args)
{
    if (this->GetLogLevel() < LogLevel::Error)
    {
        return;
    }
    // else
    this->logAdapter.Log(LogLevel::Error, Formatter::FormatPrintf(format, args...));
}
 
template<typename... Args>
inline void LoggerBase::PrintFatal(const char* format, const Args& ... args)
{
    if (this->GetLogLevel() < LogLevel::Fatal)
    {
        return;
    }
    // else
    this->logAdapter.Log(LogLevel::Fatal, Formatter::FormatPrintf(format, args...));
}
 
}}}}} // end of namesapce Arp::System::Commons::Diagnostics::Logging