Mirror/spdlog
1
0
Fork 0
mirror of https://github.com/gabime/spdlog.git synced 2025-09-29 09:59:33 +08:00
Code Issues Packages Projects Releases Wiki Activity

logger refactoring to init lists and mutex remove

Browse Source
This commit is contained in:
gabime
2014-03-08 16:18:57 +02:00
parent 0caa2dd1e8
commit a6d1ea77ee
8 changed files with 106 additions and 118 deletions
Download Patch File Download Diff File Expand all files Collapse all files

75
include/c11log/logger.h
View File

@@ -12,10 +12,12 @@
#include "sinks/base_sink.h"
#include "details/factory.h"
//Thread safe, fast logger.
//All initialization is done in ctor only, so we get away lot of locking
namespace c11log
{
namespace details
{
class line_logger;
@@ -26,33 +28,43 @@ class logger
{
public:
typedef std::shared_ptr<sinks::base_sink> sink_ptr_t;
typedef std::vector<sink_ptr_t> sinks_vector_t;
using sink_ptr = std::shared_ptr<sinks::base_sink>;
using formatter_ptr = std::shared_ptr<c11log::formatters::formatter>;
using sinks_vector_t = std::vector<sink_ptr>;
using sinks_init_list = std::initializer_list<sink_ptr>;
explicit logger(const std::string& name) :
logger(const std::string& name, formatter_ptr f, sinks_init_list sinks_list) :
_logger_name(name),
_formatter(new formatters::default_formatter()),
_sinks(),
_mutex() {
_formatter(f),
_sinks(sinks_list) {
//Seems that vs2013 doesnt support atomic member initialization in ctor, so its done here
_atomic_level = level::INFO;
}
logger(const std::string& name, sinks_init_list sinks_list) :
logger(name, std::make_shared<formatters::default_formatter>(), sinks_list) {}
logger(sinks_init_list sinks_list) :
logger("", std::make_shared<formatters::default_formatter>(), sinks_list) {}
~logger() = default;
//Non copybale in anyway
logger(const logger&) = delete;
logger(logger&&) = delete;
logger& operator=(const logger&) = delete;
logger& operator=(logger&&) = delete;
void set_name(const std::string& name);
const std::string& get_name();
void add_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_level(c11log::level::level_enum level);
void set_level(c11log::level::level_enum);
c11log::level::level_enum get_level() const;
bool should_log(c11log::level::level_enum level) const;
details::line_logger log(level::level_enum level);
const std::string& get_name() const;
bool should_log(c11log::level::level_enum) const;
details::line_logger log(level::level_enum);
details::line_logger debug();
details::line_logger info();
details::line_logger warn();
@@ -63,9 +75,8 @@ private:
friend details::line_logger;
std::string _logger_name = "";
std::unique_ptr<c11log::formatters::formatter> _formatter;
formatter_ptr _formatter;
sinks_vector_t _sinks;
std::mutex _mutex;
std::atomic_int _atomic_level;
void _log_it(const std::string& msg, const level::level_enum level);
@@ -107,35 +118,12 @@ inline c11log::details::line_logger c11log::logger::fatal()
return log(c11log::level::FATAL);
}
inline void c11log::logger::set_name(const std::string& name)
{
std::lock_guard<std::mutex> lock(_mutex);
_logger_name = name;
}
inline const std::string& c11log::logger::get_name()
inline const std::string& c11log::logger::get_name() const
{
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);
}
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());
}
inline void c11log::logger::set_formatter(std::unique_ptr<formatters::formatter> formatter)
{
std::lock_guard<std::mutex> lock(_mutex);
_formatter = std::move(formatter);
}
inline void c11log::logger::set_level(c11log::level::level_enum level)
{
@@ -143,7 +131,7 @@ inline void c11log::logger::set_level(c11log::level::level_enum level)
}
inline c11log::level::level_enum c11log::logger::get_level() const
{
{
return static_cast<c11log::level::level_enum>(_atomic_level.load());
}
@@ -153,14 +141,13 @@ inline bool c11log::logger::should_log(c11log::level::level_enum level) const
}
inline void c11log::logger::_log_it(const std::string& msg, const level::level_enum level)
{
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));
}