danny
/
spdlog
mirror of https://github.com/gabime/spdlog.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Ref-qualified memfns and added some move semantics

Browse Source
pull/1919/head
Jackson 4 years ago
parent c5abaeddca
commit 619311922a
19 changed files with 130 additions and 110 deletions
Show Stats Download Patch File Download Diff File

2
include/spdlog/async_logger-inl.h
Unescape Escape View File

@ -84,7 +84,7 @@ SPDLOG_INLINE void spdlog::async_logger::backend_flush_()
} }
} }
SPDLOG_INLINE std::shared_ptr<spdlog::logger> spdlog::async_logger::clone(std::string new_name) SPDLOG_INLINE std::shared_ptr<spdlog::logger> spdlog::async_logger::clone(std::string new_name) const&
{ {
auto cloned = std::make_shared<spdlog::async_logger>(*this); auto cloned = std::make_shared<spdlog::async_logger>(*this);
cloned->name_ = std::move(new_name); cloned->name_ = std::move(new_name);

2
include/spdlog/async_logger.h
Unescape Escape View File

@ -49,7 +49,7 @@ public:
async_logger(std::string logger_name, sink_ptr single_sink, std::weak_ptr<details::thread_pool> tp, async_logger(std::string logger_name, sink_ptr single_sink, std::weak_ptr<details::thread_pool> tp,
async_overflow_policy overflow_policy = async_overflow_policy::block); async_overflow_policy overflow_policy = async_overflow_policy::block);
std::shared_ptr<logger> clone(std::string new_name) override; std::shared_ptr<logger> clone(std::string new_name) const & override;
protected: protected:
void sink_it_(const details::log_msg &msg) override; void sink_it_(const details::log_msg &msg) override;

2
include/spdlog/details/backtracer-inl.h
Unescape Escape View File

@ -22,7 +22,7 @@ SPDLOG_INLINE backtracer::backtracer(backtracer &&other) SPDLOG_NOEXCEPT
messages_ = std::move(other.messages_); messages_ = std::move(other.messages_);
} }
SPDLOG_INLINE backtracer &backtracer::operator=(backtracer other) SPDLOG_INLINE backtracer &backtracer::operator=(backtracer other) &
{ {
std::lock_guard<std::mutex> lock(mutex_); std::lock_guard<std::mutex> lock(mutex_);
enabled_ = other.enabled(); enabled_ = other.enabled();

3
include/spdlog/details/backtracer.h
Unescape Escape View File

@ -26,7 +26,7 @@ public:
backtracer(const backtracer &other); backtracer(const backtracer &other);
backtracer(backtracer &&other) SPDLOG_NOEXCEPT; backtracer(backtracer &&other) SPDLOG_NOEXCEPT;
backtracer &operator=(backtracer other); backtracer &operator=(backtracer other) &;
void enable(size_t size); void enable(size_t size);
void disable(); void disable();
@ -43,4 +43,3 @@ public:
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
#include "backtracer-inl.h" #include "backtracer-inl.h"
#endif #endif

17
include/spdlog/details/circular_q.h
Unescape Escape View File

@ -30,7 +30,7 @@ public:
{} {}
circular_q(const circular_q &) = default; circular_q(const circular_q &) = default;
circular_q &operator=(const circular_q &) = default; circular_q &operator=(const circular_q &) & = default;
// move cannot be default, // move cannot be default,
// since we need to reset head_, tail_, etc to zero in the moved object // since we need to reset head_, tail_, etc to zero in the moved object
@ -39,14 +39,14 @@ public:
copy_moveable(std::move(other)); copy_moveable(std::move(other));
} }
circular_q &operator=(circular_q &&other) SPDLOG_NOEXCEPT circular_q &operator=(circular_q &&other) & SPDLOG_NOEXCEPT
{ {
copy_moveable(std::move(other)); copy_moveable(std::move(other));
return *this; return *this;
} }
// push back, overrun (oldest) item if no room left // push back, overrun (oldest) item if no room left
void push_back(T &&item) void push_back(T &&item) &
{ {
if (max_items_ > 0) if (max_items_ > 0)
{ {
@ -63,16 +63,21 @@ public:
// Return reference to the front item. // Return reference to the front item.
// If there are no elements in the container, the behavior is undefined. // If there are no elements in the container, the behavior is undefined.
const T &front() const const T &front() const &
{ {
return v_[head_]; return v_[head_];
} }
T &front() T &front() &
{ {
return v_[head_]; return v_[head_];
} }
T front() &&
{
return std::move(v_[head_]);
}
// Return number of elements actually stored // Return number of elements actually stored
size_t size() const size_t size() const
{ {
@ -96,7 +101,7 @@ public:
// Pop item from front. // Pop item from front.
// If there are no elements in the container, the behavior is undefined. // If there are no elements in the container, the behavior is undefined.
void pop_front() void pop_front() &
{ {
head_ = (head_ + 1) % max_items_; head_ = (head_ + 1) % max_items_;
} }

8
include/spdlog/details/log_msg_buffer-inl.h
Unescape Escape View File

@ -26,14 +26,12 @@ SPDLOG_INLINE log_msg_buffer::log_msg_buffer(const log_msg_buffer &other)
update_string_views(); update_string_views();
} }
SPDLOG_INLINE log_msg_buffer::log_msg_buffer(log_msg_buffer &&other) SPDLOG_NOEXCEPT SPDLOG_INLINE log_msg_buffer::log_msg_buffer(log_msg_buffer &&other) SPDLOG_NOEXCEPT : log_msg{other}, buffer{std::move(other.buffer)}
: log_msg{other}
, buffer{std::move(other.buffer)}
{ {
update_string_views(); update_string_views();
} }
SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(const log_msg_buffer &other) SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(const log_msg_buffer &other) &
{ {
log_msg::operator=(other); log_msg::operator=(other);
buffer.clear(); buffer.clear();
@ -42,7 +40,7 @@ SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(const log_msg_buffer &ot
return *this; return *this;
} }
SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(log_msg_buffer &&other) SPDLOG_NOEXCEPT SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(log_msg_buffer &&other) & SPDLOG_NOEXCEPT
{ {
log_msg::operator=(other); log_msg::operator=(other);
buffer = std::move(other.buffer); buffer = std::move(other.buffer);

4
include/spdlog/details/log_msg_buffer.h
Unescape Escape View File

@ -21,8 +21,8 @@ public:
explicit log_msg_buffer(const log_msg &orig_msg); explicit log_msg_buffer(const log_msg &orig_msg);
log_msg_buffer(const log_msg_buffer &other); log_msg_buffer(const log_msg_buffer &other);
log_msg_buffer(log_msg_buffer &&other) SPDLOG_NOEXCEPT; log_msg_buffer(log_msg_buffer &&other) SPDLOG_NOEXCEPT;
log_msg_buffer &operator=(const log_msg_buffer &other); log_msg_buffer &operator=(const log_msg_buffer &other) &;
log_msg_buffer &operator=(log_msg_buffer &&other) SPDLOG_NOEXCEPT; log_msg_buffer &operator=(log_msg_buffer &&other) & SPDLOG_NOEXCEPT;
}; };
} // namespace details } // namespace details

14
include/spdlog/details/mpmc_blocking_q.h
Unescape Escape View File

@ -29,7 +29,7 @@ public:
#ifndef __MINGW32__ #ifndef __MINGW32__
// try to enqueue and block if no room left // try to enqueue and block if no room left
void enqueue(T &&item) void enqueue(T &&item) &
{ {
{ {
std::unique_lock<std::mutex> lock(queue_mutex_); std::unique_lock<std::mutex> lock(queue_mutex_);
@ -40,7 +40,7 @@ public:
} }
// enqueue immediately. overrun oldest message in the queue if no room left. // enqueue immediately. overrun oldest message in the queue if no room left.
void enqueue_nowait(T &&item) void enqueue_nowait(T &&item) &
{ {
{ {
std::unique_lock<std::mutex> lock(queue_mutex_); std::unique_lock<std::mutex> lock(queue_mutex_);
@ -71,7 +71,7 @@ public:
// so release the mutex at the very end each function. // so release the mutex at the very end each function.
// try to enqueue and block if no room left // try to enqueue and block if no room left
void enqueue(T &&item) void enqueue(T &&item) &
{ {
std::unique_lock<std::mutex> lock(queue_mutex_); std::unique_lock<std::mutex> lock(queue_mutex_);
pop_cv_.wait(lock, [this] { return !this->q_.full(); }); pop_cv_.wait(lock, [this] { return !this->q_.full(); });
@ -80,7 +80,7 @@ public:
} }
// enqueue immediately. overrun oldest message in the queue if no room left. // enqueue immediately. overrun oldest message in the queue if no room left.
void enqueue_nowait(T &&item) void enqueue_nowait(T &&item) &
{ {
std::unique_lock<std::mutex> lock(queue_mutex_); std::unique_lock<std::mutex> lock(queue_mutex_);
q_.push_back(std::move(item)); q_.push_back(std::move(item));
@ -104,20 +104,20 @@ public:
#endif #endif
size_t overrun_counter() size_t overrun_counter() const
{ {
std::unique_lock<std::mutex> lock(queue_mutex_); std::unique_lock<std::mutex> lock(queue_mutex_);
return q_.overrun_counter(); return q_.overrun_counter();
} }
size_t size() size_t size() const
{ {
std::unique_lock<std::mutex> lock(queue_mutex_); std::unique_lock<std::mutex> lock(queue_mutex_);
return q_.size(); return q_.size();
} }
private: private:
std::mutex queue_mutex_; mutable std::mutex queue_mutex_;
std::condition_variable push_cv_; std::condition_variable push_cv_;
std::condition_variable pop_cv_; std::condition_variable pop_cv_;
spdlog::details::circular_q<T> q_; spdlog::details::circular_q<T> q_;

28
include/spdlog/details/registry-inl.h
Unescape Escape View File

@ -51,13 +51,13 @@ SPDLOG_INLINE registry::registry()
SPDLOG_INLINE registry::~registry() = default; SPDLOG_INLINE registry::~registry() = default;
SPDLOG_INLINE void registry::register_logger(std::shared_ptr<logger> new_logger) SPDLOG_INLINE void registry::register_logger(std::shared_ptr<logger> new_logger) &
{ {
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
register_logger_(std::move(new_logger)); register_logger_(std::move(new_logger));
} }
SPDLOG_INLINE void registry::initialize_logger(std::shared_ptr<logger> new_logger) SPDLOG_INLINE void registry::initialize_logger(std::shared_ptr<logger> new_logger) &
{ {
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
new_logger->set_formatter(formatter_->clone()); new_logger->set_formatter(formatter_->clone());
@ -109,7 +109,7 @@ SPDLOG_INLINE logger *registry::get_default_raw()
// set default logger. // set default logger.
// default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map. // default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map.
SPDLOG_INLINE void registry::set_default_logger(std::shared_ptr<logger> new_default_logger) SPDLOG_INLINE void registry::set_default_logger(std::shared_ptr<logger> new_default_logger) &
{ {
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
// remove previous default logger from the map // remove previous default logger from the map
@ -124,7 +124,7 @@ SPDLOG_INLINE void registry::set_default_logger(std::shared_ptr<logger> new_defa
default_logger_ = std::move(new_default_logger); default_logger_ = std::move(new_default_logger);
} }
SPDLOG_INLINE void registry::set_tp(std::shared_ptr<thread_pool> tp) SPDLOG_INLINE void registry::set_tp(std::shared_ptr<thread_pool> tp) &
{ {
std::lock_guard<std::recursive_mutex> lock(tp_mutex_); std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
tp_ = std::move(tp); tp_ = std::move(tp);
@ -137,7 +137,7 @@ SPDLOG_INLINE std::shared_ptr<thread_pool> registry::get_tp()
} }
// Set global formatter. Each sink in each logger will get a clone of this object // Set global formatter. Each sink in each logger will get a clone of this object
SPDLOG_INLINE void registry::set_formatter(std::unique_ptr<formatter> formatter) SPDLOG_INLINE void registry::set_formatter(std::unique_ptr<formatter> formatter) &
{ {
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
formatter_ = std::move(formatter); formatter_ = std::move(formatter);
@ -147,7 +147,7 @@ SPDLOG_INLINE void registry::set_formatter(std::unique_ptr<formatter> formatter)
} }
} }
SPDLOG_INLINE void registry::enable_backtrace(size_t n_messages) SPDLOG_INLINE void registry::enable_backtrace(size_t n_messages) &
{ {
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
backtrace_n_messages_ = n_messages; backtrace_n_messages_ = n_messages;
@ -158,7 +158,7 @@ SPDLOG_INLINE void registry::enable_backtrace(size_t n_messages)
} }
} }
SPDLOG_INLINE void registry::disable_backtrace() SPDLOG_INLINE void registry::disable_backtrace() &
{ {
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
backtrace_n_messages_ = 0; backtrace_n_messages_ = 0;
@ -168,7 +168,7 @@ SPDLOG_INLINE void registry::disable_backtrace()
} }
} }
SPDLOG_INLINE void registry::set_level(level::level_enum log_level) SPDLOG_INLINE void registry::set_level(level::level_enum log_level) &
{ {
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
for (auto &l : loggers_) for (auto &l : loggers_)
@ -178,7 +178,7 @@ SPDLOG_INLINE void registry::set_level(level::level_enum log_level)
global_log_level_ = log_level; global_log_level_ = log_level;
} }
SPDLOG_INLINE void registry::flush_on(level::level_enum log_level) SPDLOG_INLINE void registry::flush_on(level::level_enum log_level) &
{ {
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
for (auto &l : loggers_) for (auto &l : loggers_)
@ -188,14 +188,14 @@ SPDLOG_INLINE void registry::flush_on(level::level_enum log_level)
flush_level_ = log_level; flush_level_ = log_level;
} }
SPDLOG_INLINE void registry::flush_every(std::chrono::seconds interval) SPDLOG_INLINE void registry::flush_every(std::chrono::seconds interval) &
{ {
std::lock_guard<std::mutex> lock(flusher_mutex_); std::lock_guard<std::mutex> lock(flusher_mutex_);
auto clbk = [this]() { this->flush_all(); }; auto clbk = [this]() { this->flush_all(); };
periodic_flusher_ = details::make_unique<periodic_worker>(clbk, interval); periodic_flusher_ = details::make_unique<periodic_worker>(clbk, interval);
} }
SPDLOG_INLINE void registry::set_error_handler(void (*handler)(const std::string &msg)) SPDLOG_INLINE void registry::set_error_handler(void (*handler)(const std::string &msg)) &
{ {
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
for (auto &l : loggers_) for (auto &l : loggers_)
@ -261,13 +261,13 @@ SPDLOG_INLINE std::recursive_mutex &registry::tp_mutex()
return tp_mutex_; return tp_mutex_;
} }
SPDLOG_INLINE void registry::set_automatic_registration(bool automatic_registration) SPDLOG_INLINE void registry::set_automatic_registration(bool automatic_registration) &
{ {
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
automatic_registration_ = automatic_registration; automatic_registration_ = automatic_registration;
} }
SPDLOG_INLINE void registry::set_levels(log_levels levels, level::level_enum *global_level) SPDLOG_INLINE void registry::set_levels(log_levels levels, level::level_enum *global_level) &
{ {
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
log_levels_ = std::move(levels); log_levels_ = std::move(levels);
@ -302,7 +302,7 @@ SPDLOG_INLINE void registry::throw_if_exists_(const std::string &logger_name)
} }
} }
SPDLOG_INLINE void registry::register_logger_(std::shared_ptr<logger> new_logger) SPDLOG_INLINE void registry::register_logger_(std::shared_ptr<logger> new_logger) &
{ {
auto logger_name = new_logger->name(); auto logger_name = new_logger->name();
throw_if_exists_(logger_name); throw_if_exists_(logger_name);

29
include/spdlog/details/registry.h
Unescape Escape View File

@ -31,8 +31,8 @@ public:
registry(const registry &) = delete; registry(const registry &) = delete;
registry &operator=(const registry &) = delete; registry &operator=(const registry &) = delete;
void register_logger(std::shared_ptr<logger> new_logger); void register_logger(std::shared_ptr<logger> new_logger) &;
void initialize_logger(std::shared_ptr<logger> new_logger); void initialize_logger(std::shared_ptr<logger> new_logger) &;
std::shared_ptr<logger> get(const std::string &logger_name); std::shared_ptr<logger> get(const std::string &logger_name);
std::shared_ptr<logger> default_logger(); std::shared_ptr<logger> default_logger();
@ -44,26 +44,26 @@ public:
// set default logger. // set default logger.
// default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map. // default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map.
void set_default_logger(std::shared_ptr<logger> new_default_logger); void set_default_logger(std::shared_ptr<logger> new_default_logger) &;
void set_tp(std::shared_ptr<thread_pool> tp); void set_tp(std::shared_ptr<thread_pool> tp) &;
std::shared_ptr<thread_pool> get_tp(); std::shared_ptr<thread_pool> get_tp();
// Set global formatter. Each sink in each logger will get a clone of this object // Set global formatter. Each sink in each logger will get a clone of this object
void set_formatter(std::unique_ptr<formatter> formatter); void set_formatter(std::unique_ptr<formatter> formatter) &;
void enable_backtrace(size_t n_messages); void enable_backtrace(size_t n_messages) &;
void disable_backtrace(); void disable_backtrace() &;
void set_level(level::level_enum log_level); void set_level(level::level_enum log_level) &;
void flush_on(level::level_enum log_level); void flush_on(level::level_enum log_level) &;
void flush_every(std::chrono::seconds interval); void flush_every(std::chrono::seconds interval) &;
void set_error_handler(void (*handler)(const std::string &msg)); void set_error_handler(void (*handler)(const std::string &msg)) &;
void apply_all(const std::function<void(const std::shared_ptr<logger>)> &fun); void apply_all(const std::function<void(const std::shared_ptr<logger>)> &fun);
@ -78,10 +78,10 @@ public:
std::recursive_mutex &tp_mutex(); std::recursive_mutex &tp_mutex();
void set_automatic_registration(bool automatic_registration); void set_automatic_registration(bool automatic_registration) &;
// set levels for all existing/future loggers. global_level can be null if should not set. // set levels for all existing/future loggers. global_level can be null if should not set.
void set_levels(log_levels levels, level::level_enum *global_level); void set_levels(log_levels levels, level::level_enum *global_level) &;
static registry &instance(); static registry &instance();
@ -90,8 +90,9 @@ private:
~registry(); ~registry();
void throw_if_exists_(const std::string &logger_name); void throw_if_exists_(const std::string &logger_name);
void register_logger_(std::shared_ptr<logger> new_logger); void register_logger_(std::shared_ptr<logger> new_logger) &;
bool set_level_from_cfg_(logger *logger); bool set_level_from_cfg_(logger *logger);
std::mutex logger_map_mutex_, flusher_mutex_; std::mutex logger_map_mutex_, flusher_mutex_;
std::recursive_mutex tp_mutex_; std::recursive_mutex tp_mutex_;
std::unordered_map<std::string, std::shared_ptr<logger>> loggers_; std::unordered_map<std::string, std::shared_ptr<logger>> loggers_;

4
include/spdlog/details/tcp_client-windows.h
Unescape Escape View File

@ -64,7 +64,7 @@ public:
return socket_ != INVALID_SOCKET; return socket_ != INVALID_SOCKET;
} }
void close() void close() &
{ {
::closesocket(socket_); ::closesocket(socket_);
socket_ = INVALID_SOCKET; socket_ = INVALID_SOCKET;
@ -82,7 +82,7 @@ public:
} }
// try to connect or throw on failure // try to connect or throw on failure
void connect(const std::string &host, int port) void connect(const std::string &host, int port) &
{ {
// initialize winsock if needed // initialize winsock if needed
if (!winsock_initialized_()) if (!winsock_initialized_())

4
include/spdlog/details/tcp_client.h
Unescape Escape View File

@ -31,7 +31,7 @@ public:
return socket_ != -1; return socket_ != -1;
} }
void close() void close() &
{ {
if (is_connected()) if (is_connected())
{ {
@ -51,7 +51,7 @@ public:
} }
// try to connect or throw on failure // try to connect or throw on failure
void connect(const std::string &host, int port) void connect(const std::string &host, int port) &
{ {
close(); close();
struct addrinfo hints struct addrinfo hints

10
include/spdlog/details/thread_pool-inl.h
Unescape Escape View File

@ -63,17 +63,17 @@ void SPDLOG_INLINE thread_pool::post_flush(async_logger_ptr &&worker_ptr, async_
post_async_msg_(async_msg(std::move(worker_ptr), async_msg_type::flush), overflow_policy); post_async_msg_(async_msg(std::move(worker_ptr), async_msg_type::flush), overflow_policy);
} }
size_t SPDLOG_INLINE thread_pool::overrun_counter() size_t SPDLOG_INLINE thread_pool::overrun_counter() const
{ {
return q_.overrun_counter(); return q_.overrun_counter();
} }
size_t SPDLOG_INLINE thread_pool::queue_size() size_t SPDLOG_INLINE thread_pool::queue_size() const
{ {
return q_.size(); return q_.size();
} }
void SPDLOG_INLINE thread_pool::post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy) void SPDLOG_INLINE thread_pool::post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy) &
{ {
if (overflow_policy == async_overflow_policy::block) if (overflow_policy == async_overflow_policy::block)
{ {
@ -85,7 +85,7 @@ void SPDLOG_INLINE thread_pool::post_async_msg_(async_msg &&new_msg, async_overf
} }
} }
void SPDLOG_INLINE thread_pool::worker_loop_() void SPDLOG_INLINE thread_pool::worker_loop_() &
{ {
while (process_next_msg_()) {} while (process_next_msg_()) {}
} }
@ -93,7 +93,7 @@ void SPDLOG_INLINE thread_pool::worker_loop_()
// process next message in the queue // process next message in the queue
// return true if this thread should still be active (while no terminate msg // return true if this thread should still be active (while no terminate msg
// was received) // was received)
bool SPDLOG_INLINE thread_pool::process_next_msg_() bool SPDLOG_INLINE thread_pool::process_next_msg_() &
{ {
async_msg incoming_async_msg; async_msg incoming_async_msg;
bool dequeued = q_.dequeue_for(incoming_async_msg, std::chrono::seconds(10)); bool dequeued = q_.dequeue_for(incoming_async_msg, std::chrono::seconds(10));

14
include/spdlog/details/thread_pool.h
Unescape Escape View File

@ -49,7 +49,7 @@ struct async_msg : log_msg_buffer
, worker_ptr(std::move(other.worker_ptr)) , worker_ptr(std::move(other.worker_ptr))
{} {}
async_msg &operator=(async_msg &&other) async_msg &operator=(async_msg &&other) &
{ {
*static_cast<log_msg_buffer *>(this) = std::move(other); *static_cast<log_msg_buffer *>(this) = std::move(other);
msg_type = other.msg_type; msg_type = other.msg_type;
@ -58,7 +58,7 @@ struct async_msg : log_msg_buffer
} }
#else // (_MSC_VER) && _MSC_VER <= 1800 #else // (_MSC_VER) && _MSC_VER <= 1800
async_msg(async_msg &&) = default; async_msg(async_msg &&) = default;
async_msg &operator=(async_msg &&) = default; async_msg &operator=(async_msg &&) & = default;
#endif #endif
// construct from log_msg with given type // construct from log_msg with given type
@ -96,21 +96,21 @@ public:
void post_log(async_logger_ptr &&worker_ptr, const details::log_msg &msg, async_overflow_policy overflow_policy); void post_log(async_logger_ptr &&worker_ptr, const details::log_msg &msg, async_overflow_policy overflow_policy);
void post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy); void post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy);
size_t overrun_counter(); size_t overrun_counter() const;
size_t queue_size(); size_t queue_size() const;
private: private:
q_type q_; q_type q_;
std::vector<std::thread> threads_; std::vector<std::thread> threads_;
void post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy); void post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy) &;
void worker_loop_(); void worker_loop_() &;
// process next message in the queue // process next message in the queue
// return true if this thread should still be active (while no terminate msg // return true if this thread should still be active (while no terminate msg
// was received) // was received)
bool process_next_msg_(); bool process_next_msg_() &;
}; };
} // namespace details } // namespace details

39
include/spdlog/logger-inl.h
Unescape Escape View File

@ -34,13 +34,13 @@ SPDLOG_INLINE logger::logger(logger &&other) SPDLOG_NOEXCEPT : name_(std::move(o
{} {}
SPDLOG_INLINE logger &logger::operator=(logger other) SPDLOG_NOEXCEPT SPDLOG_INLINE logger &logger::operator=(logger other) & SPDLOG_NOEXCEPT
{ {
this->swap(other); this->swap(other);
return *this; return *this;
} }
SPDLOG_INLINE void logger::swap(spdlog::logger &other) SPDLOG_NOEXCEPT SPDLOG_INLINE void logger::swap(spdlog::logger &other) & SPDLOG_NOEXCEPT
{ {
name_.swap(other.name_); name_.swap(other.name_);
sinks_.swap(other.sinks_); sinks_.swap(other.sinks_);
@ -64,7 +64,7 @@ SPDLOG_INLINE void swap(logger &a, logger &b)
a.swap(b); a.swap(b);
} }
SPDLOG_INLINE void logger::set_level(level::level_enum log_level) SPDLOG_INLINE void logger::set_level(level::level_enum log_level) &
{ {
level_.store(log_level); level_.store(log_level);
} }
@ -74,14 +74,24 @@ SPDLOG_INLINE level::level_enum logger::level() const
return static_cast<level::level_enum>(level_.load(std::memory_order_relaxed)); return static_cast<level::level_enum>(level_.load(std::memory_order_relaxed));
} }
SPDLOG_INLINE const std::string &logger::name() const SPDLOG_INLINE std::string logger::name() &&
{
return std::move(name_);
}
SPDLOG_INLINE const std::string &logger::name() const &
{
return name_;
}
SPDLOG_INLINE std::string &logger::name() &
{ {
return name_; return name_;
} }
// set formatting for the sinks in this logger. // set formatting for the sinks in this logger.
// each sink will get a separate instance of the formatter object. // each sink will get a separate instance of the formatter object.
SPDLOG_INLINE void logger::set_formatter(std::unique_ptr<formatter> f) SPDLOG_INLINE void logger::set_formatter(std::unique_ptr<formatter> f) &
{ {
for (auto it = sinks_.begin(); it != sinks_.end(); ++it) for (auto it = sinks_.begin(); it != sinks_.end(); ++it)
{ {
@ -98,20 +108,20 @@ SPDLOG_INLINE void logger::set_formatter(std::unique_ptr<formatter> f)
} }
} }
SPDLOG_INLINE void logger::set_pattern(std::string pattern, pattern_time_type time_type) SPDLOG_INLINE void logger::set_pattern(std::string pattern, pattern_time_type time_type) &
{ {
auto new_formatter = details::make_unique<pattern_formatter>(std::move(pattern), time_type); auto new_formatter = details::make_unique<pattern_formatter>(std::move(pattern), time_type);
set_formatter(std::move(new_formatter)); set_formatter(std::move(new_formatter));
} }
// create new backtrace sink and move to it all our child sinks // create new backtrace sink and move to it all our child sinks
SPDLOG_INLINE void logger::enable_backtrace(size_t n_messages) SPDLOG_INLINE void logger::enable_backtrace(size_t n_messages) &
{ {
tracer_.enable(n_messages); tracer_.enable(n_messages);
} }
// restore orig sinks and level and delete the backtrace sink // restore orig sinks and level and delete the backtrace sink
SPDLOG_INLINE void logger::disable_backtrace() SPDLOG_INLINE void logger::disable_backtrace() &
{ {
tracer_.disable(); tracer_.disable();
} }
@ -138,24 +148,29 @@ SPDLOG_INLINE level::level_enum logger::flush_level() const
} }
// sinks // sinks
SPDLOG_INLINE const std::vector<sink_ptr> &logger::sinks() const SPDLOG_INLINE std::vector<sink_ptr> logger::sinks() &&
{
return std::move(sinks_);
}
SPDLOG_INLINE const std::vector<sink_ptr> &logger::sinks() const &
{ {
return sinks_; return sinks_;
} }
SPDLOG_INLINE std::vector<sink_ptr> &logger::sinks() SPDLOG_INLINE std::vector<sink_ptr> &logger::sinks() &
{ {
return sinks_; return sinks_;
} }
// error handler // error handler
SPDLOG_INLINE void logger::set_error_handler(err_handler handler) SPDLOG_INLINE void logger::set_error_handler(err_handler handler) &
{ {
custom_err_handler_ = std::move(handler); custom_err_handler_ = std::move(handler);
} }
// create new logger with same sinks and configuration. // create new logger with same sinks and configuration.
SPDLOG_INLINE std::shared_ptr<logger> logger::clone(std::string logger_name) SPDLOG_INLINE std::shared_ptr<logger> logger::clone(std::string logger_name) const &
{ {
auto cloned = std::make_shared<logger>(*this); auto cloned = std::make_shared<logger>(*this);
cloned->name_ = std::move(logger_name); cloned->name_ = std::move(logger_name);

50
include/spdlog/logger.h
Unescape Escape View File

@ -69,62 +69,62 @@ public:
logger(const logger &other); logger(const logger &other);
logger(logger &&other) SPDLOG_NOEXCEPT; logger(logger &&other) SPDLOG_NOEXCEPT;
logger &operator=(logger other) SPDLOG_NOEXCEPT; logger &operator=(logger other) & SPDLOG_NOEXCEPT;
void swap(spdlog::logger &other) SPDLOG_NOEXCEPT; void swap(spdlog::logger &other) & SPDLOG_NOEXCEPT;
// FormatString is a type derived from fmt::compile_string // FormatString is a type derived from fmt::compile_string
template<typename FormatString, typename std::enable_if<fmt::is_compile_string<FormatString>::value, int>::type = 0, typename... Args> template<typename FormatString, typename std::enable_if<fmt::is_compile_string<FormatString>::value, int>::type = 0, typename... Args>
void log(source_loc loc, level::level_enum lvl, const FormatString &fmt, Args&&...args) void log(source_loc loc, level::level_enum lvl, const FormatString &fmt, Args &&...args)
{ {
log_(loc, lvl, fmt, std::forward<Args>(args)...); log_(loc, lvl, fmt, std::forward<Args>(args)...);
} }
// FormatString is NOT a type derived from fmt::compile_string but is a string_view_t or can be implicitly converted to one // FormatString is NOT a type derived from fmt::compile_string but is a string_view_t or can be implicitly converted to one
template<typename... Args> template<typename... Args>
void log(source_loc loc, level::level_enum lvl, string_view_t fmt, Args&&...args) void log(source_loc loc, level::level_enum lvl, string_view_t fmt, Args &&...args)
{ {
log_(loc, lvl, fmt, std::forward<Args>(args)...); log_(loc, lvl, fmt, std::forward<Args>(args)...);
} }
template<typename FormatString, typename... Args> template<typename FormatString, typename... Args>
void log(level::level_enum lvl, const FormatString &fmt, Args&&...args) void log(level::level_enum lvl, const FormatString &fmt, Args &&...args)
{ {
log(source_loc{}, lvl, fmt, std::forward<Args>(args)...); log(source_loc{}, lvl, fmt, std::forward<Args>(args)...);
} }
template<typename FormatString, typename... Args> template<typename FormatString, typename... Args>
void trace(const FormatString &fmt, Args&&...args) void trace(const FormatString &fmt, Args &&...args)
{ {
log(level::trace, fmt, std::forward<Args>(args)...); log(level::trace, fmt, std::forward<Args>(args)...);
} }
template<typename FormatString, typename... Args> template<typename FormatString, typename... Args>
void debug(const FormatString &fmt, Args&&...args) void debug(const FormatString &fmt, Args &&...args)
{ {
log(level::debug, fmt, std::forward<Args>(args)...); log(level::debug, fmt, std::forward<Args>(args)...);
} }
template<typename FormatString, typename... Args> template<typename FormatString, typename... Args>
void info(const FormatString &fmt, Args&&...args) void info(const FormatString &fmt, Args &&...args)
{ {
log(level::info, fmt, std::forward<Args>(args)...); log(level::info, fmt, std::forward<Args>(args)...);
} }
template<typename FormatString, typename... Args> template<typename FormatString, typename... Args>
void warn(const FormatString &fmt, Args&&...args) void warn(const FormatString &fmt, Args &&...args)
{ {
log(level::warn, fmt, std::forward<Args>(args)...); log(level::warn, fmt, std::forward<Args>(args)...);
} }
template<typename FormatString, typename... Args> template<typename FormatString, typename... Args>
void error(const FormatString &fmt, Args&&...args) void error(const FormatString &fmt, Args &&...args)
{ {
log(level::err, fmt, std::forward<Args>(args)...); log(level::err, fmt, std::forward<Args>(args)...);
} }
template<typename FormatString, typename... Args> template<typename FormatString, typename... Args>
void critical(const FormatString &fmt, Args&&...args) void critical(const FormatString &fmt, Args &&...args)
{ {
log(level::critical, fmt, std::forward<Args>(args)...); log(level::critical, fmt, std::forward<Args>(args)...);
} }
@ -225,7 +225,7 @@ public:
#else #else
template<typename... Args> template<typename... Args>
void log(source_loc loc, level::level_enum lvl, wstring_view_t fmt, Args&&...args) void log(source_loc loc, level::level_enum lvl, wstring_view_t fmt, Args &&...args)
{ {
bool log_enabled = should_log(lvl); bool log_enabled = should_log(lvl);
bool traceback_enabled = tracer_.enabled(); bool traceback_enabled = tracer_.enabled();
@ -282,22 +282,24 @@ public:
return tracer_.enabled(); return tracer_.enabled();
} }
void set_level(level::level_enum log_level); void set_level(level::level_enum log_level) &;
level::level_enum level() const; level::level_enum level() const;
const std::string &name() const; std::string name() &&;
const std::string &name() const&;
std::string &name() &;
// set formatting for the sinks in this logger. // set formatting for the sinks in this logger.
// each sink will get a separate instance of the formatter object. // each sink will get a separate instance of the formatter object.
void set_formatter(std::unique_ptr<formatter> f); void set_formatter(std::unique_ptr<formatter> f) &;
void set_pattern(std::string pattern, pattern_time_type time_type = pattern_time_type::local); void set_pattern(std::string pattern, pattern_time_type time_type = pattern_time_type::local) &;
// backtrace support. // backtrace support.
// efficiently store all debug/trace messages in a circular buffer until needed for debugging. // efficiently store all debug/trace messages in a circular buffer until needed for debugging.
void enable_backtrace(size_t n_messages); void enable_backtrace(size_t n_messages) &;
void disable_backtrace(); void disable_backtrace() &;
void dump_backtrace(); void dump_backtrace();
// flush functions // flush functions
@ -306,15 +308,15 @@ public:
level::level_enum flush_level() const; level::level_enum flush_level() const;
// sinks // sinks
const std::vector<sink_ptr> &sinks() const; std::vector<sink_ptr> sinks() &&;
const std::vector<sink_ptr> &sinks() const &;
std::vector<sink_ptr> &sinks(); std::vector<sink_ptr> &sinks() &;
// error handler // error handler
void set_error_handler(err_handler); void set_error_handler(err_handler) &;
// create new logger with same sinks and configuration. // create new logger with same sinks and configuration.
virtual std::shared_ptr<logger> clone(std::string logger_name); virtual std::shared_ptr<logger> clone(std::string logger_name) const&;
protected: protected:
std::string name_; std::string name_;
@ -326,7 +328,7 @@ protected:
// common implementation for after templated public api has been resolved // common implementation for after templated public api has been resolved
template<typename FormatString, typename... Args> template<typename FormatString, typename... Args>
void log_(source_loc loc, level::level_enum lvl, const FormatString &fmt, Args&&...args) void log_(source_loc loc, level::level_enum lvl, const FormatString &fmt, Args &&...args)
{ {
bool log_enabled = should_log(lvl); bool log_enabled = should_log(lvl);
bool traceback_enabled = tracer_.enabled(); bool traceback_enabled = tracer_.enabled();

2
include/spdlog/pattern_formatter-inl.h
Unescape Escape View File

@ -1064,7 +1064,7 @@ SPDLOG_INLINE void pattern_formatter::format(const details::log_msg &msg, memory
details::fmt_helper::append_string_view(eol_, dest); details::fmt_helper::append_string_view(eol_, dest);
} }
SPDLOG_INLINE void pattern_formatter::set_pattern(std::string pattern) SPDLOG_INLINE void pattern_formatter::set_pattern(std::string pattern) &
{ {
pattern_ = std::move(pattern); pattern_ = std::move(pattern);
compile_pattern_(pattern_); compile_pattern_(pattern_);

6
include/spdlog/pattern_formatter.h
Unescape Escape View File

@ -68,7 +68,7 @@ class SPDLOG_API custom_flag_formatter : public details::flag_formatter
public: public:
virtual std::unique_ptr<custom_flag_formatter> clone() const = 0; virtual std::unique_ptr<custom_flag_formatter> clone() const = 0;
void set_padding_info(details::padding_info padding) void set_padding_info(details::padding_info padding) &
{ {
flag_formatter::padinfo_ = padding; flag_formatter::padinfo_ = padding;
} }
@ -92,12 +92,12 @@ public:
void format(const details::log_msg &msg, memory_buf_t &dest) override; void format(const details::log_msg &msg, memory_buf_t &dest) override;
template<typename T, typename... Args> template<typename T, typename... Args>
pattern_formatter &add_flag(char flag, Args&&...args) pattern_formatter &add_flag(char flag, Args&&...args) &
{ {
custom_handlers_[flag] = details::make_unique<T>(std::forward<Args>(args)...); custom_handlers_[flag] = details::make_unique<T>(std::forward<Args>(args)...);
return *this; return *this;
} }
void set_pattern(std::string pattern); void set_pattern(std::string pattern) &;
private: private:
std::string pattern_; std::string pattern_;

2
include/spdlog/stopwatch.h
Unescape Escape View File

@ -40,7 +40,7 @@ public:
return std::chrono::duration<double>(clock::now() - start_tp_); return std::chrono::duration<double>(clock::now() - start_tp_);
} }
void reset() void reset() &
{ {
start_tp_ = clock ::now(); start_tp_ = clock ::now();
} }

Write Preview
Loading…
Cancel
Save