Skip to content

S
spdlog
Commit 09cb4500 authored by gabime's avatar gabime
Browse files
Options

Added copy ctor and assignment to logger

parent 9d3aa5a2
Hide whitespace changes
Inline Side-by-side
Showing with 193 additions and 140 deletions
include/spdlog/logger-inl.h
View file @ 09cb4500
...@@ -11,180 +11,228 @@ ...@@ -11,180 +11,228 @@
#include "spdlog/details/pattern_formatter.h" #include "spdlog/details/pattern_formatter.h"
namespace spdlog { namespace spdlog {
// public methods
SPDLOG_INLINE void logger::log(source_loc loc, level::level_enum lvl, const char *msg)
{
if (!should_log(lvl))
{
return;
}
try // public methods
SPDLOG_INLINE logger::logger(const logger &other):
name_(other.name_),
sinks_(other.sinks_),
level_(other.level_.load(std::memory_order_relaxed)),
flush_level_(other.flush_level_.load(std::memory_order_relaxed)),
custom_err_handler_(other.custom_err_handler_)
{ {
details::log_msg log_msg(loc, string_view_t(name_), lvl, string_view_t(msg));
sink_it_(log_msg);
} }
catch (const std::exception &ex)
SPDLOG_INLINE logger::logger(logger &&other):
name_(std::move(other.name_)),
sinks_(std::move(other.sinks_)),
level_(other.level_.load(std::memory_order_relaxed)),
flush_level_(other.flush_level_.load(std::memory_order_relaxed)),
custom_err_handler_(std::move(other.custom_err_handler_))
{ {
err_handler_(ex.what());
} }
catch (...)
SPDLOG_INLINE logger &logger::operator=(logger other)
{ {
err_handler_("Unknown exception in logger"); this->swap(other);
return *this;
} }
}
SPDLOG_INLINE void logger::log(level::level_enum lvl, const char *msg) SPDLOG_INLINE void logger::swap(spdlog::logger &other)
{ {
log(source_loc{}, lvl, msg); name_.swap(other.name_);
} sinks_.swap(other.sinks_);
SPDLOG_INLINE bool logger::should_log(level::level_enum msg_level) const //swap level_
{ auto tmp = other.level_.load();
return msg_level >= level_.load(std::memory_order_relaxed); tmp = level_.exchange(tmp);
} other.level_.store(tmp);
SPDLOG_INLINE void logger::set_level(level::level_enum log_level) //swap flush level_
{ tmp = other.flush_level_.load();
level_.store(log_level); tmp = flush_level_.exchange(tmp);
} other.flush_level_.store(tmp);
SPDLOG_INLINE level::level_enum logger::default_level() custom_err_handler_.swap(other.custom_err_handler_);
{ }
return static_cast<level::level_enum>(SPDLOG_ACTIVE_LEVEL);
}
SPDLOG_INLINE level::level_enum logger::level() const
{
return static_cast<level::level_enum>(level_.load(std::memory_order_relaxed));
}
SPDLOG_INLINE const std::string &logger::name() const SPDLOG_INLINE void swap(logger &a, logger &b)
{ {
return name_; a.swap(b);
} }
// set formatting for the sinks in this logger. void logger::log(source_loc loc, level::level_enum lvl, const char *msg)
// each sink will get a seperate instance of the formatter object.
SPDLOG_INLINE void logger::set_formatter(std::unique_ptr<formatter> f)
{
for (auto it = sinks_.begin(); it != sinks_.end(); ++it)
{ {
if (std::next(it) == sinks_.end()) if (!should_log(lvl))
{ {
// last element - we can be move it. return;
(*it)->set_formatter(std::move(f));
} }
else
try
{
details::log_msg log_msg(loc, string_view_t(name_), lvl, string_view_t(msg));
sink_it_(log_msg);
}
catch (const std::exception &ex)
{ {
(*it)->set_formatter(f->clone()); err_handler_(ex.what());
} }
catch (...)
{
err_handler_("Unknown exception in logger");
}
}
SPDLOG_INLINE void logger::log(level::level_enum lvl, const char *msg)
{
log(source_loc{}, lvl, msg);
} }
}
SPDLOG_INLINE void logger::set_pattern(std::string pattern, pattern_time_type time_type) SPDLOG_INLINE bool logger::should_log(level::level_enum msg_level) const
{ {
auto new_formatter = details::make_unique<pattern_formatter>(std::move(pattern), time_type); return msg_level >= level_.load(std::memory_order_relaxed);
set_formatter(std::move(new_formatter)); }
}
// flush functions SPDLOG_INLINE void logger::set_level(level::level_enum log_level)
SPDLOG_INLINE void logger::flush()
{
try
{ {
flush_(); level_.store(log_level);
} }
catch (const std::exception &ex)
SPDLOG_INLINE level::level_enum logger::default_level()
{ {
err_handler_(ex.what()); return static_cast<level::level_enum>(SPDLOG_ACTIVE_LEVEL);
} }
catch (...)
SPDLOG_INLINE level::level_enum logger::level() const
{ {
err_handler_("Unknown exception in logger"); return static_cast<level::level_enum>(level_.load(std::memory_order_relaxed));
} }
}
SPDLOG_INLINE void logger::flush_on(level::level_enum log_level) SPDLOG_INLINE const std::string &logger::name() const
{ {
flush_level_.store(log_level); return name_;
} }
SPDLOG_INLINE level::level_enum logger::flush_level() const // set formatting for the sinks in this logger.
{ // each sink will get a seperate instance of the formatter object.
return static_cast<level::level_enum>(flush_level_.load(std::memory_order_relaxed)); SPDLOG_INLINE void logger::set_formatter(std::unique_ptr<formatter> f)
} {
for (auto it = sinks_.begin(); it != sinks_.end(); ++it)
{
if (std::next(it) == sinks_.end())
{
// last element - we can be move it.
(*it)->set_formatter(std::move(f));
}
else
{
(*it)->set_formatter(f->clone());
}
}
}
// sinks SPDLOG_INLINE void logger::set_pattern(std::string pattern, pattern_time_type time_type)
SPDLOG_INLINE const std::vector<sink_ptr> &logger::sinks() const {
{ auto new_formatter = details::make_unique<pattern_formatter>(std::move(pattern), time_type);
return sinks_; set_formatter(std::move(new_formatter));
} }
SPDLOG_INLINE std::vector<sink_ptr> &logger::sinks() // flush functions
{ SPDLOG_INLINE void logger::flush()
return sinks_; {
} try
{
// error handler flush_();
SPDLOG_INLINE void logger::set_error_handler(err_handler handler) }
{ catch (const std::exception &ex)
custom_err_handler_ = handler; {
} err_handler_(ex.what());
}
// create new logger with same sinks and configuration. catch (...)
SPDLOG_INLINE std::shared_ptr<logger> logger::clone(std::string logger_name)
{
auto cloned = std::make_shared<logger>(std::move(logger_name), sinks_.begin(), sinks_.end());
cloned->set_level(this->level());
cloned->flush_on(this->flush_level());
cloned->set_error_handler(this->custom_err_handler_);
return cloned;
}
// protected methods
SPDLOG_INLINE void logger::sink_it_(details::log_msg &msg)
{
for (auto &sink : sinks_)
{
if (sink->should_log(msg.level))
{ {
sink->log(msg); err_handler_("Unknown exception in logger");
} }
} }
if (should_flush_(msg)) SPDLOG_INLINE void logger::flush_on(level::level_enum log_level)
{
flush_level_.store(log_level);
}
SPDLOG_INLINE level::level_enum logger::flush_level() const
{
return static_cast<level::level_enum>(flush_level_.load(std::memory_order_relaxed));
}
// sinks
SPDLOG_INLINE const std::vector<sink_ptr> &logger::sinks() const
{
return sinks_;
}
SPDLOG_INLINE std::vector<sink_ptr> &logger::sinks()
{
return sinks_;
}
// error handler
SPDLOG_INLINE void logger::set_error_handler(err_handler handler)
{
custom_err_handler_ = handler;
}
// create new logger with same sinks and configuration.
SPDLOG_INLINE std::shared_ptr<logger> logger::clone(std::string logger_name)
{ {
flush_(); auto cloned = std::make_shared<logger>(*this);
cloned->name_ = std::move(logger_name);
return cloned;
} }
}
SPDLOG_INLINE void logger::flush_() // protected methods
{ SPDLOG_INLINE void logger::sink_it_(details::log_msg &msg)
for (auto &sink : sinks_)
{ {
sink->flush(); for (auto &sink : sinks_)
{
if (sink->should_log(msg.level))
{
sink->log(msg);
}
}
if (should_flush_(msg))
{
flush_();
}
} }
}
SPDLOG_INLINE bool logger::should_flush_(const details::log_msg &msg) SPDLOG_INLINE void logger::flush_()
{ {
auto flush_level = flush_level_.load(std::memory_order_relaxed); for (auto &sink : sinks_)
return (msg.level >= flush_level) && (msg.level != level::off); {
} sink->flush();
}
}
SPDLOG_INLINE void logger::err_handler_(const std::string &msg) SPDLOG_INLINE bool logger::should_flush_(const details::log_msg &msg)
{
if (custom_err_handler_)
{ {
custom_err_handler_(msg); auto flush_level = flush_level_.load(std::memory_order_relaxed);
return (msg.level >= flush_level) && (msg.level != level::off);
} }
else
SPDLOG_INLINE void logger::err_handler_(const std::string &msg)
{ {
auto tm_time = details::os::localtime(); if (custom_err_handler_)
char date_buf[64]; {
std::strftime(date_buf, sizeof(date_buf), "%Y-%m-%d %H:%M:%S", &tm_time); custom_err_handler_(msg);
fmt::print(stderr, "[*** LOG ERROR ***] [{}] [{}] {}\n", date_buf, name(), msg); }
else
{
auto tm_time = details::os::localtime();
char date_buf[64];
std::strftime(date_buf, sizeof(date_buf), "%Y-%m-%d %H:%M:%S", &tm_time);
fmt::print(stderr, "[*** LOG ERROR ***] [{}] [{}] {}\n", date_buf, name(), msg);
}
} }
}
} // namespace spdlog } // namespace spdlog
\ No newline at end of file
include/spdlog/logger.h
View file @ 09cb4500
...@@ -56,8 +56,11 @@ public: ...@@ -56,8 +56,11 @@ public:
virtual ~logger() = default; virtual ~logger() = default;
logger(const logger &) = delete; logger(const logger &other);
logger &operator=(const logger &) = delete; logger(logger &&other);
logger &operator=(logger other);
void swap(spdlog::logger &other);
template<typename... Args> template<typename... Args>
void log(source_loc loc, level::level_enum lvl, const char *fmt, const Args &... args) void log(source_loc loc, level::level_enum lvl, const char *fmt, const Args &... args)
...@@ -328,23 +331,26 @@ public: ...@@ -328,23 +331,26 @@ public:
virtual std::shared_ptr<logger> clone(std::string logger_name); virtual std::shared_ptr<logger> clone(std::string logger_name);
protected: protected:
virtual void sink_it_(details::log_msg &msg); std::string name_;
std::vector<sink_ptr> sinks_;
spdlog::level_t level_{spdlog::logger::default_level()};
spdlog::level_t flush_level_{level::off};
err_handler custom_err_handler_{nullptr};
virtual void sink_it_(details::log_msg &msg);
virtual void flush_(); virtual void flush_();
bool should_flush_(const details::log_msg &msg); bool should_flush_(const details::log_msg &msg);
// default error handler. // default error handler.
// print the error to stderr with the max rate of 1 message/minute. // print the error to stderr with the max rate of 1 message/minute.
void err_handler_(const std::string &msg); void err_handler_(const std::string &msg);
const std::string name_;
std::vector<sink_ptr> sinks_;
spdlog::level_t level_{spdlog::logger::default_level()};
spdlog::level_t flush_level_{level::off};
err_handler custom_err_handler_{nullptr};
}; };
void swap(logger& a, logger& b);
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
#include "logger-inl.h" #include "logger-inl.h"
#endif #endif
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment