NLogger.h

#pragma once
#include <memory>
#include <mutex>
#include <string>
#include <unordered_map>
#include <memory>
#include <mutex>
#include <string>
#include <unordered_map>
#include <fstream>
#include <thread>
 
#define NLog(level, format, ...) Ndmspc::NLogger::Log(__FILE__, __LINE__, level, format, ##__VA_ARGS__)
 
#define NLogTrace(format, ...) \
  Ndmspc::NLogger::Log(__FILE__, __LINE__, Ndmspc::logs::Severity::kTrace, format, ##__VA_ARGS__)
 
#define NLogDebug(format, ...) \
  Ndmspc::NLogger::Log(__FILE__, __LINE__, Ndmspc::logs::Severity::kDebug, format, ##__VA_ARGS__)
 
#define NLogInfo(format, ...) \
  Ndmspc::NLogger::Log(__FILE__, __LINE__, Ndmspc::logs::Severity::kInfo, format, ##__VA_ARGS__)
 
#define NLogWarning(format, ...) \
  Ndmspc::NLogger::Log(__FILE__, __LINE__, Ndmspc::logs::Severity::kWarn, format, ##__VA_ARGS__)
 
#define NLogError(format, ...) \
  Ndmspc::NLogger::Log(__FILE__, __LINE__, Ndmspc::logs::Severity::kError, format, ##__VA_ARGS__)
 
#define NLogFatal(format, ...) \
  Ndmspc::NLogger::Log(__FILE__, __LINE__, Ndmspc::logs::Severity::kFatal, format, ##__VA_ARGS__)
 
namespace Ndmspc {
 
namespace logs {
 
enum class Severity {
  kTrace = 0, 
  kTrace2,    
  kTrace3,    
  kTrace4,    
  kDebug,     
  kDebug2,    
  kDebug3,    
  kDebug4,    
  kInfo,      
  kInfo2,     
  kInfo3,     
  kInfo4,     
  kWarn,      
  kWarn2,     
  kWarn3,     
  kWarn4,     
  kError,     
  kError2,    
  kError3,    
  kError4,    
  kFatal,     
  kFatal2,    
  kFatal3,    
  kFatal4     
};
 
static const std::unordered_map<std::string, Severity> fgSeverityMap = {
    {"TRACE", Severity::kTrace},   {"TRACE2", Severity::kTrace2}, {"TRACE3", Severity::kTrace3},
    {"TRACE4", Severity::kTrace4}, {"DEBUG", Severity::kDebug},   {"DEBUG2", Severity::kDebug2},
    {"DEBUG3", Severity::kDebug3}, {"DEBUG4", Severity::kDebug4}, {"INFO", Severity::kInfo},
    {"INFO2", Severity::kInfo2},   {"INFO3", Severity::kInfo3},   {"INFO4", Severity::kInfo4},
    {"WARN", Severity::kWarn},     {"WARN2", Severity::kWarn2},   {"WARN3", Severity::kWarn3},
    {"WARN4", Severity::kWarn4},   {"ERROR", Severity::kError},   {"ERROR2", Severity::kError2},
    {"ERROR3", Severity::kError3}, {"ERROR4", Severity::kError4}, {"FATAL", Severity::kFatal},
    {"FATAL2", Severity::kFatal2}, {"FATAL3", Severity::kFatal3}, {"FATAL4", Severity::kFatal4}};
} // namespace logs
 
class NLogger {
  public:
  NLogger();
 
  virtual ~NLogger();
 
  // Delete copy constructor and assignment operator
  NLogger(const NLogger &)             = delete;
  NLogger & operator=(const NLogger &) = delete;
 
  static NLogger * Instance();
 
  static std::string SeverityToString(logs::Severity level);
 
  static logs::Severity GetSeverityFromString(const std::string & severity_str);
 
  static void Log(const char * file, int line, logs::Severity level, const char * format, ...);
 
  static void SetMinSeverity(logs::Severity level) { fgMinSeverity = level; }
 
  static logs::Severity GetMinSeverity() { return fgMinSeverity; }
 
  static void SetLogDirectory(const std::string & dir);
 
  static void SetConsoleOutput(bool enable) { fgConsoleOutput = enable; }
 
  static void SetFileOutput(bool enable) { fgFileOutput = enable; } // New: Set process name (prefix for all log files)
 
  static void SetProcessName(const std::string & name);
 
  static std::string GetProcessName() { return fgProcessName; }
 
  static void SetThreadName(const std::string & name, std::thread::id thread_id = std::this_thread::get_id());
 
  static std::string GetThreadName();
 
  static bool         GetConsoleOutput() { return fgConsoleOutput; } 
  static bool         GetFileOutput() { return fgFileOutput; }       
  static std::string  GetLogDirectory() { return fgLogDirectory; }   
  static std::mutex & GetLoggerMutex() { return fgLoggerMutex; }     
 
  private:
  static std::mutex               fgLoggerMutex;   
  static logs::Severity           fgMinSeverity;   
  static std::string              fgLogDirectory;  
  static bool                     fgConsoleOutput; 
  static bool                     fgFileOutput;    
  static std::string              fgProcessName;   
  static std::unique_ptr<NLogger> fgLogger;        
 
  void Init();
 
  void Cleanup();
  std::ofstream & GetThreadStream();
 
  void CloseThreadStream(std::thread::id thread_id);
 
  std::mutex fStreamMapMutex;
 
  std::unordered_map<std::thread::id, std::unique_ptr<std::ofstream>> fThreadStreams;
  std::unordered_map<std::thread::id, std::string> fThreadNames;          
  std::string                                      GetThreadIdentifier(); 
 
  // ClassDefOverride(NLogger, 1);
};
} // namespace Ndmspc