Initial import

src/factory.cpp

@@ -0,0 +1,23 @@
+#include "stdafx.h"
+#include "c11log/details/factory.h"
+#include "c11log/logger.h"
+
+c11log::details::factory::logger_ptr c11log::details::factory::get_logger(const std::string &name)
+{
+	std::lock_guard<std::mutex> lock(_loggers_mutex);
+	auto found = _loggers.find(name);
+	if (found == _loggers.end()) {
+		auto new_logger_ptr = std::make_shared<c11log::logger>(name);
+		_loggers.insert(std::make_pair(name, new_logger_ptr));
+		return new_logger_ptr;
+	}
+	else {		
+		return found->second;
+	}
+}
+
+c11log::details::factory & c11log::details::factory::instance()
+{
+	static c11log::details::factory instance;
+	return instance;
+}

src/formatters.cpp

@@ -0,0 +1,36 @@
+#include "stdafx.h"
+#include "c11log/formatters/formatters.h"
+#include "c11log/level.h"
+
+void c11log::formatters::format_time(const c11log::formatters::timepoint& tp, std::ostream &dest)
+{
+    std::tm tm = details::os::localtime(std::chrono::system_clock::to_time_t(tp));
+    //get ms
+    auto duration = tp.time_since_epoch();
+    int millis = static_cast<int>(std::chrono::duration_cast<std::chrono::milliseconds>(duration).count() % 1000);
+    //std::put_time(&tm, "[ %Y-%m-%d %H:%M:%S ]") - seems too slow
+    char buf[64];
+    sprintf(buf, "[%d-%02d-%02d %02d:%02d:%02d.%03d]",
+            tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
+            tm.tm_hour, tm.tm_min, tm.tm_sec, millis);
+    dest << buf;
+}
+
+void c11log::formatters::format_time(std::ostream& dest)
+{
+    return format_time(std::chrono::system_clock::now(), dest);
+}
+
+
+static const char _hex_chars[17] = "0123456789ABCDEF";
+
+std::string c11log::formatters::to_hex(const unsigned char* buf, std::size_t size)
+{
+    std::ostringstream oss;
+
+    for (std::size_t i = 0; i < size; i++) {
+        oss << _hex_chars[buf[i] >> 4];
+        oss << _hex_chars[buf[i] & 0x0F];
+    }
+    return oss.str();
+}

src/line_logger.cpp

@@ -0,0 +1,21 @@
+#include "stdafx.h"
+#include "c11log/logger.h"
+
+c11log::details::line_logger::line_logger(logger* callback_logger, level::level_enum msg_level) :
+    _callback_logger(callback_logger)
+{
+    if (callback_logger) {
+        callback_logger->_formatter->format_header(callback_logger->_logger_name,
+                msg_level,
+                c11log::formatters::timepoint::clock::now(),
+                _oss);
+    }
+}
+
+c11log::details::line_logger::~line_logger()
+{
+    if (_callback_logger) {
+        _oss << '\n';
+        _callback_logger->_log_it(_oss.str_ref());
+    }
+}

src/logger.cpp

@@ -0,0 +1,51 @@
+#include "stdafx.h"
+#include <algorithm>
+
+#include "c11log/logger.h"
+
+void c11log::logger::set_name(const std::string& name)
+{
+    std::lock_guard<std::mutex> lock(_mutex);
+    _logger_name = name;
+}
+
+const std::string& c11log::logger::get_name()
+{
+    std::lock_guard<std::mutex> lock(_mutex);
+    return _logger_name;
+}
+
+void c11log::logger::add_sink(sink_ptr_t sink_ptr)
+{
+    std::lock_guard<std::mutex> lock(_mutex);
+    _sinks.push_back(sink_ptr);
+}
+
+void c11log::logger::remove_sink(sink_ptr_t sink_ptr)
+{
+    std::lock_guard<std::mutex> lock(_mutex);
+    _sinks.erase(std::remove(_sinks.begin(), _sinks.end(), sink_ptr), _sinks.end());
+}
+
+void c11log::logger::set_formatter(std::unique_ptr<formatters::formatter> formatter)
+{
+    std::lock_guard<std::mutex> lock(_mutex);
+    _formatter = std::move(formatter);
+}
+
+void c11log::logger::set_level(c11log::level::level_enum level)
+{
+    std::lock_guard<std::mutex> lock(_mutex);
+    _level = level;
+}
+
+bool c11log::logger::should_log(c11log::level::level_enum level)
+{
+    std::lock_guard<std::mutex> lock(_mutex);
+    return level >= _level;
+}
+
+c11log::logger& c11log::get_logger(const std::string& name)
+{
+    return *(c11log::details::factory::instance().get_logger(name));
+}

src/os.cpp

@@ -0,0 +1,24 @@
+#include "stdafx.h"
+
+#include "c11log/details/os.h"
+
+namespace c11log {
+namespace details {
+namespace os {
+std::tm localtime(const std::time_t &time_t)
+{
+#ifdef _MSC_VER
+    std::tm tm;
+    localtime_s(&tm, &time_t);
+    return tm;
+#endif
+}
+
+std::tm localtime()
+{
+    std::time_t now_t = time(0);
+    return localtime(now_t);
+}
+}
+}
+}