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
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: TODO:SDK: make non static appendEventEnabled
    static std::atomic<size_t>  appendEventCounter;
    static AppendEvent          appendEvent;

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 bool LogManager::HasAppendEvent()
{
    return appendEventCounter > 0;
}

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