mirrors/spdlog
1
0
Fork 0
mirror of https://github.com/gabime/spdlog.git synced 2024-11-15 08:25:43 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

clang-format

Browse Source
This commit is contained in:
gabime 2021-11-16 23:44:35 +02:00
parent 1756c5d37f
commit dc030ec53c
29 changed files with 184 additions and 167 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
bench/bench.cpp
View File

@ -160,8 +160,8 @@ void bench(int howmany, std::shared_ptr<spdlog::logger> log)
auto delta = high_resolution_clock::now() - start; auto delta = high_resolution_clock::now() - start;
auto delta_d = duration_cast<duration<double>>(delta).count(); auto delta_d = duration_cast<duration<double>>(delta).count();
spdlog::info( spdlog::info(spdlog::fmt_lib::format(
spdlog::fmt_lib::format(std::locale("en_US.UTF-8"), "{:<30} Elapsed: {:0.2f} secs {:>16L}/sec", log->name(), delta_d, int(howmany / delta_d))); std::locale("en_US.UTF-8"), "{:<30} Elapsed: {:0.2f} secs {:>16L}/sec", log->name(), delta_d, int(howmany / delta_d)));
spdlog::drop(log->name()); spdlog::drop(log->name());
} }
@ -191,8 +191,8 @@ void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, size_t thread_co
auto delta = high_resolution_clock::now() - start; auto delta = high_resolution_clock::now() - start;
auto delta_d = duration_cast<duration<double>>(delta).count(); auto delta_d = duration_cast<duration<double>>(delta).count();
spdlog::info( spdlog::info(spdlog::fmt_lib::format(
spdlog::fmt_lib::format(std::locale("en_US.UTF-8"), "{:<30} Elapsed: {:0.2f} secs {:>16L}/sec", log->name(), delta_d, int(howmany / delta_d))); std::locale("en_US.UTF-8"), "{:<30} Elapsed: {:0.2f} secs {:>16L}/sec", log->name(), delta_d, int(howmany / delta_d)));
spdlog::drop(log->name()); spdlog::drop(log->name());
} }

6
include/spdlog/async.h
View File

@ -35,7 +35,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)
{ {
auto &registry_inst = details::registry::instance(); auto &registry_inst = details::registry::instance();
@ -61,13 +61,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
View File

@ -323,7 +323,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/file_helper-inl.h
View File

@ -20,7 +20,7 @@
namespace spdlog { namespace spdlog {
namespace details { namespace details {
SPDLOG_INLINE file_helper::file_helper(const file_event_handlers& event_handlers) SPDLOG_INLINE file_helper::file_helper(const file_event_handlers &event_handlers)
: event_handlers_(event_handlers) : event_handlers_(event_handlers)
{} {}

2
include/spdlog/details/file_helper.h
View File

@ -17,7 +17,7 @@ class SPDLOG_API file_helper
{ {
public: public:
file_helper() = default; file_helper() = default;
explicit file_helper(const file_event_handlers& event_handlers); explicit file_helper(const file_event_handlers &event_handlers);
file_helper(const file_helper &) = delete; file_helper(const file_helper &) = delete;
file_helper &operator=(const file_helper &) = delete; file_helper &operator=(const file_helper &) = delete;

10
include/spdlog/details/fmt_helper.h
View File

@ -9,8 +9,8 @@
#include <spdlog/common.h> #include <spdlog/common.h>
#ifdef SPDLOG_USE_STD_FORMAT #ifdef SPDLOG_USE_STD_FORMAT
#include <charconv> # include <charconv>
#include <limits> # include <limits>
#endif #endif
// Some fmt helpers to efficiently format and pad ints and strings // Some fmt helpers to efficiently format and pad ints and strings
@ -89,11 +89,11 @@ inline unsigned int count_digits(T n)
return static_cast<unsigned int>(fmt:: return static_cast<unsigned int>(fmt::
// fmt 7.0.0 renamed the internal namespace to detail. // fmt 7.0.0 renamed the internal namespace to detail.
// See: https://github.com/fmtlib/fmt/issues/1538 // See: https://github.com/fmtlib/fmt/issues/1538
#if FMT_VERSION < 70000 # if FMT_VERSION < 70000
internal internal
#else # else
detail detail
#endif # endif
::count_digits(static_cast<count_type>(n))); ::count_digits(static_cast<count_type>(n)));
#endif #endif
} }

6
include/spdlog/details/os-inl.h
View File

@ -381,11 +381,11 @@ SPDLOG_INLINE std::string filename_to_str(const filename_t &filename)
{ {
memory_buf_t buf; memory_buf_t buf;
wstr_to_utf8buf(filename, buf); wstr_to_utf8buf(filename, buf);
#ifdef SPDLOG_USE_STD_FORMAT # ifdef SPDLOG_USE_STD_FORMAT
return buf; return buf;
#else # else
return fmt::to_string(buf); return fmt::to_string(buf);
#endif # endif
} }
#else #else
SPDLOG_INLINE std::string filename_to_str(const filename_t &filename) SPDLOG_INLINE std::string filename_to_str(const filename_t &filename)

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

@ -13,7 +13,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)...);
auto new_logger = std::make_shared<spdlog::logger>(std::move(logger_name), std::move(sink)); auto new_logger = std::make_shared<spdlog::logger>(std::move(logger_name), std::move(sink));

2
include/spdlog/details/tcp_client-windows.h
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
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
View File

@ -31,7 +31,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)
@ -60,7 +59,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!");
} }

2
include/spdlog/fmt/bin_to_hex.h
View File

@ -220,4 +220,4 @@ struct formatter<spdlog::details::dump_info<T>, char>
} }
} }
}; };
} // namespace fmt/std } // namespace std

