debug::Logger

src/debug/Logger.cpp

@@ -0,0 +1,74 @@
+#include "Logger.h"
+ 
+#include <ctime>
+#include <iomanip>
+#include <chrono>
+
+using namespace debug;
+
+std::ofstream Logger::file;
+std::mutex Logger::mutex;
+std::string Logger::utcOffset = "";
+unsigned Logger::moduleLen = 16;
+
+LogMessage::~LogMessage() {
+    logger->log(level, ss.str());
+}
+
+Logger::Logger(std::string name) : name(name) {
+}
+
+void Logger::log(LogLevel level, const std::string& name, std::string message) {
+    using namespace std::chrono;
+
+    std::stringstream ss;
+    switch (level) {
+        case LogLevel::debug:
+#         ifdef NDEBUG
+            return;
+#         endif
+            ss << "[D]";
+            break;
+        case LogLevel::info:
+            ss << "[I]";
+            break;
+        case LogLevel::warning:
+            ss << "[W]";
+            break;
+        case LogLevel::error:
+            ss << "[E]";
+            break;
+    }
+    time_t tm = std::time(nullptr);
+    auto ms = duration_cast<milliseconds>(system_clock::now().time_since_epoch()) % 1000;
+    ss << " " << std::put_time(std::localtime(&tm), "%Y/%m/%d %T");
+    ss << '.' << std::setfill('0') << std::setw(3) << ms.count();
+    ss << utcOffset << " (" << std::setfill(' ') << std::setw(moduleLen) << name << ") ";
+    ss << message;
+    {
+        std::lock_guard<std::mutex> lock(mutex);
+        auto string = ss.str();
+        if (file.good()) {
+            file << string << '\n';
+        }
+        std::cout << string << std::endl;
+    }
+}
+
+void Logger::init(const std::string& filename) {
+    file.open(filename);
+
+    time_t tm = std::time(nullptr);
+    std::stringstream ss;
+    ss << std::put_time(std::localtime(&tm), "%z");
+    utcOffset = ss.str();
+}
+
+void Logger::flush() {
+    std::lock_guard<std::mutex> lock(mutex);
+    file.flush();
+}
+
+void Logger::log(LogLevel level, std::string message) {
+    log(level, name, message);
+}

src/debug/Logger.h

@@ -0,0 +1,66 @@
+#ifndef DEBUG_LOGGER_H_
+#define DEBUG_LOGGER_H_
+
+#include <sstream>
+#include <fstream>
+#include <iostream>
+#include <mutex>
+
+namespace debug {
+    enum class LogLevel {
+        debug, info, warning, error
+    };
+
+    class Logger;
+
+    class LogMessage {
+        Logger* logger;
+        LogLevel level;
+        std::stringstream ss;
+    public:
+        LogMessage(Logger* logger, LogLevel level) : logger(logger), level(level) {}
+        ~LogMessage();
+
+        template<class T>
+        LogMessage& operator<<(const T& x) {
+            ss << x;
+            return *this;
+        }
+    };
+
+    class Logger {
+        static std::mutex mutex;
+        static std::string utcOffset;
+        static std::ofstream file;
+        static unsigned moduleLen;
+
+        std::string name;
+   
+        static void log(LogLevel level, const std::string& name, std::string message);
+    public:
+        static void init(const std::string& filename);
+        static void flush();
+
+        Logger(std::string name);
+
+        void log(LogLevel level, std::string message);
+
+        LogMessage debug() {
+            return LogMessage(this, LogLevel::debug);
+        }
+
+        LogMessage info() {
+            return LogMessage(this, LogLevel::info);
+        }
+
+        LogMessage error() {
+            return LogMessage(this, LogLevel::error);
+        }
+
+        LogMessage warning() {
+            return LogMessage(this, LogLevel::warning);
+        }
+    };
+}
+
+#endif // DEBUG_LOGGER_H_