1. Added test

2. Fixes

include/c11log/logger.h

@@ -1,5 +1,7 @@
 #pragma once
 
+// Thread safe logger
+// Has log level and vector sinks which do the actual logging
 #include<vector>
 #include<memory>
 #include<mutex>
@@ -20,15 +22,13 @@ public:
     typedef std::shared_ptr<sinks::base_sink>  sink_ptr_t;
     typedef std::vector<sink_ptr_t> sinks_vector_t;
 
-    explicit logger(const std::string& name) : _logger_name(name),
-        _formatter(std::make_unique<formatters::default_formatter>())
+    explicit logger(const std::string& name) : logger_name_(name),
+        formatter_(std::make_unique<formatters::default_formatter>())
     {
-        _atomic_level.store(level::INFO);
+        atomic_level_.store(level::INFO);
     }
 
-    ~logger()
-    {
-    };
+    ~logger() = default;
 
     logger(const logger&) = delete;
     logger& operator=(const logger&) = delete;
@@ -53,30 +53,32 @@ private:
     friend details::line_logger;
 
 
-    std::string _logger_name = "";
-    std::unique_ptr<c11log::formatters::formatter> _formatter;
-    sinks_vector_t _sinks;
-    std::mutex _mutex;
-    std::atomic_int _atomic_level;
+    std::string logger_name_ = "";
+    std::unique_ptr<c11log::formatters::formatter> formatter_;
+    sinks_vector_t sinks_;
+    std::mutex mutex_;
+    std::atomic_int atomic_level_;
 
-    void _log_it(const std::string& msg);
+    void log_it_(const std::string& msg);
 
 };
 
 logger& get_logger(const std::string& name);
 }
 
-/*
-Logger inline impl
-*/
-
+//
+// Logger inline impl
+//
 inline c11log::details::line_logger c11log::logger::log(c11log::level::level_enum msg_level)
 {
 
-    if (msg_level >= _atomic_level.load()) {
-        std::lock_guard<std::mutex> lock(_mutex);
+    if (msg_level >= atomic_level_.load())
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
         return details::line_logger(this, msg_level);
-    } else {
+    } 
+    else
+    {
         return details::line_logger(nullptr);
     }
 
@@ -105,56 +107,57 @@ inline c11log::details::line_logger c11log::logger::fatal()
 
 inline void c11log::logger::set_name(const std::string& name)
 {
-    std::lock_guard<std::mutex> lock(_mutex);
-    _logger_name = name;
+    std::lock_guard<std::mutex> lock(mutex_);
+    logger_name_ = name;
 }
 
 inline const std::string& c11log::logger::get_name()
 {
-    std::lock_guard<std::mutex> lock(_mutex);
-    return _logger_name;
+    std::lock_guard<std::mutex> lock(mutex_);
+    return logger_name_;
 }
 
 inline void c11log::logger::add_sink(sink_ptr_t sink_ptr)
 {
-    std::lock_guard<std::mutex> lock(_mutex);
-    _sinks.push_back(sink_ptr);
+    std::lock_guard<std::mutex> lock(mutex_);
+    sinks_.push_back(sink_ptr);
 }
 
 inline 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());
+    std::lock_guard<std::mutex> lock(mutex_);
+    sinks_.erase(std::remove(sinks_.begin(), sinks_.end(), sink_ptr), sinks_.end());
 }
 
 inline void c11log::logger::set_formatter(std::unique_ptr<formatters::formatter> formatter)
 {
-    std::lock_guard<std::mutex> lock(_mutex);
-    _formatter = std::move(formatter);
+    std::lock_guard<std::mutex> lock(mutex_);
+    formatter_ = std::move(formatter);
 }
 
 inline void c11log::logger::set_level(c11log::level::level_enum level)
 {
-    _atomic_level.store(level);
+    atomic_level_.store(level);
 }
 
 inline c11log::level::level_enum c11log::logger::get_level() const
 {
-    return static_cast<c11log::level::level_enum>(_atomic_level.load());
+    return static_cast<c11log::level::level_enum>(atomic_level_.load());
 }
 
 inline bool c11log::logger::should_log(c11log::level::level_enum level) const
 {
-    return level >= _atomic_level.load();
+    return level >= atomic_level_.load();
 }
-inline void c11log::logger::_log_it(const std::string& msg)
+inline void c11log::logger::log_it_(const std::string& msg)
 {
-    level::level_enum level = static_cast<level::level_enum>(_atomic_level.load());
-    std::lock_guard<std::mutex> lock(_mutex);
-    for (auto &sink : _sinks)
+    level::level_enum level = static_cast<level::level_enum>(atomic_level_.load());
+    std::lock_guard<std::mutex> lock(mutex_);
+    for (auto &sink : sinks_)
         sink->log(msg, level);
 }
 
+// Static factory function
 inline c11log::logger& c11log::get_logger(const std::string& name)
 {
     return *(c11log::details::factory::instance().get_logger(name));