46
include/spdlog/logger.h
View File

@ -31,9 +31,9 @@
# 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_lib::format("{} [{}({})]", ex.what(), location.filename, location.line)); \ err_handler_(fmt_lib::format("{} [{}({})]", ex.what(), location.filename, location.line)); \
} \ } \
else \ else \
{ \ { \
@ -85,13 +85,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, format_string_t<Args...> fmt, Args &&...args) void log(source_loc loc, level::level_enum lvl, format_string_t<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, format_string_t<Args...> fmt, Args &&...args) void log(level::level_enum lvl, format_string_t<Args...> fmt, Args &&... args)
{ {
log(source_loc{}, lvl, fmt, std::forward<Args>(args)...); log(source_loc{}, lvl, fmt, std::forward<Args>(args)...);
} }
@ -141,50 +141,50 @@ public:
} }
template<typename... Args> template<typename... Args>
void trace(format_string_t<Args...> fmt, Args &&...args) void trace(format_string_t<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(format_string_t<Args...> fmt, Args &&...args) void debug(format_string_t<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(format_string_t<Args...> fmt, Args &&...args) void info(format_string_t<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(format_string_t<Args...> fmt, Args &&...args) void warn(format_string_t<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(format_string_t<Args...> fmt, Args &&...args) void error(format_string_t<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(format_string_t<Args...> fmt, Args &&...args) void critical(format_string_t<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(source_loc loc, level::level_enum lvl, wformat_string_t<Args...> fmt, Args &&...args) void log(source_loc loc, level::level_enum lvl, wformat_string_t<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, wformat_string_t<Args...> fmt, Args &&...args) void log(level::level_enum lvl, wformat_string_t<Args...> fmt, Args &&... args)
{ {
log(source_loc{}, lvl, fmt, std::forward<Args>(args)...); log(source_loc{}, lvl, fmt, std::forward<Args>(args)...);
} }
@ -225,37 +225,37 @@ public:
} }
template<typename... Args> template<typename... Args>
void trace(wformat_string_t<Args...> fmt, Args &&...args) void trace(wformat_string_t<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(wformat_string_t<Args...> fmt, Args &&...args) void debug(wformat_string_t<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(wformat_string_t<Args...> fmt, Args &&...args) void info(wformat_string_t<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(wformat_string_t<Args...> fmt, Args &&...args) void warn(wformat_string_t<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(wformat_string_t<Args...> fmt, Args &&...args) void error(wformat_string_t<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(wformat_string_t<Args...> fmt, Args &&...args) void critical(wformat_string_t<Args...> fmt, Args &&... args)
{ {
log(level::critical, fmt, std::forward<Args>(args)...); log(level::critical, fmt, std::forward<Args>(args)...);
} }
@ -353,7 +353,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)
{ {
bool log_enabled = should_log(lvl); bool log_enabled = should_log(lvl);
bool traceback_enabled = tracer_.enabled(); bool traceback_enabled = tracer_.enabled();
@ -377,7 +377,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();
@ -389,12 +389,12 @@ protected:
{ {
// format to wmemory_buffer and convert to utf8 // format to wmemory_buffer and convert to utf8
; ;
#ifdef SPDLOG_USE_STD_FORMAT # ifdef SPDLOG_USE_STD_FORMAT
wmemory_buf_t wbuf = std::vformat(fmt, std::make_wformat_args(std::forward<Args>(args)...)); wmemory_buf_t wbuf = std::vformat(fmt, std::make_wformat_args(std::forward<Args>(args)...));
#else # else
wmemory_buf_t wbuf; wmemory_buf_t wbuf;
fmt::detail::vformat_to(wbuf, fmt, fmt::make_format_args<fmt::wformat_context>(std::forward<Args>(args)...)); fmt::detail::vformat_to(wbuf, fmt, fmt::make_format_args<fmt::wformat_context>(std::forward<Args>(args)...));
#endif # endif
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()));

2
include/spdlog/pattern_formatter.h
View File

@ -92,7 +92,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;

2
include/spdlog/sinks/basic_file_sink-inl.h
View File

@ -14,7 +14,7 @@ namespace spdlog {
namespace sinks { namespace sinks {
template<typename Mutex> template<typename Mutex>
SPDLOG_INLINE basic_file_sink<Mutex>::basic_file_sink(const filename_t &filename, bool truncate, const file_event_handlers& event_handlers) SPDLOG_INLINE basic_file_sink<Mutex>::basic_file_sink(const filename_t &filename, bool truncate, const file_event_handlers &event_handlers)
: file_helper_{event_handlers} : file_helper_{event_handlers}
{ {
file_helper_.open(filename, truncate); file_helper_.open(filename, truncate);

8
include/spdlog/sinks/basic_file_sink.h
View File

@ -20,7 +20,7 @@ template<typename Mutex>
class basic_file_sink final : public base_sink<Mutex> class basic_file_sink final : public base_sink<Mutex>
{ {
public: public:
explicit basic_file_sink(const filename_t &filename, bool truncate = false, const file_event_handlers& event_handlers = {}); explicit basic_file_sink(const filename_t &filename, bool truncate = false, const file_event_handlers &event_handlers = {});
const filename_t &filename() const; const filename_t &filename() const;
protected: protected:
@ -40,13 +40,15 @@ using basic_file_sink_st = basic_file_sink<details::null_mutex>;
// factory functions // factory functions
// //
template<typename Factory = spdlog::synchronous_factory> template<typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> basic_logger_mt(const std::string &logger_name, const filename_t &filename, bool truncate = false, const file_event_handlers& event_handlers = {}) inline std::shared_ptr<logger> basic_logger_mt(
const std::string &logger_name, const filename_t &filename, bool truncate = false, const file_event_handlers &event_handlers = {})
{ {
return Factory::template create<sinks::basic_file_sink_mt>(logger_name, filename, truncate, event_handlers); return Factory::template create<sinks::basic_file_sink_mt>(logger_name, filename, truncate, event_handlers);
} }
template<typename Factory = spdlog::synchronous_factory> template<typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> basic_logger_st(const std::string &logger_name, const filename_t &filename, bool truncate = false, const file_event_handlers& event_handlers = {}) inline std::shared_ptr<logger> basic_logger_st(
const std::string &logger_name, const filename_t &filename, bool truncate = false, const file_event_handlers &event_handlers = {})
{ {
return Factory::template create<sinks::basic_file_sink_st>(logger_name, filename, truncate, event_handlers); return Factory::template create<sinks::basic_file_sink_st>(logger_name, filename, truncate, event_handlers);
} }

25
include/spdlog/sinks/daily_file_sink.h
View File

@ -116,7 +116,8 @@ class daily_file_sink final : public base_sink<Mutex>
{ {
public: public:
// create daily file sink which rotates on given time // create daily file sink which rotates on given time
daily_file_sink(filename_t base_filename, int rotation_hour, int rotation_minute, bool truncate = false, uint16_t max_files = 0, const file_event_handlers& event_handlers = {}) daily_file_sink(filename_t base_filename, int rotation_hour, int rotation_minute, bool truncate = false, uint16_t max_files = 0,
const file_event_handlers &event_handlers = {})
: base_filename_(std::move(base_filename)) : base_filename_(std::move(base_filename))
, rotation_h_(rotation_hour) , rotation_h_(rotation_hour)
, rotation_m_(rotation_minute) , rotation_m_(rotation_minute)
@ -262,30 +263,32 @@ using daily_file_format_sink_st = daily_file_sink<details::null_mutex, daily_fil
// factory functions // factory functions
// //
template<typename Factory = spdlog::synchronous_factory> template<typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> daily_logger_mt( inline std::shared_ptr<logger> daily_logger_mt(const std::string &logger_name, const filename_t &filename, int hour = 0, int minute = 0,
const std::string &logger_name, const filename_t &filename, int hour = 0, int minute = 0, bool truncate = false, uint16_t max_files = 0, const file_event_handlers& event_handlers = {}) bool truncate = false, uint16_t max_files = 0, const file_event_handlers &event_handlers = {})
{ {
return Factory::template create<sinks::daily_file_sink_mt>(logger_name, filename, hour, minute, truncate, max_files, event_handlers); return Factory::template create<sinks::daily_file_sink_mt>(logger_name, filename, hour, minute, truncate, max_files, event_handlers);
} }
template<typename Factory = spdlog::synchronous_factory> template<typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> daily_logger_format_mt( inline std::shared_ptr<logger> daily_logger_format_mt(const std::string &logger_name, const filename_t &filename, int hour = 0,
const std::string &logger_name, const filename_t &filename, int hour = 0, int minute = 0, bool truncate = false, uint16_t max_files = 0, const file_event_handlers& event_handlers = {}) int minute = 0, bool truncate = false, uint16_t max_files = 0, const file_event_handlers &event_handlers = {})
{ {
return Factory::template create<sinks::daily_file_format_sink_mt>(logger_name, filename, hour, minute, truncate, max_files, event_handlers); return Factory::template create<sinks::daily_file_format_sink_mt>(
logger_name, filename, hour, minute, truncate, max_files, event_handlers);
} }
template<typename Factory = spdlog::synchronous_factory> template<typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> daily_logger_st( inline std::shared_ptr<logger> daily_logger_st(const std::string &logger_name, const filename_t &filename, int hour = 0, int minute = 0,
const std::string &logger_name, const filename_t &filename, int hour = 0, int minute = 0, bool truncate = false, uint16_t max_files = 0, const file_event_handlers& event_handlers = {}) bool truncate = false, uint16_t max_files = 0, const file_event_handlers &event_handlers = {})
{ {
return Factory::template create<sinks::daily_file_sink_st>(logger_name, filename, hour, minute, truncate, max_files, event_handlers); return Factory::template create<sinks::daily_file_sink_st>(logger_name, filename, hour, minute, truncate, max_files, event_handlers);
} }
template<typename Factory = spdlog::synchronous_factory> template<typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> daily_logger_format_st( inline std::shared_ptr<logger> daily_logger_format_st(const std::string &logger_name, const filename_t &filename, int hour = 0,
const std::string &logger_name, const filename_t &filename, int hour = 0, int minute = 0, bool truncate = false, uint16_t max_files = 0, const file_event_handlers& event_handlers = {}) int minute = 0, bool truncate = false, uint16_t max_files = 0, const file_event_handlers &event_handlers = {})
{ {
return Factory::template create<sinks::daily_file_format_sink_st>(logger_name, filename, hour, minute, truncate, max_files, event_handlers); return Factory::template create<sinks::daily_file_format_sink_st>(
logger_name, filename, hour, minute, truncate, max_files, event_handlers);
} }
} // namespace spdlog } // namespace spdlog

11
include/spdlog/sinks/hourly_file_sink.h
View File

@ -46,7 +46,8 @@ class hourly_file_sink final : public base_sink<Mutex>
{ {
public: public:
// create hourly file sink which rotates on given time // create hourly file sink which rotates on given time
hourly_file_sink(filename_t base_filename, bool truncate = false, uint16_t max_files = 0, const file_event_handlers& event_handlers = {}) hourly_file_sink(
filename_t base_filename, bool truncate = false, uint16_t max_files = 0, const file_event_handlers &event_handlers = {})
: base_filename_(std::move(base_filename)) : base_filename_(std::move(base_filename))
, file_helper_{event_handlers} , file_helper_{event_handlers}
, truncate_(truncate) , truncate_(truncate)
@ -180,15 +181,15 @@ using hourly_file_sink_st = hourly_file_sink<details::null_mutex>;
// factory functions // factory functions
// //
template<typename Factory = spdlog::synchronous_factory> template<typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> hourly_logger_mt( inline std::shared_ptr<logger> hourly_logger_mt(const std::string &logger_name, const filename_t &filename, bool truncate = false,
const std::string &logger_name, const filename_t &filename, bool truncate = false, uint16_t max_files = 0, const file_event_handlers& event_handlers = {}) uint16_t max_files = 0, const file_event_handlers &event_handlers = {})
{ {
return Factory::template create<sinks::hourly_file_sink_mt>(logger_name, filename, truncate, max_files, event_handlers); return Factory::template create<sinks::hourly_file_sink_mt>(logger_name, filename, truncate, max_files, event_handlers);
} }
template<typename Factory = spdlog::synchronous_factory> template<typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> hourly_logger_st( inline std::shared_ptr<logger> hourly_logger_st(const std::string &logger_name, const filename_t &filename, bool truncate = false,
const std::string &logger_name, const filename_t &filename, bool truncate = false, uint16_t max_files = 0, const file_event_handlers& event_handlers = {}) uint16_t max_files = 0, const file_event_handlers &event_handlers = {})
{ {
return Factory::template create<sinks::hourly_file_sink_st>(logger_name, filename, truncate, max_files, event_handlers); return Factory::template create<sinks::hourly_file_sink_st>(logger_name, filename, truncate, max_files, event_handlers);
} }

6
include/spdlog/sinks/msvc_sink.h
View File

@ -30,11 +30,11 @@ protected:
{ {
memory_buf_t formatted; memory_buf_t formatted;
base_sink<Mutex>::formatter_->format(msg, formatted); base_sink<Mutex>::formatter_->format(msg, formatted);
#ifdef SPDLOG_USE_STD_FORMAT # ifdef SPDLOG_USE_STD_FORMAT
OutputDebugStringA(formatted.c_str()); OutputDebugStringA(formatted.c_str());
#else # else
OutputDebugStringA(fmt::to_string(formatted).c_str()); OutputDebugStringA(fmt::to_string(formatted).c_str());
#endif # endif
} }
void flush_() override {} void flush_() override {}

89
include/spdlog/sinks/qt_sinks.h
View File

@ -21,29 +21,36 @@
// //
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; {
meta_method_ = meta_method; qt_object_ = qt_object;
} 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; {
base_sink<Mutex>::formatter_->format(msg, formatted); memory_buf_t formatted;
string_view_t str = string_view_t(formatted.data(), formatted.size()); base_sink<Mutex>::formatter_->format(msg, formatted);
QMetaObject::invokeMethod(qt_object_, meta_method_.c_str(), Qt::AutoConnection, string_view_t str = string_view_t(formatted.data(), formatted.size());
Q_ARG(QString, QString::fromUtf8(str.data(), static_cast<int>(str.size())).trimmed())); QMetaObject::invokeMethod(qt_object_, meta_method_.c_str(), Qt::AutoConnection,
} Q_ARG(QString, QString::fromUtf8(str.data(), static_cast<int>(str.size())).trimmed()));
}
void flush_() override {} void flush_() override {}
private: private:
QObject *qt_object_ = nullptr; QObject *qt_object_ = nullptr;
std::string meta_method_; std::string meta_method_;
}; };
#include "spdlog/details/null_mutex.h" #include "spdlog/details/null_mutex.h"
@ -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);
}
template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger>
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);
}
template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger>
qt_logger_mt(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(const std::string &logger_name, QTextEdit *qt_object, const std::string &meta_method = "append")
qt_logger_st(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(
qt_logger_mt(const std::string &logger_name, QObject* qt_object, const std::string &meta_method) { 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, QObject* qt_object, const std::string &meta_method) { 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);
}
template<typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> 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);
}
template<typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> 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

2
include/spdlog/sinks/rotating_file_sink-inl.h
View File

@ -25,7 +25,7 @@ namespace sinks {
template<typename Mutex> template<typename Mutex>
SPDLOG_INLINE rotating_file_sink<Mutex>::rotating_file_sink( SPDLOG_INLINE rotating_file_sink<Mutex>::rotating_file_sink(
filename_t base_filename, std::size_t max_size, std::size_t max_files, bool rotate_on_open, const file_event_handlers& event_handlers) filename_t base_filename, std::size_t max_size, std::size_t max_files, bool rotate_on_open, const file_event_handlers &event_handlers)
: base_filename_(std::move(base_filename)) : base_filename_(std::move(base_filename))
, max_size_(max_size) , max_size_(max_size)
, max_files_(max_files) , max_files_(max_files)

17
include/spdlog/sinks/rotating_file_sink.h
View File

@ -22,7 +22,8 @@ template<typename Mutex>
class rotating_file_sink final : public base_sink<Mutex> class rotating_file_sink final : public base_sink<Mutex>
{ {
public: public:
rotating_file_sink(filename_t base_filename, std::size_t max_size, std::size_t max_files, bool rotate_on_open = false, const file_event_handlers& event_handlers = {}); rotating_file_sink(filename_t base_filename, std::size_t max_size, std::size_t max_files, bool rotate_on_open = false,
const file_event_handlers &event_handlers = {});
static filename_t calc_filename(const filename_t &filename, std::size_t index); static filename_t calc_filename(const filename_t &filename, std::size_t index);
filename_t filename(); filename_t filename();
@ -59,17 +60,19 @@ using rotating_file_sink_st = rotating_file_sink<details::null_mutex>;
// //
template<typename Factory = spdlog::synchronous_factory> template<typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> rotating_logger_mt( inline std::shared_ptr<logger> rotating_logger_mt(const std::string &logger_name, const filename_t &filename, size_t max_file_size,
const std::string &logger_name, const filename_t &filename, size_t max_file_size, size_t max_files, bool rotate_on_open = false, const file_event_handlers& event_handlers = {}) size_t max_files, bool rotate_on_open = false, const file_event_handlers &event_handlers = {})
{ {
return Factory::template create<sinks::rotating_file_sink_mt>(logger_name, filename, max_file_size, max_files, rotate_on_open, event_handlers); return Factory::template create<sinks::rotating_file_sink_mt>(
logger_name, filename, max_file_size, max_files, rotate_on_open, event_handlers);
} }
template<typename Factory = spdlog::synchronous_factory> template<typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> rotating_logger_st( inline std::shared_ptr<logger> rotating_logger_st(const std::string &logger_name, const filename_t &filename, size_t max_file_size,
const std::string &logger_name, const filename_t &filename, size_t max_file_size, size_t max_files, bool rotate_on_open = false, const file_event_handlers& event_handlers = {}) size_t max_files, bool rotate_on_open = false, const file_event_handlers &event_handlers = {})
{ {
return Factory::template create<sinks::rotating_file_sink_st>(logger_name, filename, max_file_size, max_files, rotate_on_open, event_handlers); return Factory::template create<sinks::rotating_file_sink_st>(
logger_name, filename, max_file_size, max_files, rotate_on_open, event_handlers);
} }
} // namespace spdlog } // namespace spdlog

4
include/spdlog/sinks/win_eventlog_sink.h
View File

@ -53,8 +53,8 @@ struct local_alloc_t
SPDLOG_CONSTEXPR local_alloc_t() SPDLOG_NOEXCEPT : hlocal_(nullptr) {} SPDLOG_CONSTEXPR local_alloc_t() SPDLOG_NOEXCEPT : hlocal_(nullptr) {}
local_alloc_t(local_alloc_t const&) = delete; local_alloc_t(local_alloc_t const &) = delete;
local_alloc_t& operator=(local_alloc_t const&) = delete; local_alloc_t &operator=(local_alloc_t const &) = delete;
~local_alloc_t() SPDLOG_NOEXCEPT ~local_alloc_t() SPDLOG_NOEXCEPT
{ {

34
include/spdlog/spdlog.h
View File

@ -31,7 +31,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)...);
} }
@ -128,49 +128,49 @@ SPDLOG_API spdlog::logger *default_logger_raw();
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, format_string_t<Args...> fmt, Args &&...args) inline void log(source_loc source, level::level_enum lvl, format_string_t<Args...> fmt, Args &&... args)
{ {
default_logger_raw()->log(source, lvl, fmt, std::forward<Args>(args)...); default_logger_raw()->log(source, lvl, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void log(level::level_enum lvl, format_string_t<Args...> fmt, Args &&...args) inline void log(level::level_enum lvl, format_string_t<Args...> fmt, Args &&... args)
{ {
default_logger_raw()->log(source_loc{}, lvl, fmt, std::forward<Args>(args)...); default_logger_raw()->log(source_loc{}, lvl, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void trace(format_string_t<Args...> fmt, Args &&...args) inline void trace(format_string_t<Args...> fmt, Args &&... args)
{ {
default_logger_raw()->trace(fmt, std::forward<Args>(args)...); default_logger_raw()->trace(fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void debug(format_string_t<Args...> fmt, Args &&...args) inline void debug(format_string_t<Args...> fmt, Args &&... args)
{ {
default_logger_raw()->debug(fmt, std::forward<Args>(args)...); default_logger_raw()->debug(fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void info(format_string_t<Args...> fmt, Args &&...args) inline void info(format_string_t<Args...> fmt, Args &&... args)
{ {
default_logger_raw()->info(fmt, std::forward<Args>(args)...); default_logger_raw()->info(fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void warn(format_string_t<Args...> fmt, Args &&...args) inline void warn(format_string_t<Args...> fmt, Args &&... args)
{ {
default_logger_raw()->warn(fmt, std::forward<Args>(args)...); default_logger_raw()->warn(fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void error(format_string_t<Args...> fmt, Args &&...args) inline void error(format_string_t<Args...> fmt, Args &&... args)
{ {
default_logger_raw()->error(fmt, std::forward<Args>(args)...); default_logger_raw()->error(fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void critical(format_string_t<Args...> fmt, Args &&...args) inline void critical(format_string_t<Args...> fmt, Args &&... args)
{ {
default_logger_raw()->critical(fmt, std::forward<Args>(args)...); default_logger_raw()->critical(fmt, std::forward<Args>(args)...);
} }
@ -189,49 +189,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, wformat_string_t<Args...> fmt, Args &&...args) inline void log(source_loc source, level::level_enum lvl, wformat_string_t<Args...> fmt, Args &&... args)
{ {
default_logger_raw()->log(source, lvl, fmt, std::forward<Args>(args)...); default_logger_raw()->log(source, lvl, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void log(level::level_enum lvl, wformat_string_t<Args...> fmt, Args &&...args) inline void log(level::level_enum lvl, wformat_string_t<Args...> fmt, Args &&... args)
{ {
default_logger_raw()->log(source_loc{}, lvl, fmt, std::forward<Args>(args)...); default_logger_raw()->log(source_loc{}, lvl, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void trace(wformat_string_t<Args...> fmt, Args &&...args) inline void trace(wformat_string_t<Args...> fmt, Args &&... args)
{ {
default_logger_raw()->trace(fmt, std::forward<Args>(args)...); default_logger_raw()->trace(fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void debug(wformat_string_t<Args...> fmt, Args &&...args) inline void debug(wformat_string_t<Args...> fmt, Args &&... args)
{ {
default_logger_raw()->debug(fmt, std::forward<Args>(args)...); default_logger_raw()->debug(fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void info(wformat_string_t<Args...> fmt, Args &&...args) inline void info(wformat_string_t<Args...> fmt, Args &&... args)
{ {
default_logger_raw()->info(fmt, std::forward<Args>(args)...); default_logger_raw()->info(fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void warn(wformat_string_t<Args...> fmt, Args &&...args) inline void warn(wformat_string_t<Args...> fmt, Args &&... args)
{ {
default_logger_raw()->warn(fmt, std::forward<Args>(args)...); default_logger_raw()->warn(fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void error(wformat_string_t<Args...> fmt, Args &&...args) inline void error(wformat_string_t<Args...> fmt, Args &&... args)
{ {
default_logger_raw()->error(fmt, std::forward<Args>(args)...); default_logger_raw()->error(fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void critical(wformat_string_t<Args...> fmt, Args &&...args) inline void critical(wformat_string_t<Args...> fmt, Args &&... args)
{ {
default_logger_raw()->critical(fmt, std::forward<Args>(args)...); default_logger_raw()->critical(fmt, std::forward<Args>(args)...);
} }

2
include/spdlog/stopwatch.h
View File

@ -65,4 +65,4 @@ struct formatter<spdlog::stopwatch> : formatter<double>
return formatter<double>::format(sw.elapsed().count(), ctx); return formatter<double>::format(sw.elapsed().count(), ctx);
} }
}; };
} // namespace fmt/std } // namespace std

34
tests/test_daily_logger.cpp
View File

@ -33,17 +33,17 @@ TEST_CASE("daily_logger with dateonly calculator", "[daily_logger]")
#ifdef SPDLOG_WCHAR_FILENAMES #ifdef SPDLOG_WCHAR_FILENAMES
spdlog::memory_buf_t buf; spdlog::memory_buf_t buf;
spdlog::details::os::wstr_to_utf8buf(fmt::to_string(w), buf); spdlog::details::os::wstr_to_utf8buf(fmt::to_string(w), buf);
#ifdef SPDLOG_USE_STD_FORMAT # ifdef SPDLOG_USE_STD_FORMAT
auto &filename = buf; auto &filename = buf;
#else # else
auto filename = fmt::to_string(buf); auto filename = fmt::to_string(buf);
#endif # endif
#else #else
#ifdef SPDLOG_USE_STD_FORMAT # ifdef SPDLOG_USE_STD_FORMAT
auto &filename = w; auto &filename = w;
#else # else
auto filename = fmt::to_string(w); auto filename = fmt::to_string(w);
#endif # endif
#endif #endif
require_message_count(filename, 10); require_message_count(filename, 10);
} }
@ -53,8 +53,8 @@ struct custom_daily_file_name_calculator
static spdlog::filename_t calc_filename(const spdlog::filename_t &basename, const tm &now_tm) static spdlog::filename_t calc_filename(const spdlog::filename_t &basename, const tm &now_tm)
{ {
filename_memory_buf_t w; filename_memory_buf_t w;
spdlog::fmt_lib::format_to(std::back_inserter(w), SPDLOG_FILENAME_T("{}{:04d}{:02d}{:02d}"), basename, now_tm.tm_year + 1900, now_tm.tm_mon + 1, spdlog::fmt_lib::format_to(std::back_inserter(w), SPDLOG_FILENAME_T("{}{:04d}{:02d}{:02d}"), basename, now_tm.tm_year + 1900,
now_tm.tm_mday); now_tm.tm_mon + 1, now_tm.tm_mday);
#ifdef SPDLOG_USE_STD_FORMAT #ifdef SPDLOG_USE_STD_FORMAT
return w; return w;
#else #else
@ -87,17 +87,17 @@ TEST_CASE("daily_logger with custom calculator", "[daily_logger]")
#ifdef SPDLOG_WCHAR_FILENAMES #ifdef SPDLOG_WCHAR_FILENAMES
spdlog::memory_buf_t buf; spdlog::memory_buf_t buf;
spdlog::details::os::wstr_to_utf8buf(fmt::to_string(w), buf); spdlog::details::os::wstr_to_utf8buf(fmt::to_string(w), buf);
#ifdef SPDLOG_USE_STD_FORMAT # ifdef SPDLOG_USE_STD_FORMAT
auto &filename = buf; auto &filename = buf;
#else # else
auto filename = fmt::to_string(buf); auto filename = fmt::to_string(buf);
#endif # endif
#else #else
#ifdef SPDLOG_USE_STD_FORMAT # ifdef SPDLOG_USE_STD_FORMAT
auto &filename = w; auto &filename = w;
#else # else
auto filename = fmt::to_string(w); auto filename = fmt::to_string(w);
#endif # endif
#endif #endif
require_message_count(filename, 10); require_message_count(filename, 10);
} }
@ -146,10 +146,10 @@ TEST_CASE("daily_file_sink::daily_filename_format_calculator", "[daily_file_sink
{ {
std::tm tm = spdlog::details::os::localtime(); std::tm tm = spdlog::details::os::localtime();
// example-YYYY-MM-DD.log // example-YYYY-MM-DD.log
auto filename = auto filename = spdlog::sinks::daily_filename_format_calculator::calc_filename(SPDLOG_FILENAME_T("example-%Y-%m-%d.log"), tm);
spdlog::sinks::daily_filename_format_calculator::calc_filename(SPDLOG_FILENAME_T("example-%Y-%m-%d.log"), tm);
REQUIRE(filename == spdlog::fmt_lib::format(SPDLOG_FILENAME_T("example-{:04d}-{:02d}-{:02d}.log"), tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday)); REQUIRE(filename ==
spdlog::fmt_lib::format(SPDLOG_FILENAME_T("example-{:04d}-{:02d}-{:02d}.log"), tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday));
} }
/* Test removal of old files */ /* Test removal of old files */

2
tests/test_pattern_formatter.cpp
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);