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

clang-format

Browse Source
pull/2143/head
gabime 4 years ago
parent 2160f8dfbf
commit ce8cd2078a
20 changed files with 114 additions and 113 deletions
Show Stats Download Patch File Download Diff File

2
bench/async_bench.cpp
Unescape Escape View File

@ -123,7 +123,7 @@ int main(int argc, char *argv[])
auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(filename, true); auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(filename, true);
auto logger = std::make_shared<async_logger>("async_logger", std::move(file_sink), std::move(tp), async_overflow_policy::block); auto logger = std::make_shared<async_logger>("async_logger", std::move(file_sink), std::move(tp), async_overflow_policy::block);
bench_mt(howmany, std::move(logger), threads); bench_mt(howmany, std::move(logger), threads);
//verify_file(filename, howmany); // verify_file(filename, howmany);
} }
spdlog::info(""); spdlog::info("");

2
bench/formatter-bench.cpp
Unescape Escape View File

@ -12,7 +12,7 @@
void bench_formatter(benchmark::State &state, std::string pattern) void bench_formatter(benchmark::State &state, std::string pattern)
{ {
std::unique_ptr<spdlog::formatter> formatter; std::unique_ptr<spdlog::formatter> formatter;
if(pattern == "%+") if (pattern == "%+")
{ {
formatter = spdlog::details::make_unique<spdlog::default_formatter>(); formatter = spdlog::details::make_unique<spdlog::default_formatter>();
} }

9
example/example.cpp
Unescape Escape View File

@ -119,13 +119,13 @@ void load_levels_example()
// SPDLOG_LEVEL=info,mylogger=trace && ./example // SPDLOG_LEVEL=info,mylogger=trace && ./example
auto levels = spdlog::cfg::load_env_levels(); auto levels = spdlog::cfg::load_env_levels();
auto it = levels.find(spdlog::default_logger()->name()); auto it = levels.find(spdlog::default_logger()->name());
if(it != levels.end()) if (it != levels.end())
spdlog::default_logger()->set_level(it->second); spdlog::default_logger()->set_level(it->second);
auto my_logger = spdlog::basic_logger_mt("my_logger", "logs/my-logger.txt"); auto my_logger = spdlog::basic_logger_mt("my_logger", "logs/my-logger.txt");
it = levels.find(my_logger->name()); it = levels.find(my_logger->name());
if(it != levels.end()) if (it != levels.end())
my_logger ->set_level(it->second); my_logger->set_level(it->second);
// or from command line: // or from command line:
// ./example SPDLOG_LEVEL=info,mylogger=trace // ./example SPDLOG_LEVEL=info,mylogger=trace
@ -245,7 +245,8 @@ void user_defined_example()
void err_handler_example() void err_handler_example()
{ {
// can be set globally or per logger(logger->set_error_handler(..)) // can be set globally or per logger(logger->set_error_handler(..))
spdlog::default_logger()->set_error_handler([](const std::string &msg) { printf("*** Custom log error handler: %s ***\n", msg.c_str()); }); spdlog::default_logger()->set_error_handler(
[](const std::string &msg) { printf("*** Custom log error handler: %s ***\n", msg.c_str()); });
} }
// syslog example (linux/osx/freebsd) // syslog example (linux/osx/freebsd)

12
include/spdlog/async.h
Unescape Escape View File

@ -27,7 +27,7 @@ namespace details {
static const size_t default_async_q_size = 8192; static const size_t default_async_q_size = 8192;
static std::shared_ptr<thread_pool> s_thread_pool; static std::shared_ptr<thread_pool> s_thread_pool;
static std::recursive_mutex s_thread_pool_mutex; static std::recursive_mutex s_thread_pool_mutex;
} } // namespace details
// async logger factory - creates async loggers backed with thread pool. // async logger factory - creates async loggers backed with thread pool.
// if a global thread pool doesn't already exist, create it with default queue // if a global thread pool doesn't already exist, create it with default queue
@ -36,7 +36,7 @@ template<async_overflow_policy OverflowPolicy = async_overflow_policy::block>
struct async_factory_impl struct async_factory_impl
{ {
template<typename Sink, typename... SinkArgs> template<typename Sink, typename... SinkArgs>
static std::shared_ptr<async_logger> create(std::string logger_name, SinkArgs &&...args) static std::shared_ptr<async_logger> create(std::string logger_name, SinkArgs &&... args)
{ {
// create global thread pool if not already exists.. // create global thread pool if not already exists..
@ -45,10 +45,10 @@ struct async_factory_impl
if (!details::s_thread_pool) if (!details::s_thread_pool)
{ {
details::s_thread_pool = std::make_shared<details::thread_pool>(details::default_async_q_size, 1U); details::s_thread_pool = std::make_shared<details::thread_pool>(details::default_async_q_size, 1U);
} }
auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...); auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...);
auto new_logger = std::make_shared<async_logger>(std::move(logger_name), std::move(sink), std::move(details::s_thread_pool), OverflowPolicy); auto new_logger =
std::make_shared<async_logger>(std::move(logger_name), std::move(sink), std::move(details::s_thread_pool), OverflowPolicy);
return new_logger; return new_logger;
} }
}; };
@ -57,13 +57,13 @@ using async_factory = async_factory_impl<async_overflow_policy::block>;
using async_factory_nonblock = async_factory_impl<async_overflow_policy::overrun_oldest>; using async_factory_nonblock = async_factory_impl<async_overflow_policy::overrun_oldest>;
template<typename Sink, typename... SinkArgs> template<typename Sink, typename... SinkArgs>
inline std::shared_ptr<spdlog::logger> create_async(std::string logger_name, SinkArgs &&...sink_args) inline std::shared_ptr<spdlog::logger> create_async(std::string logger_name, SinkArgs &&... sink_args)
{ {
return async_factory::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...); return async_factory::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...);
} }
template<typename Sink, typename... SinkArgs> template<typename Sink, typename... SinkArgs>
inline std::shared_ptr<spdlog::logger> create_async_nb(std::string logger_name, SinkArgs &&...sink_args) inline std::shared_ptr<spdlog::logger> create_async_nb(std::string logger_name, SinkArgs &&... sink_args)
{ {
return async_factory_nonblock::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...); return async_factory_nonblock::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...);
} }

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

