LogManager.hpp

//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#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/Internal/LogAdapter.hpp"
#include <new>

// forwards
namespace Arp
{
class AppDomain;
}
namespace log4cplus
{
class Initializer;
class Hierarchy;
class Logger;
}

namespace Arp { namespace System { namespace Commons { namespace Diagnostics { namespace Logging
{

using namespace Arp::System::Commons::Threading;
using LogAdapter = Internal::LogAdapter;

// singleton log manager class
class LogManager : public AppDomainSingleton<LogManager>
{
    friend class AppDomainSingleton<LogManager>;

private: // typedefs
    typedef AppDomainSingleton<LogManager>  SingletonBase;

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);

public: // operations
    LogAdapter  CreateLogAdapter(const char* loggerName);

private: // methods
    void                Initialize(LogLevel rootLevel, log4cplus::Logger& rootLogger);
    log4cplus::Logger   GetLoggerInstance(const char* loggerName);

private: // fields
    Mutex                   syncRoot;
    LogAdapter::Ptr         rootLogAdapterPtr;
    log4cplus::Hierarchy*   pRootHierarchy;
    log4cplus::Initializer* pInitializer;

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 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