logger refactoring to init lists and mutex remove

include/c11log/details/factory.h

@@ -13,29 +13,45 @@ 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);
+    using logger_ptr = std::shared_ptr<c11log::logger>;
+    using logger_map = std::unordered_map<std::string, logger_ptr>;
+	void add_logger(const std::string& name, logger_ptr);
+    logger_ptr get_logger(const std::string &name);	
     static c11log::details::factory& instance();
 private:
+	std::mutex _loggers_mutex;
     logger_map _loggers;
-    std::mutex _loggers_mutex;
+
 };
 }
 }
 
 
+inline void c11log::details::factory::add_logger(const std::string& name, logger_ptr logger_p)
+{
+	std::lock_guard<std::mutex> lock(_loggers_mutex);
+	_loggers.insert(logger_map::value_type(name, logger_p));
+}
+
 inline 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);
+
+	auto found = _loggers.find(name);
+	if (found != _loggers.end())
+		return found->second;
+	else
+		return logger_ptr(nullptr);
+	/*
+	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;
-    }
+    }*/
 }
 
 inline c11log::details::factory & c11log::details::factory::instance()

include/c11log/details/line_logger.h

@@ -3,11 +3,15 @@
 #include "../common_types.h"
 #include "../logger.h"
 #include "fast_oss.h"
-#include <iostream>
+
+
+// line logger class. should be used by the logger as an rvalue only.
+// aggregates logging string until the end of the line and then calls the logger upon destruction
+
 
 namespace c11log
 {
-class logger;
+//class logger;
 namespace details
 {
 
@@ -19,24 +23,27 @@ public:
         _oss(),
         _level(msg_level),
         _enabled(enabled) {
-        callback_logger->_formatter->format_header(callback_logger->_logger_name,
-                msg_level,
-                log_clock::now(),
-                _oss);
+        if(enabled) {
+            callback_logger->_formatter->format_header(callback_logger->_logger_name,
+                    msg_level,
+                    log_clock::now(),
+                    _oss);
+        }
     }
     // No copy intended. Only move
     line_logger(const line_logger& other) = delete;
+    line_logger& operator=(const line_logger&) = delete;
+    line_logger& operator=(line_logger&&) = delete;
 
     line_logger(line_logger&& other) :
         _callback_logger(other._callback_logger),
+        // The move ctor should only be called on start of logging line,
+        // where no logging happened yet for this line so no need to copy the string from the other
         _oss(),
         _level(other._level) {
     };
 
 
-    line_logger& operator=(const line_logger&) = delete;
-    line_logger& operator=(line_logger&&) = delete;
-
     ~line_logger() {
         if (_enabled) {
             _oss << '\n';
@@ -46,15 +53,14 @@ public:
 
 
     template<typename T>
-    line_logger& operator<<(const T& msg) {
+    line_logger&& operator<<(const T& msg) && {
         if (_enabled)
             _oss << msg;
-        return *this;
+        return std::move(*this);
     }
 
 private:
     logger* _callback_logger;
-    //std::ostringstream _oss;
     details::fast_oss _oss;
     level::level_enum _level;
     bool _enabled;