@ -262,7 +262,7 @@ namespace details {
using std::make_unique; using std::make_unique;
#else #else
template<typename T, typename... Args> template<typename T, typename... Args>
std::unique_ptr<T> make_unique(Args &&...args) std::unique_ptr<T> make_unique(Args &&... args)
{ {
static_assert(!std::is_array<T>::value, "arrays not supported"); static_assert(!std::is_array<T>::value, "arrays not supported");
return std::unique_ptr<T>(new T(std::forward<Args>(args)...)); return std::unique_ptr<T>(new T(std::forward<Args>(args)...));

2
include/spdlog/details/synchronous_factory.h
Unescape Escape View File

@ -11,7 +11,7 @@ class logger;
struct synchronous_factory struct synchronous_factory
{ {
template<typename Sink, typename... SinkArgs> template<typename Sink, typename... SinkArgs>
static std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&...args) static std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&... args)
{ {
auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...); auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...);
return std::make_shared<spdlog::logger>(std::move(logger_name), std::move(sink)); return std::make_shared<spdlog::logger>(std::move(logger_name), std::move(sink));

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

@ -56,7 +56,6 @@ public:
::WSACleanup(); ::WSACleanup();
} }
bool is_connected() const bool is_connected() const
{ {
return socket_ != INVALID_SOCKET; return socket_ != INVALID_SOCKET;
@ -73,7 +72,6 @@ public:
return socket_; return socket_;
} }
// 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)
{ {

5
include/spdlog/details/udp_client-windows.h
Unescape Escape View File

@ -23,7 +23,7 @@ namespace spdlog {
namespace details { namespace details {
class udp_client class udp_client
{ {
static constexpr int TX_BUFFER_SIZE = 1024*10; static constexpr int TX_BUFFER_SIZE = 1024 * 10;
SOCKET socket_ = INVALID_SOCKET; SOCKET socket_ = INVALID_SOCKET;
sockaddr_in addr_ = {0}; sockaddr_in addr_ = {0};
@ -64,7 +64,8 @@ public:
addr_.sin_family = PF_INET; addr_.sin_family = PF_INET;
addr_.sin_port = htons(port); addr_.sin_port = htons(port);
addr_.sin_addr.s_addr = INADDR_ANY; addr_.sin_addr.s_addr = INADDR_ANY;
if (InetPton(PF_INET, TEXT(host.c_str()), &addr_.sin_addr.s_addr) != 1) { if (InetPton(PF_INET, TEXT(host.c_str()), &addr_.sin_addr.s_addr) != 1)
{
int last_error = ::WSAGetLastError(); int last_error = ::WSAGetLastError();
::WSACleanup(); ::WSACleanup();
throw_winsock_error_("error: Invalid address!", last_error); throw_winsock_error_("error: Invalid address!", last_error);

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

@ -30,7 +30,6 @@ class udp_client
int socket_ = -1; int socket_ = -1;
struct sockaddr_in sockAddr_; struct sockaddr_in sockAddr_;
void cleanup_() void cleanup_()
{ {
if (socket_ != -1) if (socket_ != -1)
@ -59,7 +58,8 @@ public:
sockAddr_.sin_family = AF_INET; sockAddr_.sin_family = AF_INET;
sockAddr_.sin_port = htons(port); sockAddr_.sin_port = htons(port);
if (::inet_aton(host.c_str(), &sockAddr_.sin_addr) == 0) { if (::inet_aton(host.c_str(), &sockAddr_.sin_addr) == 0)
{
cleanup_(); cleanup_();
throw_spdlog_ex("error: Invalid address!"); throw_spdlog_ex("error: Invalid address!");
} }

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

@ -28,7 +28,6 @@ SPDLOG_INLINE logger::logger(logger &&other) SPDLOG_NOEXCEPT : name_(std::move(o
flush_level_(other.flush_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_)) custom_err_handler_(std::move(other.custom_err_handler_))
{} {}
SPDLOG_INLINE logger &logger::operator=(logger other) SPDLOG_NOEXCEPT SPDLOG_INLINE logger &logger::operator=(logger other) SPDLOG_NOEXCEPT
@ -135,7 +134,6 @@ SPDLOG_INLINE std::shared_ptr<logger> logger::clone(std::string logger_name)
return cloned; return cloned;
} }
SPDLOG_INLINE void logger::sink_it_(const details::log_msg &msg) SPDLOG_INLINE void logger::sink_it_(const details::log_msg &msg)
{ {
for (auto &sink : sinks_) for (auto &sink : sinks_)
@ -168,7 +166,6 @@ SPDLOG_INLINE void logger::flush_()
} }
} }
SPDLOG_INLINE bool logger::should_flush_(const details::log_msg &msg) SPDLOG_INLINE bool logger::should_flush_(const details::log_msg &msg)
{ {
auto flush_level = flush_level_.load(std::memory_order_relaxed); auto flush_level = flush_level_.load(std::memory_order_relaxed);

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

@ -30,7 +30,7 @@
# define SPDLOG_LOGGER_CATCH(location) \ # define SPDLOG_LOGGER_CATCH(location) \
catch (const std::exception &ex) \ catch (const std::exception &ex) \
{ \ { \
if(location.filename) \ if (location.filename) \
{ \ { \
err_handler_(fmt::format("{} [{}({})]", ex.what(), location.filename, location.line)); \ err_handler_(fmt::format("{} [{}({})]", ex.what(), location.filename, location.line)); \
} \ } \
@ -84,13 +84,13 @@ public:
void swap(spdlog::logger &other) SPDLOG_NOEXCEPT; void swap(spdlog::logger &other) SPDLOG_NOEXCEPT;
template<typename... Args> template<typename... Args>
void log(source_loc loc, level::level_enum lvl, fmt::format_string<Args...> fmt, Args &&...args) void log(source_loc loc, level::level_enum lvl, fmt::format_string<Args...> fmt, Args &&... args)
{ {
log_(loc, lvl, fmt, std::forward<Args>(args)...); log_(loc, lvl, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
void log(level::level_enum lvl, fmt::format_string<Args...> fmt, Args &&...args) void log(level::level_enum lvl, fmt::format_string<Args...> fmt, Args &&... args)
{ {
log(source_loc{}, lvl, fmt, std::forward<Args>(args)...); log(source_loc{}, lvl, fmt, std::forward<Args>(args)...);
} }
@ -142,86 +142,86 @@ public:
} }
template<typename... Args> template<typename... Args>
void trace(fmt::format_string<Args...> fmt, Args &&...args) void trace(fmt::format_string<Args...> fmt, Args &&... args)
{ {
log(level::trace, fmt, std::forward<Args>(args)...); log(level::trace, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
void debug(fmt::format_string<Args...> fmt, Args &&...args) void debug(fmt::format_string<Args...> fmt, Args &&... args)
{ {
log(level::debug, fmt, std::forward<Args>(args)...); log(level::debug, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
void info(fmt::format_string<Args...> fmt, Args &&...args) void info(fmt::format_string<Args...> fmt, Args &&... args)
{ {
log(level::info, fmt, std::forward<Args>(args)...); log(level::info, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
void warn(fmt::format_string<Args...> fmt, Args &&...args) void warn(fmt::format_string<Args...> fmt, Args &&... args)
{ {
log(level::warn, fmt, std::forward<Args>(args)...); log(level::warn, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
void error(fmt::format_string<Args...> fmt, Args &&...args) void error(fmt::format_string<Args...> fmt, Args &&... args)
{ {
log(level::err, fmt, std::forward<Args>(args)...); log(level::err, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
void critical(fmt::format_string<Args...> fmt, Args &&...args) void critical(fmt::format_string<Args...> fmt, Args &&... args)
{ {
log(level::critical, fmt, std::forward<Args>(args)...); log(level::critical, fmt, std::forward<Args>(args)...);
} }
#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
template<typename... Args> template<typename... Args>
void log(level::level_enum lvl, fmt::wformat_string<Args...> fmt, Args &&...args) void log(level::level_enum lvl, fmt::wformat_string<Args...> fmt, Args &&... args)
{ {
log(source_loc{}, lvl, fmt, std::forward<Args>(args)...); log(source_loc{}, lvl, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
void log(source_loc loc, level::level_enum lvl, fmt::wformat_string<Args...> fmt, Args &&...args) void log(source_loc loc, level::level_enum lvl, fmt::wformat_string<Args...> fmt, Args &&... args)
{ {
log_(loc, lvl, fmt, std::forward<Args>(args)...); log_(loc, lvl, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
void trace(fmt::wformat_string<Args...> fmt, Args &&...args) void trace(fmt::wformat_string<Args...> fmt, Args &&... args)
{ {
log(level::trace, fmt, std::forward<Args>(args)...); log(level::trace, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
void debug(fmt::wformat_string<Args...> fmt, Args &&...args) void debug(fmt::wformat_string<Args...> fmt, Args &&... args)
{ {
log(level::debug, fmt, std::forward<Args>(args)...); log(level::debug, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
void info(fmt::wformat_string<Args...> fmt, Args &&...args) void info(fmt::wformat_string<Args...> fmt, Args &&... args)
{ {
log(level::info, fmt, std::forward<Args>(args)...); log(level::info, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
void warn(fmt::wformat_string<Args...> fmt, Args &&...args) void warn(fmt::wformat_string<Args...> fmt, Args &&... args)
{ {
log(level::warn, fmt, std::forward<Args>(args)...); log(level::warn, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
void error(fmt::wformat_string<Args...> fmt, Args &&...args) void error(fmt::wformat_string<Args...> fmt, Args &&... args)
{ {
log(level::err, fmt, std::forward<Args>(args)...); log(level::err, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
void critical(fmt::wformat_string<Args...> fmt, Args &&...args) void critical(fmt::wformat_string<Args...> fmt, Args &&... args)
{ {
log(level::critical, fmt, std::forward<Args>(args)...); log(level::critical, fmt, std::forward<Args>(args)...);
} }
@ -304,7 +304,7 @@ protected:
// common implementation for after templated public api has been resolved // common implementation for after templated public api has been resolved
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)
{ {
if (!should_log(lvl)) if (!should_log(lvl))
{ {
@ -322,7 +322,7 @@ protected:
#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
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();
@ -338,7 +338,7 @@ protected:
memory_buf_t buf; memory_buf_t buf;
details::os::wstr_to_utf8buf(wstring_view_t(wbuf.data(), wbuf.size()), buf); details::os::wstr_to_utf8buf(wstring_view_t(wbuf.data(), wbuf.size()), buf);
details::log_msg log_msg(loc, name_, lvl, string_view_t(buf.data(), buf.size())); details::log_msg log_msg(loc, name_, lvl, string_view_t(buf.data(), buf.size()));
//log_it_(log_msg, log_enabled, traceback_enabled); // log_it_(log_msg, log_enabled, traceback_enabled);
sink_it_(log_msg); sink_it_(log_msg);
} }
SPDLOG_LOGGER_CATCH(loc) SPDLOG_LOGGER_CATCH(loc)

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

@ -925,7 +925,6 @@ private:
log_clock::time_point last_message_time_; log_clock::time_point last_message_time_;
}; };
} // namespace details } // namespace details
SPDLOG_INLINE pattern_formatter::pattern_formatter( SPDLOG_INLINE pattern_formatter::pattern_formatter(
@ -1289,7 +1288,7 @@ SPDLOG_INLINE void pattern_formatter::compile_pattern_(const std::string &patter
} }
} }
SPDLOG_INLINE void set_pattern(logger& logger, std::string pattern) SPDLOG_INLINE void set_pattern(logger &logger, std::string pattern)
{ {
logger.set_formatter(details::make_unique<pattern_formatter>(std::move(pattern))); logger.set_formatter(details::make_unique<pattern_formatter>(std::move(pattern)));
} }

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

@ -90,7 +90,7 @@ 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;
@ -118,9 +118,8 @@ private:
void compile_pattern_(const std::string &pattern); void compile_pattern_(const std::string &pattern);
}; };
// set pattern to logger // set pattern to logger
SPDLOG_API void set_pattern(logger& logger, std::string pattern); SPDLOG_API void set_pattern(logger &logger, std::string pattern);
} // namespace spdlog } // namespace spdlog

1
include/spdlog/sinks/base_sink-inl.h
Unescape Escape View File

@ -43,7 +43,6 @@ void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_formatter(std::unique_pt
set_formatter_(std::move(sink_formatter)); set_formatter_(std::move(sink_formatter));
} }
template<typename Mutex> template<typename Mutex>
void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_formatter_(std::unique_ptr<spdlog::formatter> sink_formatter) void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_formatter_(std::unique_ptr<spdlog::formatter> sink_formatter)
{ {

53
include/spdlog/sinks/qt_sinks.h
Unescape Escape View File

@ -21,17 +21,24 @@
// //
namespace spdlog { namespace spdlog {
namespace sinks { namespace sinks {
template <typename Mutex> class qt_sink : public base_sink<Mutex> { template<typename Mutex>
class qt_sink : public base_sink<Mutex>
{
public: public:
qt_sink(QObject *qt_object, const std::string &meta_method) { qt_sink(QObject *qt_object, const std::string &meta_method)
{
qt_object_ = qt_object; qt_object_ = qt_object;
meta_method_ = meta_method; meta_method_ = meta_method;
} }
~qt_sink() { flush_(); } ~qt_sink()
{
flush_();
}
protected: protected:
void sink_it_(const details::log_msg &msg) override { void sink_it_(const details::log_msg &msg) override
{
memory_buf_t formatted; memory_buf_t formatted;
base_sink<Mutex>::formatter_->format(msg, formatted); base_sink<Mutex>::formatter_->format(msg, formatted);
string_view_t str = string_view_t(formatted.data(), formatted.size()); string_view_t str = string_view_t(formatted.data(), formatted.size());
@ -55,39 +62,41 @@ using qt_sink_st = qt_sink<spdlog::details::null_mutex>;
// //
// Factory functions // Factory functions
// //
template <typename Factory = spdlog::synchronous_factory> template<typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> inline std::shared_ptr<logger> qt_logger_mt(const std::string &logger_name, QTextEdit *qt_object, const std::string &meta_method = "append")
qt_logger_mt(const std::string &logger_name, QTextEdit* qt_object, const std::string &meta_method = "append") { {
return Factory::template create<sinks::qt_sink_mt>(logger_name, qt_object, meta_method); return Factory::template create<sinks::qt_sink_mt>(logger_name, qt_object, meta_method);
} }
template <typename Factory = spdlog::synchronous_factory> template<typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> inline std::shared_ptr<logger> qt_logger_st(const std::string &logger_name, QTextEdit *qt_object, const std::string &meta_method = "append")
qt_logger_st(const std::string &logger_name, QTextEdit* qt_object, const std::string &meta_method = "append") { {
return Factory::template create<sinks::qt_sink_st>(logger_name, qt_object, meta_method); return Factory::template create<sinks::qt_sink_st>(logger_name, qt_object, meta_method);
} }
template <typename Factory = spdlog::synchronous_factory> template<typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> inline std::shared_ptr<logger> qt_logger_mt(
qt_logger_mt(const std::string &logger_name, QPlainTextEdit* qt_object , const std::string &meta_method = "appendPlainText") { const std::string &logger_name, QPlainTextEdit *qt_object, const std::string &meta_method = "appendPlainText")
{
return Factory::template create<sinks::qt_sink_mt>(logger_name, qt_object, meta_method); return Factory::template create<sinks::qt_sink_mt>(logger_name, qt_object, meta_method);
} }
template <typename Factory = spdlog::synchronous_factory> template<typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> inline std::shared_ptr<logger> qt_logger_st(
qt_logger_st(const std::string &logger_name, QPlainTextEdit* qt_object, const std::string &meta_method = "appendPlainText") { const std::string &logger_name, QPlainTextEdit *qt_object, const std::string &meta_method = "appendPlainText")
{
return Factory::template create<sinks::qt_sink_st>(logger_name, qt_object, meta_method); return Factory::template create<sinks::qt_sink_st>(logger_name, qt_object, meta_method);
} }
template <typename Factory = spdlog::synchronous_factory> template<typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> inline std::shared_ptr<logger> qt_logger_mt(const std::string &logger_name, QObject *qt_object, const std::string &meta_method)
qt_logger_mt(const std::string &logger_name, QObject* qt_object, const std::string &meta_method) { {
return Factory::template create<sinks::qt_sink_mt>(logger_name, qt_object, meta_method); return Factory::template create<sinks::qt_sink_mt>(logger_name, qt_object, meta_method);
} }
template <typename Factory = spdlog::synchronous_factory> template<typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> inline std::shared_ptr<logger> qt_logger_st(const std::string &logger_name, QObject *qt_object, const std::string &meta_method)
qt_logger_st(const std::string &logger_name, QObject* qt_object, const std::string &meta_method) { {
return Factory::template create<sinks::qt_sink_st>(logger_name, qt_object, meta_method); return Factory::template create<sinks::qt_sink_st>(logger_name, qt_object, meta_method);
} }
} // namespace spdlog } // namespace spdlog

1
include/spdlog/sinks/wincolor_sink-inl.h
Unescape Escape View File

@ -84,7 +84,6 @@ void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::flush()
// windows console always flushed? // windows console always flushed?
} }
template<typename ConsoleMutex> template<typename ConsoleMutex>
void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter)
{ {

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

@ -12,7 +12,7 @@
namespace spdlog { namespace spdlog {
SPDLOG_INLINE std::shared_ptr<spdlog::logger>& default_logger() SPDLOG_INLINE std::shared_ptr<spdlog::logger> &default_logger()
{ {
static auto s_default_logger = stdout_color_mt(""); static auto s_default_logger = stdout_color_mt("");
return s_default_logger; return s_default_logger;

35
include/spdlog/spdlog.h
Unescape Escape View File

@ -30,7 +30,7 @@ using default_factory = synchronous_factory;
// Example: // Example:
// spdlog::create<daily_file_sink_st>("logger_name", "dailylog_filename", 11, 59); // spdlog::create<daily_file_sink_st>("logger_name", "dailylog_filename", 11, 59);
template<typename Sink, typename... SinkArgs> template<typename Sink, typename... SinkArgs>
inline std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&...sink_args) inline std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&... sink_args)
{ {
return default_factory::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...); return default_factory::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...);
} }
@ -53,51 +53,50 @@ inline std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs
SPDLOG_API std::shared_ptr<spdlog::logger> &default_logger(); SPDLOG_API std::shared_ptr<spdlog::logger> &default_logger();
SPDLOG_API void set_default_logger(std::shared_ptr<spdlog::logger> default_logger); SPDLOG_API void set_default_logger(std::shared_ptr<spdlog::logger> default_logger);
template<typename... Args> template<typename... Args>
inline void log(source_loc source, level::level_enum lvl, fmt::format_string<Args...> fmt, Args &&...args) inline void log(source_loc source, level::level_enum lvl, fmt::format_string<Args...> fmt, Args &&... args)
{ {
default_logger()->log(source, lvl, fmt, std::forward<Args>(args)...); default_logger()->log(source, lvl, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void log(level::level_enum lvl, fmt::format_string<Args...> fmt, Args &&...args) inline void log(level::level_enum lvl, fmt::format_string<Args...> fmt, Args &&... args)
{ {
default_logger()->log(source_loc{}, lvl, fmt, std::forward<Args>(args)...); default_logger()->log(source_loc{}, lvl, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void trace(fmt::format_string<Args...> fmt, Args &&...args) inline void trace(fmt::format_string<Args...> fmt, Args &&... args)
{ {
default_logger()->trace(fmt, std::forward<Args>(args)...); default_logger()->trace(fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void debug(fmt::format_string<Args...> fmt, Args &&...args) inline void debug(fmt::format_string<Args...> fmt, Args &&... args)
{ {
default_logger()->debug(fmt, std::forward<Args>(args)...); default_logger()->debug(fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void info(fmt::format_string<Args...> fmt, Args &&...args) inline void info(fmt::format_string<Args...> fmt, Args &&... args)
{ {
default_logger()->info(fmt, std::forward<Args>(args)...); default_logger()->info(fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void warn(fmt::format_string<Args...> fmt, Args &&...args) inline void warn(fmt::format_string<Args...> fmt, Args &&... args)
{ {
default_logger()->warn(fmt, std::forward<Args>(args)...); default_logger()->warn(fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void error(fmt::format_string<Args...> fmt, Args &&...args) inline void error(fmt::format_string<Args...> fmt, Args &&... args)
{ {
default_logger()->error(fmt, std::forward<Args>(args)...); default_logger()->error(fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void critical(fmt::format_string<Args...> fmt, Args &&...args) inline void critical(fmt::format_string<Args...> fmt, Args &&... args)
{ {
default_logger()->critical(fmt, std::forward<Args>(args)...); default_logger()->critical(fmt, std::forward<Args>(args)...);
} }
@ -116,49 +115,49 @@ inline void log(level::level_enum lvl, const T &msg)
#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
template<typename... Args> template<typename... Args>
inline void log(source_loc source, level::level_enum lvl, fmt::wformat_string<Args...> fmt, Args &&...args) inline void log(source_loc source, level::level_enum lvl, fmt::wformat_string<Args...> fmt, Args &&... args)
{ {
default_logger()->log(source, lvl, fmt, std::forward<Args>(args)...); default_logger()->log(source, lvl, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void log(level::level_enum lvl, fmt::wformat_string<Args...> fmt, Args &&...args) inline void log(level::level_enum lvl, fmt::wformat_string<Args...> fmt, Args &&... args)
{ {
default_logger()->log(source_loc{}, lvl, fmt, std::forward<Args>(args)...); default_logger()->log(source_loc{}, lvl, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void trace(fmt::wformat_string<Args...> fmt, Args &&...args) inline void trace(fmt::wformat_string<Args...> fmt, Args &&... args)
{ {
default_logger()->trace(fmt, std::forward<Args>(args)...); default_logger()->trace(fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void debug(fmt::wformat_string<Args...> fmt, Args &&...args) inline void debug(fmt::wformat_string<Args...> fmt, Args &&... args)
{ {
default_logger()->debug(fmt, std::forward<Args>(args)...); default_logger()->debug(fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void info(fmt::wformat_string<Args...> fmt, Args &&...args) inline void info(fmt::wformat_string<Args...> fmt, Args &&... args)
{ {
default_logger()->info(fmt, std::forward<Args>(args)...); default_logger()->info(fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void warn(fmt::wformat_string<Args...> fmt, Args &&...args) inline void warn(fmt::wformat_string<Args...> fmt, Args &&... args)
{ {
default_logger()->warn(fmt, std::forward<Args>(args)...); default_logger()->warn(fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void error(fmt::wformat_string<Args...> fmt, Args &&...args) inline void error(fmt::wformat_string<Args...> fmt, Args &&... args)
{ {
default_logger()->error(fmt, std::forward<Args>(args)...); default_logger()->error(fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void critical(fmt::wformat_string<Args...> fmt, Args &&...args) inline void critical(fmt::wformat_string<Args...> fmt, Args &&... args)
{ {
default_logger()->critical(fmt, std::forward<Args>(args)...); default_logger()->critical(fmt, std::forward<Args>(args)...);
} }

2
tests/test_pattern_formatter.cpp
Unescape Escape View File

@ -5,7 +5,7 @@ using spdlog::memory_buf_t;
// log to str and return it // log to str and return it
template<typename... Args> template<typename... Args>
static std::string log_to_str(const std::string &msg, const Args &...args) static std::string log_to_str(const std::string &msg, const Args &... args)
{ {
std::ostringstream oss; std::ostringstream oss;
auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss); auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss);

Write Preview
Loading…
Cancel
Save