LogAdapter.hpp

 
//
//  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 <memory>
#include <sstream>
 
// forwards
namespace log4cplus
{
class Logger;
}
 
namespace Arp { namespace System { namespace Commons { namespace Diagnostics { namespace Logging
{
 
// forwards
class Log;
class LogManager;
class LoggerBase;
 
}}}}} // end of namesapce Arp::System::Commons::Diagnostics::Logging
 
 
namespace Arp { namespace System { namespace Commons { namespace Diagnostics { namespace Logging { namespace Internal
{
 
class LogAdapter
{
    friend class Arp::System::Commons::Diagnostics::Logging::Log;
    friend class Arp::System::Commons::Diagnostics::Logging::LogManager;
    friend class Arp::System::Commons::Diagnostics::Logging::LoggerBase;
 
public: // typedefs
    typedef std::shared_ptr<LogAdapter>     Ptr;
    typedef log4cplus::Logger               InternalLogger;
    typedef std::shared_ptr<InternalLogger> InternalLoggerPtr;
 
public: // construction/destruction
    LogAdapter(void);
    LogAdapter(LogAdapter&& arg)noexcept;
    ~LogAdapter(void) = default;
 
public: // operators
    LogAdapter& operator=(LogAdapter&& arg)noexcept;
 
public: // properties
    void                SetLogLevel(LogLevel value);
    LogLevel            GetLogLevel(void);
    const std::string&  GetLoggerName(void);
 
public: // operations
    void    Log(LogLevel messageSeverity, const std::string& message);
 
private: // methods
    LogAdapter(InternalLogger& internalLogger);
    LogAdapter(InternalLogger&& internalLogger);
 
    bool            IsInitialized(void);
    void            Initialize(InternalLogger& internalLogger);
    void            Initialize(InternalLogger&& internalLogger);
    LogStream       GetLogStream(LogLevel logLevel);
 
private: // static methods
    static LogManager* GetLogManager(void);
 
 
private: // deleted methods
    LogAdapter(const LogAdapter& arg) = delete;
    LogAdapter& operator=(const LogAdapter& arg) = delete;
 
private: // fields
    LogLevel            logLevel; // store this here just for performance pupose
    InternalLoggerPtr   internalLoggerPtr;
    std::stringstream   logStreamBuffer;
 
private: // static fields // TODO:SDK: make this non static
};
 
// inline methods of class LogAdapter
inline LogAdapter::LogAdapter()
    : logLevel(LogLevel::Default)
    , internalLoggerPtr()
    , logStreamBuffer()
{
}
 
inline LogAdapter::LogAdapter(LogAdapter&& arg)noexcept
    : logLevel(arg.logLevel)
    , internalLoggerPtr(arg.internalLoggerPtr)
    , logStreamBuffer()
{
}
 
inline LogAdapter& LogAdapter::operator=(LogAdapter&& arg)noexcept
{
    this->logLevel = arg.logLevel;
    this->internalLoggerPtr = arg.internalLoggerPtr;
    //todo use of deleted function ‘std::basic_stringstream<char>& std::basic_stringstream<char>::operator=(const std::basic_stringstream<char>&)’
    //this->logStreamBuffer = std::forward<std::stringstream>(arg.logStreamBuffer);
    return *this;
};
 
inline bool LogAdapter::IsInitialized()
{
    return (this->internalLoggerPtr != nullptr);
}
 
inline LogStream LogAdapter::GetLogStream(LogLevel streamLogLevel)
{
    return LogStream(streamLogLevel, this->logStreamBuffer, this);
}
 
}}}}}} // end of namesapce Arp::System::Commons::Diagnostics::Logging::Internal