removed un needed mutex, and added copy ctors to line logger and friends

build/gcc/makefile

@@ -1,6 +1,6 @@
 SRC_DIR=../../src
 
-_SOURCES = factory.cpp formatters.cpp line_logger.cpp os.cpp
+_SOURCES = factory.cpp formatters.cpp os.cpp
 
 SOURCES = $(patsubst %,$(SRC_DIR)/%,$(_SOURCES))
 OBJS_RELEASE = $(patsubst %.cpp,release/%.o,$(_SOURCES))
@@ -8,7 +8,7 @@ OBJS_DEBUG = $(patsubst %.cpp,debug/%.o,$(_SOURCES))
 
 
 CXX	= g++
-CXXFLAGS	= -march=native -Wall -std=c++11 -pthread -I../../include 
+CXXFLAGS	= -march=native -Wall -Wextra -Wshadow -pedantic -std=c++11 -pthread -I../../include 
 CXX_RELEASE_FLAGS = -O2 -flto -g
 CXX_DEBUG_FLAGS= -g 
 

include/c11log/details/fast_oss.h

@@ -2,72 +2,80 @@
 
 #include<streambuf>
 #include<string>
-namespace c11log {
+namespace c11log
-namespace details {
+{
+namespace details
+{
 
-class str_devicebuf:public std::streambuf {
+class str_devicebuf:public std::streambuf
+{
 public:
-    str_devicebuf() = default;
+	str_devicebuf() = default;
-    ~str_devicebuf() = default;
+	~str_devicebuf() = default;
-    str_devicebuf(const str_devicebuf&) = delete;	
+	str_devicebuf(const str_devicebuf& other):std::streambuf(),_str(other._str) {}
-    str_devicebuf& operator=(const str_devicebuf&) = delete;
+	str_devicebuf& operator=(const str_devicebuf other)
+	{
+		if(this != &other)
+			_str = other._str;
+		return *this;
+	}
 
-    const std::string& str_ref() const
+	const std::string& str_ref() const {
-    {
+		return _str;
-        return _str;
+	}
-    }
 
-    void clear()
+	void clear() {
-    {
+		_str.clear();
-        _str.clear();
+	}
-    }
 
 protected:
-    virtual int sync() override
+	virtual int sync() override {
-    {
+		return 0;
-        return 0;
+	}
-    }
 
-    virtual std::streamsize xsputn(const char_type* s, std::streamsize count) override
+	virtual std::streamsize xsputn(const char_type* s, std::streamsize count) override {
-    {
+		_str.append(s, static_cast<unsigned int>(count));
-        _str.append(s, static_cast<unsigned int>(count));
+		return count;
-        return count;
+	}
-    }
 
-    virtual int_type overflow(int_type ch) override
+	virtual int_type overflow(int_type ch) override {
-    {
+		if (ch != traits_type::eof())
-        if (ch != traits_type::eof())
+			_str.append((char*)&ch, 1);
-            _str.append((char*)&ch, 1);
+		return 1;
-        return 1;
+	}
-    }
 private:
-    std::string _str;
+	std::string _str;
 };
 
-class fast_oss:public std::ostream {
+class fast_oss:public std::ostream
+{
 public:
-    fast_oss():std::ostream(&_dev){}
+	fast_oss():std::ostream(&_dev) {}
-    ~fast_oss() = default;
+	~fast_oss() = default;
-    fast_oss(const fast_oss&) = delete;
+	fast_oss(const fast_oss& other):std::basic_ios<char>(), std::ostream(),_dev(other._dev) {}
-    fast_oss operator=(const fast_oss&) = delete;
+	fast_oss operator=(const fast_oss& other)
+	{
+		if(&other != this)
+			_dev = other._dev;
+		return *this;
+	}
 
+	const std::string& str_ref() const
+	{
+		return _dev.str_ref();
+	}
 
-    const std::string& str_ref() const
+	const std::string str() const
-    {        
+	{
-        return _dev.str_ref();
+		return _dev.str_ref();
-    }
+	}
 
-    const std::string str() const
+	void clear()
-    {     
+	{
-        return _dev.str_ref();
+		_dev.clear();
-    }
+	}
-
-    void clear()
-    {
-        _dev.clear();
-    }
 private:
-    str_devicebuf _dev;
+	str_devicebuf _dev;
 };
 }
 }

include/c11log/details/line_logger.h

@@ -1,30 +1,48 @@
 #pragma once
 
 #include "../level.h"
+#include "../logger.h"
 #include "fast_oss.h"
 
-namespace c11log {
+namespace c11log
+{
 class logger;
-namespace details {
+namespace details
+{
 
-class line_logger {
+class line_logger
+{
 public:
-    line_logger(logger* callback_logger, level::level_enum msg_level);
+	line_logger(logger* callback_logger, level::level_enum msg_level) {
-    line_logger(logger* callback_logger):_callback_logger(nullptr) {};
+		callback_logger->formatter_->format_header(callback_logger->logger_name_,
-    line_logger(const line_logger&){};
+		        msg_level,
-    ~line_logger();
+		        c11log::formatters::clock::now(),
+		        _oss);
+	}
+	line_logger(logger*):_callback_logger(nullptr) {};
+	line_logger(const line_logger& other):
+		_callback_logger(other._callback_logger),
+		_oss(other._oss),
+		_level(other._level) {};
+	line_logger& operator=(const line_logger&) = delete;
+	~line_logger() {
+		if (_callback_logger) {
+			_oss << '\n';
+			_callback_logger->log_it_(_oss.str_ref());
+		}
+	}
 
-    template<typename T>
+	template<typename T>
-    line_logger& operator<<(const T& msg)
+	line_logger& operator<<(const T& msg) {
-    {
+		if (_callback_logger)
-        if (_callback_logger)
+			_oss << msg;
-            _oss << msg;
+		return *this;
-        return *this;
+	}
-    }
 
 private:
-    logger* _callback_logger;
+	logger* _callback_logger;
-    details::fast_oss _oss;
+	details::fast_oss _oss;
+	level::level_enum _level;
 
 };
 } //Namespace details

include/c11log/logger.h

@@ -10,157 +10,155 @@
 
 #include "level.h"
 #include "sinks/base_sink.h"
-#include "details/line_logger.h"
 #include "details/factory.h"
 
+namespace c11log
+{
+namespace details
+{
+class line_logger;
+}
 
-
+class logger
-
+{
-namespace c11log {
-
-class logger {
 public:
 
-    typedef std::shared_ptr<sinks::base_sink>  sink_ptr_t;
+	typedef std::shared_ptr<sinks::base_sink>  sink_ptr_t;
-    typedef std::vector<sink_ptr_t> sinks_vector_t;
+	typedef std::vector<sink_ptr_t> sinks_vector_t;
 
-    explicit logger(const std::string& name) : logger_name_(name),
+	explicit logger(const std::string& name) : logger_name_(name),
-        formatter_(std::make_unique<formatters::default_formatter>())
+		formatter_(std::make_unique<formatters::default_formatter>()) {
-    {
+		atomic_level_.store(level::INFO);
-        atomic_level_.store(level::INFO);
+	}
-    }
 
-    ~logger() = default;
+	~logger() = default;
 
-    logger(const logger&) = delete;
+	logger(const logger&) = delete;
-    logger& operator=(const logger&) = delete;
+	logger& operator=(const logger&) = delete;
 
-    void set_name(const std::string& name);
+	void set_name(const std::string& name);
-    const std::string& get_name();
+	const std::string& get_name();
-    void add_sink(sink_ptr_t sink_ptr);
+	void add_sink(sink_ptr_t sink_ptr);
-    void remove_sink(sink_ptr_t sink_ptr);
+	void remove_sink(sink_ptr_t sink_ptr);
-    void set_formatter(std::unique_ptr<formatters::formatter> formatter);
+	void set_formatter(std::unique_ptr<formatters::formatter> formatter);
-    void set_level(c11log::level::level_enum level);
+	void set_level(c11log::level::level_enum level);
-    c11log::level::level_enum get_level() const;
+	c11log::level::level_enum get_level() const;
-    bool should_log(c11log::level::level_enum level) const;
+	bool should_log(c11log::level::level_enum level) const;
 
-    details::line_logger log(level::level_enum level);
+	details::line_logger log(level::level_enum level);
-    details::line_logger debug();
+	details::line_logger debug();
-    details::line_logger info();
+	details::line_logger info();
-    details::line_logger warn();
+	details::line_logger warn();
-    details::line_logger error();
+	details::line_logger error();
-    details::line_logger fatal();
+	details::line_logger fatal();
 
 private:
-    friend details::line_logger;
+	friend details::line_logger;
 
 
-    std::string logger_name_ = "";
+	std::string logger_name_ = "";
-    std::unique_ptr<c11log::formatters::formatter> formatter_;
+	std::unique_ptr<c11log::formatters::formatter> formatter_;
-    sinks_vector_t sinks_;
+	sinks_vector_t sinks_;
-    std::mutex mutex_;
+	std::mutex mutex_;
-    std::atomic_int atomic_level_;
+	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);
 }
 
+#include "details/line_logger.h"
 //
 // Logger inline impl
 //
 inline c11log::details::line_logger c11log::logger::log(c11log::level::level_enum msg_level)
 {
 
-    if (msg_level >= atomic_level_.load())
+	if (msg_level >= atomic_level_) {
-    {
+		return details::line_logger(this, msg_level);
-        std::lock_guard<std::mutex> lock(mutex_);
+	} else {
-        return details::line_logger(this, msg_level);
+		return details::line_logger(nullptr);
-    }
+	}
-    else
-    {
-        return details::line_logger(nullptr);
-    }
 
 }
 
 inline c11log::details::line_logger c11log::logger::debug()
 {
-    return log(c11log::level::DEBUG);
+	return log(c11log::level::DEBUG);
 }
 inline c11log::details::line_logger c11log::logger::info()
 {
-    return log(c11log::level::INFO);
+	return log(c11log::level::INFO);
 }
 inline c11log::details::line_logger c11log::logger::warn()
 {
-    return log(c11log::level::WARNING);
+	return log(c11log::level::WARNING);
 }
 inline c11log::details::line_logger c11log::logger::error()
 {
-    return log(level::ERROR);
+	return log(level::ERROR);
 }
 inline c11log::details::line_logger c11log::logger::fatal()
 {
-    return log(c11log::level::FATAL);
+	return log(c11log::level::FATAL);
 }
 
 inline void c11log::logger::set_name(const std::string& name)
 {
-    std::lock_guard<std::mutex> lock(mutex_);
+	std::lock_guard<std::mutex> lock(mutex_);
-    logger_name_ = name;
+	logger_name_ = name;
 }
 
 inline const std::string& c11log::logger::get_name()
 {
-    std::lock_guard<std::mutex> lock(mutex_);
+	std::lock_guard<std::mutex> lock(mutex_);
-    return logger_name_;
+	return logger_name_;
 }
 
 inline void c11log::logger::add_sink(sink_ptr_t sink_ptr)
 {
-    std::lock_guard<std::mutex> lock(mutex_);
+	std::lock_guard<std::mutex> lock(mutex_);
-    sinks_.push_back(sink_ptr);
+	sinks_.push_back(sink_ptr);
 }
 
 inline void c11log::logger::remove_sink(sink_ptr_t sink_ptr)
 {
-    std::lock_guard<std::mutex> lock(mutex_);
+	std::lock_guard<std::mutex> lock(mutex_);
-    sinks_.erase(std::remove(sinks_.begin(), sinks_.end(), sink_ptr), sinks_.end());
+	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_);
+	std::lock_guard<std::mutex> lock(mutex_);
-    formatter_ = std::move(formatter);
+	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)
 {
-    level::level_enum level = static_cast<level::level_enum>(atomic_level_.load());
+	level::level_enum level = static_cast<level::level_enum>(atomic_level_.load());
-    std::lock_guard<std::mutex> lock(mutex_);
+	std::lock_guard<std::mutex> lock(mutex_);
-    for (auto &sink : sinks_)
+	for (auto &sink : sinks_)
-        sink->log(msg, level);
+		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));
+	return *(c11log::details::factory::instance().get_logger(name));
 }

include/c11log/sinks/base_sink.h

@@ -37,7 +37,7 @@ protected:
 
 class null_sink:public base_sink {
 protected:
-    void sink_it_(const std::string& msg) override
+    void sink_it_(const std::string& ) override
     {}
 };
 }

include/stdafx.h

@@ -17,7 +17,8 @@
 
 
 #ifndef _MSC_VER
-namespace std {
+namespace std
+{
 template<typename T, typename ...Args>
 std::unique_ptr<T> make_unique( Args&& ...args )
 {

src/factory.cpp

@@ -19,5 +19,6 @@ c11log::details::factory::logger_ptr c11log::details::factory::get_logger(const
 c11log::details::factory & c11log::details::factory::instance()
 {
 	static c11log::details::factory instance;
+
 	return instance;
 }

src/line_logger.cpp

@@ -1,21 +0,0 @@
-#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::clock::now(),
-                _oss);
-    }
-}
-
-c11log::details::line_logger::~line_logger()
-{
-    if (_callback_logger) {
-        _oss << '\n';
-        _callback_logger->log_it_(_oss.str_ref());
-    }
-}

src/test.cpp

@@ -20,7 +20,7 @@ using std::string;
 using std::chrono::seconds;
 using Q = c11log::details::blocking_queue<string>;
 
-void pusher(Q* q)
+void pusher(Q* )
 {
 	auto &logger = c11log::get_logger("async");
 	while(active)
@@ -29,7 +29,6 @@ void pusher(Q* q)
 		++push_count;
 	}
 
-		
 }
 
 
@@ -88,13 +87,11 @@ int main(int argc, char* argv[])
     auto fsink = std::make_shared<c11log::sinks::rotating_file_sink>("newlog", "txt", 1024*1024*10 , 2);
     //auto fsink = std::make_shared<c11log::sinks::daily_file_sink>("daily", "txt");
 
-	async->add_sink(fsink);	
+	async->add_sink(null_sink);
 	auto &logger = c11log::get_logger("async");
 	logger.add_sink(async);
 
     testq(qsize, pushers, poppers);
 
-    
 }
 
-