Log.hpp

 
//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Commons/Text/Formatter.hxx"
#include "Arp/System/Commons/Diagnostics/Logging/LogStream.hpp"
#include "Arp/System/Commons/Diagnostics/Logging/Internal/LogAdapter.hpp"
 
namespace Arp { namespace System { namespace Commons { namespace Diagnostics { namespace Logging
{
 
using namespace Arp::System::Commons::Text;
 
// forwards
class LogManager;
 
// static class Log to be used for 'root' logging
class Log
{
    friend class LogManager;
 
public: // static log operations for function/printf call style: Log::Info(format, arg1, arg2, arg3, ...)
    template<typename... Args> static void Trace(const char* format, const Args& ... args);
    template<typename... Args> static void Debug(const char* format, const Args& ... args);
    template<typename... Args> static void Info(const char* format, const Args& ... args);
    template<typename... Args> static void Warning(const char* format, const Args& ... args);
    template<typename... Args> static void Critical(const char* format, const Args& ... args);
    template<typename... Args> static void Error(const char* format, const Args& ... args);
    template<typename... Args> static void Fatal(const char* format, const Args& ... args);
 
    template<typename... Args> static void PrintTrace(const char* format, const Args& ... args);
    template<typename... Args> static void PrintDebug(const char* format, const Args& ... args);
    template<typename... Args> static void PrintInfo(const char* format, const Args& ... args);
    template<typename... Args> static void PrintWarning(const char* format, const Args& ... args);
    template<typename... Args> static void PrintCritical(const char* format, const Args& ... args);
    template<typename... Args> static void PrintError(const char* format, const Args& ... args);
    template<typename... Args> static void PrintFatal(const char* format, const Args& ... args);
 
public: // static log operations for stream call style: Log::Info()<<".."<<arg1<<".."<<arg2<<".."<<arg3;
    static LogStream Trace(void);
    static LogStream Debug(void);
    static LogStream Info(void);
    static LogStream Warning(void);
    static LogStream Critical(void);
    static LogStream Error(void);
    static LogStream Fatal(void);
 
private: // methods
    static void Initialize(LogAdapter::Ptr rootLogAdapter);
    static void Uninitialize(void);
 
private: // fields
    static  LogAdapter::Ptr rootLogAdapterPtr;
};
 
// inline methods of class Log
inline void Log::Initialize(LogAdapter::Ptr rootLogAdapter)
{
    rootLogAdapterPtr = rootLogAdapter;
}
 
inline void Log::Uninitialize()
{
    rootLogAdapterPtr.reset();
}
 
template<typename... Args>
inline void Log::Trace(const char* format, const Args& ... args)
{
    if (rootLogAdapterPtr != nullptr)
    {
        if (rootLogAdapterPtr->GetLogLevel() < LogLevel::Trace)
        {
            return;
        }
        // else
        rootLogAdapterPtr->Log(LogLevel::Trace, Formatter::FormatCommon(format, args...));
    }
}
 
template<typename... Args>
inline void Log::Debug(const char* format, const Args& ... args)
{
    if (rootLogAdapterPtr != nullptr)
    {
        if (rootLogAdapterPtr->GetLogLevel() < LogLevel::Debug)
        {
            return;
        }
        // else
        rootLogAdapterPtr->Log(LogLevel::Debug, Formatter::FormatCommon(format, args...));
    }
}
 
template<typename... Args>
inline void Log::Info(const char* format, const Args& ... args)
{
    if (rootLogAdapterPtr != nullptr)
    {
        if (rootLogAdapterPtr->GetLogLevel() < LogLevel::Info)
        {
            return;
        }
        // else
        rootLogAdapterPtr->Log(LogLevel::Info, Formatter::FormatCommon(format, args...));
    }
}
 
template<typename... Args>
inline void Log::Warning(const char* format, const Args& ... args)
{
    if (rootLogAdapterPtr != nullptr)
    {
        if (rootLogAdapterPtr->GetLogLevel() < LogLevel::Warning)
        {
            return;
        }
        // else
        rootLogAdapterPtr->Log(LogLevel::Warning, Formatter::FormatCommon(format, args...));
    }
}
 
template<typename... Args>
inline void Log::Critical(const char* format, const Args& ... args)
{
    if (rootLogAdapterPtr != nullptr)
    {
        if (rootLogAdapterPtr->GetLogLevel() < LogLevel::Critical)
        {
            return;
        }
        // else
        rootLogAdapterPtr->Log(LogLevel::Critical, Formatter::FormatCommon(format, args...));
    }
}
 
template<typename... Args>
inline void Log::Error(const char* format, const Args& ... args)
{
    if (rootLogAdapterPtr != nullptr)
    {
        if (rootLogAdapterPtr->GetLogLevel() < LogLevel::Error)
        {
            return;
        }
        // else
        rootLogAdapterPtr->Log(LogLevel::Error, Formatter::FormatCommon(format, args...));
    }
}
 
template<typename... Args>
inline void Log::Fatal(const char* format, const Args& ... args)
{
    if (rootLogAdapterPtr != nullptr)
    {
        if (rootLogAdapterPtr->GetLogLevel() < LogLevel::Fatal)
        {
            return;
        }
        // else
        rootLogAdapterPtr->Log(LogLevel::Fatal, Formatter::FormatCommon(format, args...));
    }
}
 
template<typename... Args>
inline void Log::PrintTrace(const char* format, const Args& ... args)
{
    if (rootLogAdapterPtr != nullptr)
    {
        if (rootLogAdapterPtr->GetLogLevel() < LogLevel::Trace)
        {
            return;
        }
        // else
        rootLogAdapterPtr->Log(LogLevel::Trace, Formatter::FormatPrintf(format, args...));
    }
}
 
template<typename... Args>
inline void Log::PrintDebug(const char* format, const Args& ... args)
{
    if (rootLogAdapterPtr != nullptr)
    {
        if (rootLogAdapterPtr->GetLogLevel() < LogLevel::Debug)
        {
            return;
        }
        // else
        rootLogAdapterPtr->Log(LogLevel::Debug, Formatter::FormatPrintf(format, args...));
    }
}
 
template<typename... Args>
inline void Log::PrintInfo(const char* format, const Args& ... args)
{
    if (rootLogAdapterPtr != nullptr)
    {
        if (rootLogAdapterPtr->GetLogLevel() < LogLevel::Info)
        {
            return;
        }
        // else
        rootLogAdapterPtr->Log(LogLevel::Info, Formatter::FormatPrintf(format, args...));
    }
}
 
template<typename... Args>
inline void Log::PrintWarning(const char* format, const Args& ... args)
{
    if (rootLogAdapterPtr != nullptr)
    {
        if (rootLogAdapterPtr->GetLogLevel() < LogLevel::Warning)
        {
            return;
        }
        // else
        rootLogAdapterPtr->Log(LogLevel::Warning, Formatter::FormatPrintf(format, args...));
    }
}
 
template<typename... Args>
inline void Log::PrintCritical(const char* format, const Args& ... args)
{
    if (rootLogAdapterPtr != nullptr)
    {
        if (rootLogAdapterPtr->GetLogLevel() < LogLevel::Critical)
        {
            return;
        }
        // else
        rootLogAdapterPtr->Log(LogLevel::Critical, Formatter::FormatPrintf(format, args...));
    }
}
 
template<typename... Args>
inline void Log::PrintError(const char* format, const Args& ... args)
{
    if (rootLogAdapterPtr != nullptr)
    {
        if (rootLogAdapterPtr->GetLogLevel() < LogLevel::Error)
        {
            return;
        }
        // else
        rootLogAdapterPtr->Log(LogLevel::Error, Formatter::FormatPrintf(format, args...));
    }
}
 
template<typename... Args>
inline void Log::PrintFatal(const char* format, const Args& ... args)
{
    if (rootLogAdapterPtr != nullptr)
    {
        if (rootLogAdapterPtr->GetLogLevel() < LogLevel::Fatal)
        {
            return;
        }
        // else
        rootLogAdapterPtr->Log(LogLevel::Fatal, Formatter::FormatPrintf(format, args...));
    }
}
 
inline LogStream Log::Trace()
{
    if (rootLogAdapterPtr != nullptr)
    {
        return (rootLogAdapterPtr->GetLogLevel() < LogLevel::Trace) ? LogStream::Null : rootLogAdapterPtr->GetLogStream(LogLevel::Trace);
    }
    else
    {
        return LogStream::Null;
    }
}
 
inline LogStream Log::Debug()
{
    if (rootLogAdapterPtr != nullptr)
    {
        return (rootLogAdapterPtr->GetLogLevel() < LogLevel::Debug) ? LogStream::Null : rootLogAdapterPtr->GetLogStream(LogLevel::Debug);
    }
    else
    {
        return LogStream::Null;
    }
}
 
inline LogStream Log::Info()
{
    if (rootLogAdapterPtr != nullptr)
    {
        return (rootLogAdapterPtr->GetLogLevel() < LogLevel::Info) ? LogStream::Null : rootLogAdapterPtr->GetLogStream(LogLevel::Info);
    }
    else
    {
        return LogStream::Null;
    }
}
 
inline LogStream Log::Warning()
{
    if (rootLogAdapterPtr != nullptr)
    {
        return (rootLogAdapterPtr->GetLogLevel() < LogLevel::Warning) ? LogStream::Null : rootLogAdapterPtr->GetLogStream(LogLevel::Warning);
    }
    else
    {
        return LogStream::Null;
    }
}
 
inline LogStream Log::Critical()
{
    if (rootLogAdapterPtr != nullptr)
    {
        return (rootLogAdapterPtr->GetLogLevel() < LogLevel::Critical) ? LogStream::Null : rootLogAdapterPtr->GetLogStream(LogLevel::Critical);
    }
    else
    {
        return LogStream::Null;
    }
}
 
inline LogStream Log::Error()
{
    if (rootLogAdapterPtr != nullptr)
    {
        return (rootLogAdapterPtr->GetLogLevel() < LogLevel::Error) ? LogStream::Null : rootLogAdapterPtr->GetLogStream(LogLevel::Error);
    }
    else
    {
        return LogStream::Null;
    }
}
 
inline LogStream Log::Fatal()
{
    if (rootLogAdapterPtr != nullptr)
    {
        return (rootLogAdapterPtr->GetLogLevel() < LogLevel::Fatal) ? LogStream::Null : rootLogAdapterPtr->GetLogStream(LogLevel::Fatal);
    }
    else
    {
        return LogStream::Null;
    }
}
 
}}}}} // end of namesapce Arp::System::Commons::Diagnostics::Logging