LogManager.hpp

//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Core/event.hxx"
#include "Arp/System/Core/TypeName.hxx"
#include "Arp/System/Core/AppDomainSingleton.hxx"
#include "Arp/System/Commons/Threading/Mutex.hpp"
#include "Arp/System/Commons/Diagnostics/Logging/LogLevel.hpp"
#include "Arp/System/Commons/Diagnostics/Logging/LogInfo.hpp"
#include "Arp/System/Commons/Diagnostics/Logging/Internal/LogAdapter.hpp"
#include <new>
#include <atomic>
 
// forwards
namespace log4cplus
{
class Initializer;
class Hierarchy;
class Logger;
}
 
namespace Arp { namespace System { namespace Commons { namespace Diagnostics { namespace Logging
{
 
// forwards
namespace Internal
{
class LogEventAppender;
}
class LoggerBase;
 
// singleton log manager class
//TODO:SDK: Remove from SDK
class LogManager : public AppDomainSingleton<LogManager>
{
    friend class LoggerBase;
    friend class Internal::LogAdapter;
    friend class AppDomainSingleton<LogManager>;
 
private: // typedefs/usings
    using SingletonBase = AppDomainSingleton<LogManager>;
    using Mutex = Arp::System::Commons::Threading::Mutex;
    using LogAdapter = Internal::LogAdapter;
    using LogEventAppenderPtr = std::shared_ptr<Internal::LogEventAppender>;
    using AppendEvent = event<const LogInfo&>;
    using AppendDelegate = delegate<void(const LogInfo&)>;
 
private:
    LogManager(void);
    LogManager(const LogManager&) = delete;
    ~LogManager(void);
    LogManager& operator=(const LogManager&) = delete;
 
public: // singleton operations
    static void AssignAppDomain(AppDomain& otherDomain);
    static void Create(const char* configFileName);
    static void Create(bool enableConsoleLogging, const char* logFileName = nullptr);
    static void Create(LogLevel logLevel, bool enableConsoleLogging, const char* logFileName = nullptr);
    static void Create(const char* layoutPattern, bool enableConsoleLogging, const char* logFileName = nullptr);
    static void Create(LogLevel logLevel, const char* layoutPattern, bool enableConsoleLogging, const char* logFileName = nullptr);
    static void Dispose(void);
 
public: // setter/getter
    void            SetRootLevel(LogLevel value);
    LogLevel        GetRootLevel(void);
    Mutex&          GetSyncRoot(void); // TODO:SDK: make private
 
public: // operations
    LogAdapter      CreateLogAdapter(const char* loggerName); // TODO:SDK: make private
    void            AddAppendDelegate(AppendDelegate appendDelegate);
    void            RemoveAppendDelegate(AppendDelegate appendDelegate);
 
private: // methods
    void                Initialize(LogLevel rootLevel, log4cplus::Logger& rootLogger);
    log4cplus::Logger   GetLoggerInstance(const char* loggerName);
    bool                HasAppendEvent(void);
    void                FireAppendEvent(const LogInfo& logInfo);
 
private: // fields
    Mutex                   syncRoot;
    LogAdapter::Ptr         rootLogAdapterPtr;
    log4cplus::Hierarchy*   pRootHierarchy;
    log4cplus::Initializer* pInitializer;
 
private: // static event fields
    ARP_DEPRECATED("Do not use. Might still be referenced in obsolete inlined code.")
    static std::atomic<size_t>  appendEventCounter; // TODO:SDK: Remove this
 
private: // const static data
    static const char* const defaultLayoutPattern;
};
 
// inline methods of class LogManager
 
inline void LogManager::SetRootLevel(LogLevel value)
{
    this->rootLogAdapterPtr->SetLogLevel(value);
}
 
inline LogLevel LogManager::GetRootLevel()
{
    // OR: do not call LogAdapter::GetLogLevel() - this would cause a cyclic method invocation
    return this->rootLogAdapterPtr->logLevel;
}
 
inline LogManager::Mutex& LogManager::GetSyncRoot()
{
    return this->syncRoot;
}
 
inline void LogManager::Create(bool enableConsoleLogging, const char* logFileName)
{
    Create(LogLevel::Default, nullptr, enableConsoleLogging, logFileName);
}
 
inline void LogManager::Create(LogLevel logLevel, bool enableConsoleLogging, const char* logFileName)
{
    Create(logLevel, nullptr, enableConsoleLogging, logFileName);
}
 
inline void LogManager::Create(const char* layoutPattern, bool enableConsoleLogging, const char* logFileName)
{
    Create(LogLevel::Default, layoutPattern, enableConsoleLogging, logFileName);
}
 
}}}}} // end of namesapce Arp::System::Commons::Diagnostics::Logging