Initial import

include/c11log/details/blocking_queue.h

@@ -0,0 +1,64 @@
+#pragma once
+
+#include <cstddef>
+#include <chrono>
+#include <memory>
+#include <queue>
+#include <mutex>
+#include <condition_variable>
+
+namespace c11log {
+namespace details {
+
+template<typename T>
+class blocking_queue {
+public:
+    explicit blocking_queue(std::size_t max_size) :_max_size(max_size), _q()
+    {}
+    blocking_queue(const blocking_queue&) = delete;
+    blocking_queue& operator=(const blocking_queue&) = delete;
+    ~blocking_queue() = default;
+
+    std::size_t size()
+    {
+        std::lock_guard<std::mutex> lock(_mutex);
+        return _q.size();
+    }
+    bool push(const T& item, const std::chrono::milliseconds& timeout)
+    {
+        std::unique_lock<std::mutex> ul(_mutex);
+        if (_q.size() >= _max_size) {
+            if (_item_popped_cond.wait_for(ul, timeout) == std::cv_status::timeout || _q.size() >= _max_size)
+                return false;
+        }
+
+        _q.push(item);
+        if (_q.size() <= 1)
+            _item_pushed_cond.notify_all();
+
+        return true;
+    }
+    bool pop(T& item, const std::chrono::milliseconds& timeout)
+    {
+        std::unique_lock<std::mutex> ul(_mutex);
+        if (_q.empty()) {
+            if (_item_pushed_cond.wait_for(ul, timeout) == std::cv_status::timeout || _q.empty())
+                return false;
+        }
+        item = _q.front();
+        _q.pop();
+        if (_q.size() >= _max_size - 1)
+            _item_popped_cond.notify_all();
+
+        return true;
+    }
+private:
+    std::size_t _max_size;
+    std::queue<T> _q;
+    std::mutex _mutex;
+    std::condition_variable _item_pushed_cond;
+    std::condition_variable _item_popped_cond;
+};
+
+}
+}

include/c11log/details/factory.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <unordered_map>
+#include <string>
+#include <memory>
+#include <mutex>
+
+namespace c11log {
+class logger;
+namespace details {
+class factory {
+public:
+    typedef std::shared_ptr<c11log::logger>  logger_ptr;
+    typedef std::unordered_map<std::string, logger_ptr> logger_map;
+    logger_ptr get_logger(const std::string &name);
+    static c11log::details::factory& instance();
+private:
+    logger_map _loggers;
+    std::mutex _loggers_mutex;
+};
+}
+}

include/c11log/details/fast_oss.h

@@ -0,0 +1,76 @@
+#pragma once
+
+#include<streambuf>
+#include<string>
+namespace c11log {
+namespace details {
+
+class str_devicebuf:public std::streambuf {
+public:
+    str_devicebuf()
+    {
+        _str.reserve(128);
+    }
+
+    const std::string& str_ref()
+    {
+        return _str;
+    }
+
+    void clear()
+    {
+        _str.clear();
+    }
+
+protected:
+    virtual int sync() override
+    {
+        return 0;
+    }
+
+    virtual std::streamsize xsputn(const char_type* s, std::streamsize count) override
+    {
+        _str.append(s, static_cast<unsigned int>(count));
+        return count;
+    }
+
+    virtual int_type overflow(int_type ch) override
+    {
+        if (ch != traits_type::eof())
+            _str.append((char*)&ch, 1);
+        return 1;
+    }
+private:
+    std::string _str;
+};
+
+class fast_oss:public std::ostream {
+public:
+    fast_oss():std::ostream(&_dev)
+    {}
+    ~fast_oss()
+    {}
+
+    const std::string& str_ref() const
+    {
+        auto mydevice = static_cast<str_devicebuf*>(rdbuf());
+        return mydevice->str_ref();
+    }
+
+    const std::string str() const
+    {
+        auto mydevice = static_cast<str_devicebuf*>(rdbuf());
+        return mydevice->str_ref();
+    }
+
+    void clear()
+    {
+        auto mydevice = static_cast<str_devicebuf*>(rdbuf());
+        mydevice->clear();
+    }
+private:
+    str_devicebuf _dev;
+
+};
+}
+}

include/c11log/details/line_logger.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "../level.h"
+#include "fast_oss.h"
+
+namespace c11log {
+class logger;
+namespace details {
+
+class line_logger {
+public:
+    c11log::details::line_logger::line_logger(logger* callback_logger, level::level_enum msg_level);
+    c11log::details::line_logger::line_logger(logger* callback_logger):_callback_logger(nullptr) {};
+    ~line_logger();
+
+    template<typename T>
+    line_logger& operator<<(const T& msg)
+    {
+        if (_callback_logger)
+            _oss << msg;
+        return *this;
+    }
+
+private:
+    logger* _callback_logger;
+    details::fast_oss _oss;
+
+};
+} //Namespace details
+} // Namespace c11log

include/c11log/details/message.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <chrono>
+#include <string>
+#include "../level.h"
+
+namespace c11log {
+namespace details {
+struct message {
+    message(const std::string& logger_name,
+            level::level_enum log_level,
+            const std::chrono::system_clock::time_point time_p
+            , const std::string& msg) :
+        logger_name(logger_name),
+        log_level(log_level),
+        time_p(time_p),
+        msg(msg) {}
+
+    ~message() = default;
+    message(const message& other) = default;
+    message& operator=(const message& rhs) = default;
+
+
+    std::string logger_name;
+    level::level_enum log_level;
+    std::chrono::system_clock::time_point time_p;
+    std::string msg;
+};
+
+}
+}

include/c11log/details/null_mutex.h

@@ -0,0 +1,17 @@
+#pragma once
+
+namespace c11log{
+	namespace details{
+		struct null_mutex
+		{
+			void lock()
+			{}
+			void unlock()
+			{}
+			bool try_lock()
+			{
+				return true;
+			}
+		};
+	}
+}

include/c11log/details/os.h

@@ -0,0 +1,17 @@
+#pragma once
+#include<string>
+#include<cstdio>
+#include<ctime>
+
+namespace c11log
+{
+	namespace details
+	{
+		namespace os
+		{			
+			std::tm localtime(const std::time_t &time_t);			
+			std::tm localtime();
+			
+		}		
+	}
+}