Log.h

#pragma once
 
#include <Foundation/Communication/Event.h>
#include <Foundation/Strings/FormatString.h>
#include <Foundation/Strings/StringBuilder.h>
#include <Foundation/Strings/StringUtils.h>
#include <Foundation/Threading/AtomicInteger.h>
#include <Foundation/Time/Time.h>
 
#define PL_LOG_BLOCK plLogBlock PL_PP_CONCAT(_logblock_, PL_SOURCE_LINE)
 
#define PL_LOG_BLOCK_MUTE()                               \
  plMuteLog PL_PP_CONCAT(_logmuteblock_, PL_SOURCE_LINE); \
  plLogSystemScope PL_PP_CONCAT(_logscope_, PL_SOURCE_LINE)(&PL_PP_CONCAT(_logmuteblock_, PL_SOURCE_LINE))
 
// Forward declaration, class is at the end of this file
class plLogBlock;
 
 
struct PL_FOUNDATION_DLL plLogMsgType
{
  using StorageType = plInt8;
 
  enum Enum : plInt8
  {
    GlobalDefault = -4,    
    Flush = -3,            
    BeginGroup = -2,       
    EndGroup = -1,         
    None = 0,              
    ErrorMsg = 1,          
    SeriousWarningMsg = 2, 
    WarningMsg = 3,        
    SuccessMsg = 4,        
    InfoMsg = 5,           
    DevMsg = 6,            
    DebugMsg = 7,          
    All = 8,               
    ENUM_COUNT,
    Default = None,
  };
};
 
struct PL_FOUNDATION_DLL plLoggingEventData
{
  plLogMsgType::Enum m_EventType = plLogMsgType::None;
 
  plUInt8 m_uiIndentation = 0;
 
  plStringView m_sText;
 
  plStringView m_sTag;
 
#if PL_ENABLED(PL_COMPILE_FOR_DEVELOPMENT)
  double m_fSeconds = 0;
#endif
};
 
using plLoggingEvent = plEvent<const plLoggingEventData&, plMutex>;
 
class PL_FOUNDATION_DLL plLogInterface
{
public:
  virtual void HandleLogMessage(const plLoggingEventData& le) = 0;
 
  PL_ALWAYS_INLINE void SetLogLevel(plLogMsgType::Enum logLevel) { m_LogLevel = logLevel; }
 
  PL_ALWAYS_INLINE plLogMsgType::Enum GetLogLevel() { return m_LogLevel; }
 
private:
  friend class plLog;
  friend class plLogBlock;
  plLogBlock* m_pCurrentBlock = nullptr;
  plLogMsgType::Enum m_LogLevel = plLogMsgType::GlobalDefault;
  plUInt32 m_uiLoggedMsgsSinceFlush = 0;
  plTime m_LastFlushTime;
};
 
 
class plMuteLog : public plLogInterface
{
public:
  plMuteLog()
  {
    SetLogLevel(plLogMsgType::None);
  }
 
  virtual void HandleLogMessage(const plLoggingEventData&) override {}
};
 
 
class PL_FOUNDATION_DLL plGlobalLog : public plLogInterface
{
public:
  virtual void HandleLogMessage(const plLoggingEventData& le) override;
 
  static plEventSubscriptionID AddLogWriter(plLoggingEvent::Handler handler);
 
  static void RemoveLogWriter(plLoggingEvent::Handler handler);
 
  static void RemoveLogWriter(plEventSubscriptionID& ref_subscriptionID);
 
  static plUInt32 GetMessageCount(plLogMsgType::Enum messageType) { return s_uiMessageCount[messageType]; }
 
  static void SetGlobalLogOverride(plLogInterface* pInterface);
 
private:
  static plAtomicInteger32 s_uiMessageCount[plLogMsgType::ENUM_COUNT];
 
  static plLoggingEvent s_LoggingEvent;
 
  static plLogInterface* s_pOverrideLog;
 
private:
  PL_DISALLOW_COPY_AND_ASSIGN(plGlobalLog);
 
  friend class plLog; // only plLog may create instances of this class
  plGlobalLog() = default;
};
 
