streamlog.hpp

Go to the documentation of this file.

#ifndef STREAMLOG_HPP
#define STREAMLOG_HPP

 
#include <ctime>
#include <fstream>
#include <iostream>
#include <sstream>
 
#ifdef ENABLE_VECTOR_LOGGING
#include <vector>
#endif
 
#ifdef ENABLE_MAP_LOGGING
#include <map>
#endif

enum LogLevel {
  TRACE, 
  DEBUG, 
  INFO,  
  WARN,  
  ERROR, 
  FATAL  
};
 
#if DEBUG_LEVEL == 1
#define LOG_LEVEL TRACE
#elif DEBUG_LEVEL == 2
#define LOG_LEVEL DEBUG
#elif DEBUG_LEVEL == 3
#define LOG_LEVEL INFO
#elif DEBUG_LEVEL == 4
#define LOG_LEVEL WARN
#elif DEBUG_LEVEL == 5
#define LOG_LEVEL ERROR
#elif DEBUG_LEVEL == 6
#define LOG_LEVEL FATAL
#endif

struct StreamColor {
  static const std::string TraceColor; 
  static const std::string DebugColor; 
  static const std::string InfoColor;  
  static const std::string WarnColor;  
  static const std::string ErrorColor; 
  static const std::string FatalColor; 
  static const std::string reset;      
};

class StreamLog {
public:
  class LogStatement {
  public:
    LogStatement(LogStatement &&other) noexcept;

    LogStatement(StreamLog &logger);

    template <typename T> LogStatement &operator<<(const T &value) {
      m_buffer << value;
      return *this;
    }

    LogStatement &operator<<(const char *value) {
      m_buffer << value;
      return *this;
    }
 
#ifdef ENABLE_VECTOR_LOGGING
    template <typename T> LogStatement &operator<<(const std::vector<T> &vec) {
      m_buffer << "[";
      for (size_t i = 0; i < vec.size(); ++i) {
        m_buffer << vec[i];
        if (i != vec.size() - 1) {
          m_buffer << ", ";
        }
      }
      m_buffer << "]";
      return *this;
    }
#endif
 
#ifdef ENABLE_MAP_LOGGING
    template <typename K, typename V>
    LogStatement &operator<<(const std::map<K, V> &m) {
      m_buffer << "{";
      for (auto it = m.begin(); it != m.end(); ++it) {
        m_buffer << it->first << ": " << it->second;
        if (std::next(it) != m.end()) {
          m_buffer << ", ";
        }
      }
      m_buffer << "}";
      return *this;
    }
#endif
    void clearBuffer();

    std::string getBufferContent() const;

    void appendToBuffer(const std::string &content);

    ~LogStatement();
 
  private:
    StreamLog &m_logger;
    std::ostringstream m_buffer;
  };

  LogStatement getLogStatement(LogLevel level);

  LogStatement operator<<(std::ostream &(*manipulator)(std::ostream &));
 
public:
  static StreamLog &instance(const std::string &fileName = "output.log",
                             bool consoleOutput = false);

  virtual ~StreamLog();
 
  // Delete copy and move operations (Rule of Five)
  StreamLog(const StreamLog &) = delete; 
  StreamLog &operator=(const StreamLog &) = delete; 
  StreamLog(StreamLog &&) = delete; 
  StreamLog &operator=(StreamLog &&) = delete; 
 
protected:
  explicit StreamLog(const std::string &fileName, bool consoleOutput = false);
 
  LogLevel m_level;       
  LogLevel m_threshold;   
 
  std::string m_fileName;  
  bool m_consoleOutput;    

  std::string levelToString(const LogLevel &level) const;

  std::string getColor() const;

  virtual std::string getTimestamp() const;

  virtual std::stringstream buildLog(const std::string &message) const;

  void writeLog(const std::string &message);

  void commitLog(const std::string &message);
 
private:
  bool createDirectories(const std::string &path) const;
};

StreamLog::LogStatement log(LogLevel level);
#endif