added crow

include/crow/logging.h

@@ -0,0 +1,175 @@
+#pragma once
+
+#include "crow/settings.h"
+
+#include <cstdio>
+#include <cstdlib>
+#include <ctime>
+#include <iostream>
+#include <sstream>
+#include <string>
+
+namespace crow
+{
+    enum class LogLevel
+    {
+#ifndef ERROR
+#ifndef DEBUG
+        DEBUG = 0,
+        INFO,
+        WARNING,
+        ERROR,
+        CRITICAL,
+#endif
+#endif
+
+        Debug = 0,
+        Info,
+        Warning,
+        Error,
+        Critical,
+    };
+
+    class ILogHandler
+    {
+    public:
+        virtual ~ILogHandler() = default;
+
+        virtual void log(const std::string& message, LogLevel level) = 0;
+    };
+
+    class CerrLogHandler : public ILogHandler
+    {
+    public:
+        void log(const std::string &message, LogLevel level) override
+        {
+            std::string log_msg;
+            log_msg.reserve(message.length() + 1+32+3+8+2);
+            log_msg
+                .append("(")
+                .append(timestamp())
+                .append(") [");
+
+            switch (level)
+            {
+                case LogLevel::Debug:
+                    log_msg.append("DEBUG   ");
+                    break;
+                case LogLevel::Info:
+                    log_msg.append("INFO    ");
+                    break;
+                case LogLevel::Warning:
+                    log_msg.append("WARNING ");
+                    break;
+                case LogLevel::Error:
+                    log_msg.append("ERROR   ");
+                    break;
+                case LogLevel::Critical:
+                    log_msg.append("CRITICAL");
+                    break;
+            }
+
+            log_msg.append("] ")
+            .append(message);
+
+            std::cerr << log_msg << std::endl;
+        }
+
+    private:
+        static std::string timestamp()
+        {
+            char date[32];
+            time_t t = time(0);
+
+            tm my_tm;
+
+#if defined(_MSC_VER) || defined(__MINGW32__)
+#ifdef CROW_USE_LOCALTIMEZONE
+            localtime_s(&my_tm, &t);
+#else
+            gmtime_s(&my_tm, &t);
+#endif
+#else
+#ifdef CROW_USE_LOCALTIMEZONE
+            localtime_r(&t, &my_tm);
+#else
+            gmtime_r(&t, &my_tm);
+#endif
+#endif
+
+            size_t sz = strftime(date, sizeof(date), "%Y-%m-%d %H:%M:%S", &my_tm);
+            return std::string(date, date + sz);
+        }
+    };
+
+    class logger
+    {
+    public:
+        logger(LogLevel level):
+          level_(level)
+        {}
+        ~logger()
+        {
+#ifdef CROW_ENABLE_LOGGING
+            if (level_ >= get_current_log_level())
+            {
+                get_handler_ref()->log(stringstream_.str(), level_);
+            }
+#endif
+        }
+
+        //
+        template<typename T>
+        logger& operator<<(T const& value)
+        {
+#ifdef CROW_ENABLE_LOGGING
+            if (level_ >= get_current_log_level())
+            {
+                stringstream_ << value;
+            }
+#endif
+            return *this;
+        }
+
+        //
+        static void setLogLevel(LogLevel level) { get_log_level_ref() = level; }
+
+        static void setHandler(ILogHandler* handler) { get_handler_ref() = handler; }
+
+        static LogLevel get_current_log_level() { return get_log_level_ref(); }
+
+    private:
+        //
+        static LogLevel& get_log_level_ref()
+        {
+            static LogLevel current_level = static_cast<LogLevel>(CROW_LOG_LEVEL);
+            return current_level;
+        }
+        static ILogHandler*& get_handler_ref()
+        {
+            static CerrLogHandler default_handler;
+            static ILogHandler* current_handler = &default_handler;
+            return current_handler;
+        }
+
+        //
+        std::ostringstream stringstream_;
+        LogLevel level_;
+    };
+} // namespace crow
+
+#define CROW_LOG_CRITICAL                                                  \
+    if (crow::logger::get_current_log_level() <= crow::LogLevel::Critical) \
+    crow::logger(crow::LogLevel::Critical)
+#define CROW_LOG_ERROR                                                  \
+    if (crow::logger::get_current_log_level() <= crow::LogLevel::Error) \
+    crow::logger(crow::LogLevel::Error)
+#define CROW_LOG_WARNING                                                  \
+    if (crow::logger::get_current_log_level() <= crow::LogLevel::Warning) \
+    crow::logger(crow::LogLevel::Warning)
+#define CROW_LOG_INFO                                                  \
+    if (crow::logger::get_current_log_level() <= crow::LogLevel::Info) \
+    crow::logger(crow::LogLevel::Info)
+#define CROW_LOG_DEBUG                                                  \
+    if (crow::logger::get_current_log_level() <= crow::LogLevel::Debug) \
+    crow::logger(crow::LogLevel::Debug)