class PL_FOUNDATION_DLL plLog
{
public:
  static void SetThreadLocalLogSystem(plLogInterface* pInterface);
 
  static plLogInterface* GetThreadLocalLogSystem();
 
  static void SetDefaultLogLevel(plLogMsgType::Enum logLevel);
 
  static plLogMsgType::Enum GetDefaultLogLevel();
 
  static void Error(plLogInterface* pInterface, const plFormatString& string);
 
  template <typename... ARGS>
  static void Error(plStringView sFormat, ARGS&&... args)
  {
    Error(GetThreadLocalLogSystem(), plFormatStringImpl<ARGS...>(sFormat, std::forward<ARGS>(args)...));
  }
 
  template <typename... ARGS>
  static void Error(plLogInterface* pInterface, plStringView sFormat, ARGS&&... args)
  {
    Error(pInterface, plFormatStringImpl<ARGS...>(sFormat, std::forward<ARGS>(args)...));
  }
 
  static void SeriousWarning(plLogInterface* pInterface, const plFormatString& string);
 
  template <typename... ARGS>
  static void SeriousWarning(plStringView sFormat, ARGS&&... args)
  {
    SeriousWarning(GetThreadLocalLogSystem(), plFormatStringImpl<ARGS...>(sFormat, std::forward<ARGS>(args)...));
  }
 
  template <typename... ARGS>
  static void SeriousWarning(plLogInterface* pInterface, plStringView sFormat, ARGS&&... args)
  {
    SeriousWarning(pInterface, plFormatStringImpl<ARGS...>(sFormat, std::forward<ARGS>(args)...));
  }
 
  static void Warning(plLogInterface* pInterface, const plFormatString& string);
 
  template <typename... ARGS>
  static void Warning(plStringView sFormat, ARGS&&... args)
  {
    Warning(GetThreadLocalLogSystem(), plFormatStringImpl<ARGS...>(sFormat, std::forward<ARGS>(args)...));
  }
 
  template <typename... ARGS>
  static void Warning(plLogInterface* pInterface, plStringView sFormat, ARGS&&... args)
  {
    Warning(pInterface, plFormatStringImpl<ARGS...>(sFormat, std::forward<ARGS>(args)...));
  }
 
  static void Success(plLogInterface* pInterface, const plFormatString& string);
 
  template <typename... ARGS>
  static void Success(plStringView sFormat, ARGS&&... args)
  {
    Success(GetThreadLocalLogSystem(), plFormatStringImpl<ARGS...>(sFormat, std::forward<ARGS>(args)...));
  }
 
  template <typename... ARGS>
  static void Success(plLogInterface* pInterface, plStringView sFormat, ARGS&&... args)
  {
    Success(pInterface, plFormatStringImpl<ARGS...>(sFormat, std::forward<ARGS>(args)...));
  }
 
  static void Info(plLogInterface* pInterface, const plFormatString& string);
 
  template <typename... ARGS>
  static void Info(plStringView sFormat, ARGS&&... args)
  {
    Info(GetThreadLocalLogSystem(), plFormatStringImpl<ARGS...>(sFormat, std::forward<ARGS>(args)...));
  }
 
  template <typename... ARGS>
  static void Info(plLogInterface* pInterface, plStringView sFormat, ARGS&&... args)
  {
    Info(pInterface, plFormatStringImpl<ARGS...>(sFormat, std::forward<ARGS>(args)...));
  }
 
  static void Dev(plLogInterface* pInterface, const plFormatString& string);
 
  template <typename... ARGS>
  static void Dev(plStringView sFormat, ARGS&&... args)
  {
    Dev(GetThreadLocalLogSystem(), plFormatStringImpl<ARGS...>(sFormat, std::forward<ARGS>(args)...));
  }
 
  template <typename... ARGS>
  static void Dev(plLogInterface* pInterface, plStringView sFormat, ARGS&&... args)
  {
    Dev(pInterface, plFormatStringImpl<ARGS...>(sFormat, std::forward<ARGS>(args)...));
  }
 
  static void Debug(plLogInterface* pInterface, const plFormatString& string);
 
  template <typename... ARGS>
  static void Debug(plStringView sFormat, ARGS&&... args)
  {
    Debug(GetThreadLocalLogSystem(), plFormatStringImpl<ARGS...>(sFormat, std::forward<ARGS>(args)...));
  }
 
  template <typename... ARGS>
  static void Debug(plLogInterface* pInterface, plStringView sFormat, ARGS&&... args)
  {
    Debug(pInterface, plFormatStringImpl<ARGS...>(sFormat, std::forward<ARGS>(args)...));
  }
 
  static bool Flush(plUInt32 uiNumNewMsgThreshold = 0, plTime timeIntervalThreshold = plTime::MakeFromSeconds(10), plLogInterface* pInterface = GetThreadLocalLogSystem());
 
  static void BroadcastLoggingEvent(plLogInterface* pInterface, plLogMsgType::Enum type, plStringView sString);
 
  static void Print(const char* szText);
 
  static void Printf(const char* szFormat, ...);
 
  using PrintFunction = void (*)(const char* szText);
 
  static void SetCustomPrintFunction(PrintFunction func);
 
  static void OsMessageBox(const plFormatString& text);
 
  enum class TimestampMode
  {
    None = 0,     
    Numeric = 1,  
    Textual = 2,  
    TimeOnly = 3, 
  };
 
  static void GenerateFormattedTimestamp(TimestampMode mode, plStringBuilder& ref_sTimestampOut);
 
private:
  // Needed to call 'EndLogBlock'
  friend class plLogBlock;
 
  static plLogMsgType::Enum s_DefaultLogLevel;
 
  static void EndLogBlock(plLogInterface* pInterface, plLogBlock* pBlock);
 
  static void WriteBlockHeader(plLogInterface* pInterface, plLogBlock* pBlock);
 
  static PrintFunction s_CustomPrintFunction;
};
 
 
class PL_FOUNDATION_DLL plLogBlock
{
public:
  plLogBlock(plStringView sName, plStringView sContextInfo = {});
 
  plLogBlock(plLogInterface* pInterface, plStringView sName, plStringView sContextInfo = {});
 
  ~plLogBlock();
 
private:
  friend class plLog;
 
  plLogInterface* m_pLogInterface;
  plLogBlock* m_pParentBlock;
  plStringView m_sName;
  plStringView m_sContextInfo;
  plUInt8 m_uiBlockDepth;
  bool m_bWritten;
#if PL_ENABLED(PL_COMPILE_FOR_DEVELOPMENT)
  double m_fSeconds; // for profiling
#endif
};
 
class PL_FOUNDATION_DLL plLogSystemScope
{
public:
  explicit plLogSystemScope(plLogInterface* pInterface)
  {
    m_pPrevious = plLog::GetThreadLocalLogSystem();
    plLog::SetThreadLocalLogSystem(pInterface);
  }
 
  ~plLogSystemScope() { plLog::SetThreadLocalLogSystem(m_pPrevious); }
 
protected:
  plLogInterface* m_pPrevious;
 
private:
  PL_DISALLOW_COPY_AND_ASSIGN(plLogSystemScope);
};
 
 
class plLogSystemToBuffer : public plLogInterface
{
public:
  virtual void HandleLogMessage(const plLoggingEventData& le) override
  {
    switch (le.m_EventType)
    {
      case plLogMsgType::ErrorMsg:
        m_sBuffer.Append("Error: ", le.m_sText, "\n");
        break;
      case plLogMsgType::SeriousWarningMsg:
      case plLogMsgType::WarningMsg:
        m_sBuffer.Append("Warning: ", le.m_sText, "\n");
        break;
      case plLogMsgType::SuccessMsg:
      case plLogMsgType::InfoMsg:
      case plLogMsgType::DevMsg:
      case plLogMsgType::DebugMsg:
        m_sBuffer.Append(le.m_sText, "\n");
        break;
      default:
        break;
    }
  }
 
  plStringBuilder m_sBuffer;
};
 
#include <Foundation/Logging/Implementation/Log_inl.h>