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

update clang format again

Browse Source
This commit is contained in:
gabime 2023-09-25 16:40:36 +03:00
parent 251c856a12
commit 0a53eafe18
104 changed files with 713 additions and 734 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
bench/async_bench.cpp
View File

@ -35,16 +35,15 @@ void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count
#ifdef _MSC_VER #ifdef _MSC_VER
#pragma warning(push) #pragma warning(push)
#pragma warning(disable : 4996) // disable fopen warning under msvc #pragma warning(disable : 4996) // disable fopen warning under msvc
#endif // _MSC_VER #endif // _MSC_VER
int count_lines(const char *filename) { int count_lines(const char *filename) {
int counter = 0; int counter = 0;
auto *infile = fopen(filename, "r"); auto *infile = fopen(filename, "r");
int ch; int ch;
while (EOF != (ch = getc(infile))) { while (EOF != (ch = getc(infile))) {
if ('\n' == ch) if ('\n' == ch) counter++;
counter++;
} }
fclose(infile); fclose(infile);
@ -67,7 +66,6 @@ void verify_file(const char *filename, int expected_count) {
#endif #endif
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
int howmany = 1000000; int howmany = 1000000;
int queue_size = std::min(howmany + 2, 8192); int queue_size = std::min(howmany + 2, 8192);
int threads = 10; int threads = 10;
@ -80,10 +78,8 @@ int main(int argc, char *argv[]) {
return 0; return 0;
} }
if (argc > 1) if (argc > 1) howmany = atoi(argv[1]);
howmany = atoi(argv[1]); if (argc > 2) threads = atoi(argv[2]);
if (argc > 2)
threads = atoi(argv[2]);
if (argc > 3) { if (argc > 3) {
queue_size = atoi(argv[3]); queue_size = atoi(argv[3]);
if (queue_size > 500000) { if (queue_size > 500000) {
@ -92,8 +88,7 @@ int main(int argc, char *argv[]) {
} }
} }
if (argc > 4) if (argc > 4) iters = atoi(argv[4]);
iters = atoi(argv[4]);
auto slot_size = sizeof(spdlog::details::async_msg); auto slot_size = sizeof(spdlog::details::async_msg);
spdlog::info("-------------------------------------------------"); spdlog::info("-------------------------------------------------");

3
bench/bench.cpp
View File

@ -22,7 +22,7 @@
#include "utils.h" #include "utils.h"
#include <atomic> #include <atomic>
#include <cstdlib> // EXIT_FAILURE #include <cstdlib> // EXIT_FAILURE
#include <memory> #include <memory>
#include <string> #include <string>
#include <thread> #include <thread>
@ -122,7 +122,6 @@ int main(int argc, char *argv[]) {
int iters = 250000; int iters = 250000;
size_t threads = 4; size_t threads = 4;
try { try {
if (argc > 1) { if (argc > 1) {
iters = std::stoi(argv[1]); iters = std::stoi(argv[1]);
} }

1
bench/formatter-bench.cpp
View File

@ -54,7 +54,6 @@ void bench_formatters() {
} }
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
spdlog::set_pattern("[%^%l%$] %v"); spdlog::set_pattern("[%^%l%$] %v");
if (argc != 2) { if (argc != 2) {
spdlog::error("Usage: {} <pattern> (or \"all\" to bench all)", argv[0]); spdlog::error("Usage: {} <pattern> (or \"all\" to bench all)", argv[0]);

12
bench/latency.cpp
View File

@ -49,8 +49,8 @@ void bench_global_logger(benchmark::State &state, std::shared_ptr<spdlog::logger
void bench_disabled_macro(benchmark::State &state, std::shared_ptr<spdlog::logger> logger) { void bench_disabled_macro(benchmark::State &state, std::shared_ptr<spdlog::logger> logger) {
int i = 0; int i = 0;
benchmark::DoNotOptimize(i); // prevent unused warnings benchmark::DoNotOptimize(i); // prevent unused warnings
benchmark::DoNotOptimize(logger); // prevent unused warnings benchmark::DoNotOptimize(logger); // prevent unused warnings
for (auto _ : state) { for (auto _ : state) {
SPDLOG_LOGGER_DEBUG(logger, "Hello logger: msg number {}...............", i++); SPDLOG_LOGGER_DEBUG(logger, "Hello logger: msg number {}...............", i++);
} }
@ -60,8 +60,8 @@ void bench_disabled_macro_global_logger(benchmark::State &state,
std::shared_ptr<spdlog::logger> logger) { std::shared_ptr<spdlog::logger> logger) {
spdlog::set_default_logger(std::move(logger)); spdlog::set_default_logger(std::move(logger));
int i = 0; int i = 0;
benchmark::DoNotOptimize(i); // prevent unused warnings benchmark::DoNotOptimize(i); // prevent unused warnings
benchmark::DoNotOptimize(logger); // prevent unused warnings benchmark::DoNotOptimize(logger); // prevent unused warnings
for (auto _ : state) { for (auto _ : state) {
SPDLOG_DEBUG("Hello logger: msg number {}...............", i++); SPDLOG_DEBUG("Hello logger: msg number {}...............", i++);
} }
@ -79,7 +79,7 @@ void bench_dev_null() {
->UseRealTime(); ->UseRealTime();
spdlog::drop("/dev/null_mt"); spdlog::drop("/dev/null_mt");
} }
#endif // __linux__ #endif // __linux__
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
using spdlog::sinks::null_sink_mt; using spdlog::sinks::null_sink_mt;
@ -123,7 +123,7 @@ int main(int argc, char *argv[]) {
#ifdef __linux #ifdef __linux
bench_dev_null(); bench_dev_null();
#endif // __linux__ #endif // __linux__
if (full_bench) { if (full_bench) {
// basic_st // basic_st

2
bench/utils.h
View File

@ -29,4 +29,4 @@ inline std::string format(const double &value) {
return ss.str(); return ss.str();
} }
} // namespace utils } // namespace utils

28
example/example.cpp
View File

@ -28,8 +28,8 @@ void file_events_example();
void replace_default_logger_example(); void replace_default_logger_example();
#include "spdlog/spdlog.h" #include "spdlog/spdlog.h"
#include "spdlog/cfg/env.h" // support for loading levels from the environment variable #include "spdlog/cfg/env.h" // support for loading levels from the environment variable
#include "spdlog/fmt/ostr.h" // support for user defined types #include "spdlog/fmt/ostr.h" // support for user defined types
int main(int, char *[]) { int main(int, char *[]) {
// Log levels can be loaded from argv/env using "SPDLOG_LEVEL" // Log levels can be loaded from argv/env using "SPDLOG_LEVEL"
@ -45,26 +45,26 @@ int main(int, char *[]) {
spdlog::info("{:>8} aligned, {:<8} aligned", "right", "left"); spdlog::info("{:>8} aligned, {:<8} aligned", "right", "left");
// Runtime log levels // Runtime log levels
spdlog::set_level(spdlog::level::info); // Set global log level to info spdlog::set_level(spdlog::level::info); // Set global log level to info
spdlog::debug("This message should not be displayed!"); spdlog::debug("This message should not be displayed!");
spdlog::set_level(spdlog::level::trace); // Set specific logger's log level spdlog::set_level(spdlog::level::trace); // Set specific logger's log level
spdlog::debug("This message should be displayed.."); spdlog::debug("This message should be displayed..");
// Customize msg format for all loggers // Customize msg format for all loggers
spdlog::set_pattern("[%H:%M:%S %z] [%^%L%$] [thread %t] %v"); spdlog::set_pattern("[%H:%M:%S %z] [%^%L%$] [thread %t] %v");
spdlog::info("This an info message with custom format"); spdlog::info("This an info message with custom format");
spdlog::set_pattern("%+"); // back to default format spdlog::set_pattern("%+"); // back to default format
spdlog::set_level(spdlog::level::info); spdlog::set_level(spdlog::level::info);
// Backtrace support // Backtrace support
// Loggers can store in a ring buffer all messages (including debug/trace) for later inspection. // Loggers can store in a ring buffer all messages (including debug/trace) for later inspection.
// When needed, call dump_backtrace() to see what happened: // When needed, call dump_backtrace() to see what happened:
spdlog::enable_backtrace(10); // create ring buffer with capacity of 10 messages spdlog::enable_backtrace(10); // create ring buffer with capacity of 10 messages
for (int i = 0; i < 100; i++) { for (int i = 0; i < 100; i++) {
spdlog::debug("Backtrace message {}", i); // not logged.. spdlog::debug("Backtrace message {}", i); // not logged..
} }
// e.g. if some error happened: // e.g. if some error happened:
spdlog::dump_backtrace(); // log them now! spdlog::dump_backtrace(); // log them now!
try { try {
stdout_logger_example(); stdout_logger_example();
@ -267,7 +267,7 @@ struct my_type {
: i(i){}; : i(i){};
}; };
#ifndef SPDLOG_USE_STD_FORMAT // when using fmtlib #ifndef SPDLOG_USE_STD_FORMAT // when using fmtlib
template <> template <>
struct fmt::formatter<my_type> : fmt::formatter<std::string> { struct fmt::formatter<my_type> : fmt::formatter<std::string> {
auto format(my_type my, format_context &ctx) -> decltype(ctx.out()) { auto format(my_type my, format_context &ctx) -> decltype(ctx.out()) {
@ -275,7 +275,7 @@ struct fmt::formatter<my_type> : fmt::formatter<std::string> {
} }
}; };
#else // when using std::format #else // when using std::format
template <> template <>
struct std::formatter<my_type> : std::formatter<std::string> { struct std::formatter<my_type> : std::formatter<std::string> {
auto format(my_type my, format_context &ctx) const -> decltype(ctx.out()) { auto format(my_type my, format_context &ctx) const -> decltype(ctx.out()) {
@ -319,8 +319,9 @@ void android_example() {
#include "spdlog/pattern_formatter.h" #include "spdlog/pattern_formatter.h"
class my_formatter_flag : public spdlog::custom_flag_formatter { class my_formatter_flag : public spdlog::custom_flag_formatter {
public: public:
void void format(const spdlog::details::log_msg &,
format(const spdlog::details::log_msg &, const std::tm &, spdlog::memory_buf_t &dest) override { const std::tm &,
spdlog::memory_buf_t &dest) override {
std::string some_txt = "custom-flag"; std::string some_txt = "custom-flag";
dest.append(some_txt.data(), some_txt.data() + some_txt.size()); dest.append(some_txt.data(), some_txt.data() + some_txt.size());
} }
@ -331,8 +332,7 @@ public:
}; };
void custom_flags_example() { void custom_flags_example() {
using spdlog::details::make_unique; // for pre c++14
using spdlog::details::make_unique; // for pre c++14
auto formatter = make_unique<spdlog::pattern_formatter>(); auto formatter = make_unique<spdlog::pattern_formatter>();
formatter->add_flag<my_formatter_flag>('*').set_pattern("[%n] [%*] [%^%l%$] %v"); formatter->add_flag<my_formatter_flag>('*').set_pattern("[%n] [%*] [%^%l%$] %v");
// set the new formatter using spdlog::set_formatter(formatter) or // set the new formatter using spdlog::set_formatter(formatter) or

7
include/spdlog/async.h
View File

@ -82,8 +82,9 @@ inline void init_thread_pool(size_t q_size,
details::registry::instance().set_tp(std::move(tp)); details::registry::instance().set_tp(std::move(tp));
} }
inline void inline void init_thread_pool(size_t q_size,
init_thread_pool(size_t q_size, size_t thread_count, std::function<void()> on_thread_start) { size_t thread_count,
std::function<void()> on_thread_start) {
init_thread_pool(q_size, thread_count, on_thread_start, [] {}); init_thread_pool(q_size, thread_count, on_thread_start, [] {});
} }
@ -96,4 +97,4 @@ inline void init_thread_pool(size_t q_size, size_t thread_count) {
inline std::shared_ptr<spdlog::details::thread_pool> thread_pool() { inline std::shared_ptr<spdlog::details::thread_pool> thread_pool() {
return details::registry::instance().get_tp(); return details::registry::instance().get_tp();
} }
} // namespace spdlog } // namespace spdlog

10
include/spdlog/async_logger.h
View File

@ -20,10 +20,10 @@ namespace spdlog {
// Async overflow policy - block by default. // Async overflow policy - block by default.
enum class async_overflow_policy { enum class async_overflow_policy {
block, // Block until message can be enqueued block, // Block until message can be enqueued
overrun_oldest, // Discard oldest message in the queue if full when trying to overrun_oldest, // Discard oldest message in the queue if full when trying to
// add new item. // add new item.
discard_new // Discard new message if the queue is full when trying to add new item. discard_new // Discard new message if the queue is full when trying to add new item.
}; };
namespace details { namespace details {
@ -67,7 +67,7 @@ private:
std::weak_ptr<details::thread_pool> thread_pool_; std::weak_ptr<details::thread_pool> thread_pool_;
async_overflow_policy overflow_policy_; async_overflow_policy overflow_policy_;
}; };
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
#include "async_logger-inl.h" #include "async_logger-inl.h"

4
include/spdlog/cfg/argv.h
View File

@ -36,5 +36,5 @@ inline void load_argv_levels(int argc, char **argv) {
load_argv_levels(argc, const_cast<const char **>(argv)); load_argv_levels(argc, const_cast<const char **>(argv));
} }
} // namespace cfg } // namespace cfg
} // namespace spdlog } // namespace spdlog

4
include/spdlog/cfg/env.h
View File

@ -32,5 +32,5 @@ inline void load_env_levels() {
} }
} }
} // namespace cfg } // namespace cfg
} // namespace spdlog } // namespace spdlog

8
include/spdlog/cfg/helpers-inl.h
View File

@ -89,7 +89,7 @@ SPDLOG_INLINE void load_levels(const std::string &input) {
if (level == level::off && level_name != "off") { if (level == level::off && level_name != "off") {
continue; continue;
} }
if (logger_name.empty()) // no logger name indicate global level if (logger_name.empty()) // no logger name indicate global level
{ {
global_level_found = true; global_level_found = true;
global_level = level; global_level = level;
@ -102,6 +102,6 @@ SPDLOG_INLINE void load_levels(const std::string &input) {
global_level_found ? &global_level : nullptr); global_level_found ? &global_level : nullptr);
} }
} // namespace helpers } // namespace helpers
} // namespace cfg } // namespace cfg
} // namespace spdlog } // namespace spdlog

8
include/spdlog/cfg/helpers.h
View File

@ -19,11 +19,11 @@ namespace helpers {
// turn off all logging except for logger1 and logger2: "off,logger1=debug,logger2=info" // turn off all logging except for logger1 and logger2: "off,logger1=debug,logger2=info"
// //
SPDLOG_API void load_levels(const std::string &txt); SPDLOG_API void load_levels(const std::string &txt);
} // namespace helpers } // namespace helpers
} // namespace cfg } // namespace cfg
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
#include "helpers-inl.h" #include "helpers-inl.h"
#endif // SPDLOG_HEADER_ONLY #endif // SPDLOG_HEADER_ONLY

4
include/spdlog/common-inl.h
View File

@ -42,7 +42,7 @@ SPDLOG_INLINE spdlog::level::level_enum from_str(const std::string &name) SPDLOG
} }
return level::off; return level::off;
} }
} // namespace level } // namespace level
SPDLOG_INLINE spdlog_ex::spdlog_ex(std::string msg) SPDLOG_INLINE spdlog_ex::spdlog_ex(std::string msg)
: msg_(std::move(msg)) {} : msg_(std::move(msg)) {}
@ -65,4 +65,4 @@ SPDLOG_INLINE void throw_spdlog_ex(const std::string &msg, int last_errno) {
SPDLOG_INLINE void throw_spdlog_ex(std::string msg) { SPDLOG_THROW(spdlog_ex(std::move(msg))); } SPDLOG_INLINE void throw_spdlog_ex(std::string msg) { SPDLOG_THROW(spdlog_ex(std::move(msg))); }
} // namespace spdlog } // namespace spdlog

50
include/spdlog/common.h
View File

@ -31,26 +31,26 @@
#if defined(_WIN32) #if defined(_WIN32)
#ifdef spdlog_EXPORTS #ifdef spdlog_EXPORTS
#define SPDLOG_API __declspec(dllexport) #define SPDLOG_API __declspec(dllexport)
#else // !spdlog_EXPORTS #else // !spdlog_EXPORTS
#define SPDLOG_API __declspec(dllimport) #define SPDLOG_API __declspec(dllimport)
#endif #endif
#else // !defined(_WIN32) #else // !defined(_WIN32)
#define SPDLOG_API __attribute__((visibility("default"))) #define SPDLOG_API __attribute__((visibility("default")))
#endif #endif
#else // !defined(SPDLOG_SHARED_LIB) #else // !defined(SPDLOG_SHARED_LIB)
#define SPDLOG_API #define SPDLOG_API
#endif #endif
#define SPDLOG_INLINE #define SPDLOG_INLINE
#else // !defined(SPDLOG_COMPILED_LIB) #else // !defined(SPDLOG_COMPILED_LIB)
#define SPDLOG_API #define SPDLOG_API
#define SPDLOG_HEADER_ONLY #define SPDLOG_HEADER_ONLY
#define SPDLOG_INLINE inline #define SPDLOG_INLINE inline
#endif // #ifdef SPDLOG_COMPILED_LIB #endif // #ifdef SPDLOG_COMPILED_LIB
#include <spdlog/fmt/fmt.h> #include <spdlog/fmt/fmt.h>
#if !defined(SPDLOG_USE_STD_FORMAT) && \ #if !defined(SPDLOG_USE_STD_FORMAT) && \
FMT_VERSION >= 80000 // backward compatibility with fmt versions older than 8 FMT_VERSION >= 80000 // backward compatibility with fmt versions older than 8
#define SPDLOG_FMT_RUNTIME(format_string) fmt::runtime(format_string) #define SPDLOG_FMT_RUNTIME(format_string) fmt::runtime(format_string)
#define SPDLOG_FMT_STRING(format_string) FMT_STRING(format_string) #define SPDLOG_FMT_STRING(format_string) FMT_STRING(format_string)
#if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) #if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
@ -162,7 +162,7 @@ using wformat_string_t = std::wstring_view;
#endif #endif
#endif #endif
#define SPDLOG_BUF_TO_STRING(x) x #define SPDLOG_BUF_TO_STRING(x) x
#else // use fmt lib instead of std::format #else // use fmt lib instead of std::format
namespace fmt_lib = fmt; namespace fmt_lib = fmt;
using string_view_t = fmt::basic_string_view<char>; using string_view_t = fmt::basic_string_view<char>;
@ -204,8 +204,8 @@ using wformat_string_t = fmt::wformat_string<Args...>;
#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
#ifndef _WIN32 #ifndef _WIN32
#error SPDLOG_WCHAR_TO_UTF8_SUPPORT only supported on windows #error SPDLOG_WCHAR_TO_UTF8_SUPPORT only supported on windows
#endif // _WIN32 #endif // _WIN32
#endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT #endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT
template <class T> template <class T>
struct is_convertible_to_any_format_string struct is_convertible_to_any_format_string
@ -271,7 +271,7 @@ SPDLOG_API const string_view_t &to_string_view(spdlog::level::level_enum l) SPDL
SPDLOG_API const char *to_short_c_str(spdlog::level::level_enum l) SPDLOG_NOEXCEPT; SPDLOG_API const char *to_short_c_str(spdlog::level::level_enum l) SPDLOG_NOEXCEPT;
SPDLOG_API spdlog::level::level_enum from_str(const std::string &name) SPDLOG_NOEXCEPT; SPDLOG_API spdlog::level::level_enum from_str(const std::string &name) SPDLOG_NOEXCEPT;
} // namespace level } // namespace level
// //
// Color mode used by sinks with color support. // Color mode used by sinks with color support.
@ -283,8 +283,8 @@ enum class color_mode { always, automatic, never };
// local time by default // local time by default
// //
enum class pattern_time_type { enum class pattern_time_type {
local, // log localtime local, // log localtime
utc // log utc utc // log utc
}; };
// //
@ -333,24 +333,24 @@ namespace details {
// to_string_view // to_string_view
SPDLOG_CONSTEXPR_FUNC spdlog::string_view_t SPDLOG_CONSTEXPR_FUNC spdlog::string_view_t to_string_view(const memory_buf_t &buf)
to_string_view(const memory_buf_t &buf) SPDLOG_NOEXCEPT { SPDLOG_NOEXCEPT {
return spdlog::string_view_t{buf.data(), buf.size()}; return spdlog::string_view_t{buf.data(), buf.size()};
} }
SPDLOG_CONSTEXPR_FUNC spdlog::string_view_t SPDLOG_CONSTEXPR_FUNC spdlog::string_view_t to_string_view(spdlog::string_view_t str)
to_string_view(spdlog::string_view_t str) SPDLOG_NOEXCEPT { SPDLOG_NOEXCEPT {
return str; return str;
} }
#if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) #if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
SPDLOG_CONSTEXPR_FUNC spdlog::wstring_view_t SPDLOG_CONSTEXPR_FUNC spdlog::wstring_view_t to_string_view(const wmemory_buf_t &buf)
to_string_view(const wmemory_buf_t &buf) SPDLOG_NOEXCEPT { SPDLOG_NOEXCEPT {
return spdlog::wstring_view_t{buf.data(), buf.size()}; return spdlog::wstring_view_t{buf.data(), buf.size()};
} }
SPDLOG_CONSTEXPR_FUNC spdlog::wstring_view_t SPDLOG_CONSTEXPR_FUNC spdlog::wstring_view_t to_string_view(spdlog::wstring_view_t str)
to_string_view(spdlog::wstring_view_t str) SPDLOG_NOEXCEPT { SPDLOG_NOEXCEPT {
return str; return str;
} }
#endif #endif
@ -362,14 +362,14 @@ inline fmt::basic_string_view<T> to_string_view(fmt::basic_format_string<T, Args
} }
#elif __cpp_lib_format >= 202207L #elif __cpp_lib_format >= 202207L
template <typename T, typename... Args> template <typename T, typename... Args>
SPDLOG_CONSTEXPR_FUNC std::basic_string_view<T> SPDLOG_CONSTEXPR_FUNC std::basic_string_view<T> to_string_view(
to_string_view(std::basic_format_string<T, Args...> fmt) SPDLOG_NOEXCEPT { std::basic_format_string<T, Args...> fmt) SPDLOG_NOEXCEPT {
return fmt.get(); return fmt.get();
} }
#endif #endif
// make_unique support for pre c++14 // make_unique support for pre c++14
#if __cplusplus >= 201402L // C++14 and beyond #if __cplusplus >= 201402L // C++14 and beyond
using std::enable_if_t; using std::enable_if_t;
using std::make_unique; using std::make_unique;
#else #else
@ -394,8 +394,8 @@ constexpr T conditional_static_cast(U value) {
return value; return value;
} }
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
#include "common-inl.h" #include "common-inl.h"

4
include/spdlog/details/backtracer-inl.h
View File

@ -59,5 +59,5 @@ SPDLOG_INLINE void backtracer::foreach_pop(std::function<void(const details::log
messages_.pop_front(); messages_.pop_front();
} }
} }
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

4
include/spdlog/details/backtracer.h
View File

@ -37,8 +37,8 @@ public:
void foreach_pop(std::function<void(const details::log_msg &)> fun); void foreach_pop(std::function<void(const details::log_msg &)> fun);
}; };
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
#include "backtracer-inl.h" #include "backtracer-inl.h"

8
include/spdlog/details/circular_q.h
View File

@ -24,7 +24,7 @@ public:
circular_q() = default; circular_q() = default;
explicit circular_q(size_t max_items) explicit circular_q(size_t max_items)
: max_items_(max_items + 1) // one item is reserved as marker for full q : max_items_(max_items + 1) // one item is reserved as marker for full q
, ,
v_(max_items_) {} v_(max_items_) {}
@ -46,7 +46,7 @@ public:
v_[tail_] = std::move(item); v_[tail_] = std::move(item);
tail_ = (tail_ + 1) % max_items_; tail_ = (tail_ + 1) % max_items_;
if (tail_ == head_) // overrun last item if full if (tail_ == head_) // overrun last item if full
{ {
head_ = (head_ + 1) % max_items_; head_ = (head_ + 1) % max_items_;
++overrun_counter_; ++overrun_counter_;
@ -109,5 +109,5 @@ private:
other.overrun_counter_ = 0; other.overrun_counter_ = 0;
} }
}; };
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

4
include/spdlog/details/console_globals.h
View File

@ -24,5 +24,5 @@ struct console_nullmutex {
return s_mutex; return s_mutex;
} }
}; };
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

8
include/spdlog/details/file_helper-inl.h
View File

@ -127,8 +127,8 @@ SPDLOG_INLINE const filename_t &file_helper::filename() const { return filename_
// ".mylog" => (".mylog". "") // ".mylog" => (".mylog". "")
// "my_folder/.mylog" => ("my_folder/.mylog", "") // "my_folder/.mylog" => ("my_folder/.mylog", "")
// "my_folder/.mylog.txt" => ("my_folder/.mylog", ".txt") // "my_folder/.mylog.txt" => ("my_folder/.mylog", ".txt")
SPDLOG_INLINE std::tuple<filename_t, filename_t> SPDLOG_INLINE std::tuple<filename_t, filename_t> file_helper::split_by_extension(
file_helper::split_by_extension(const filename_t &fname) { const filename_t &fname) {
auto ext_index = fname.rfind('.'); auto ext_index = fname.rfind('.');
// no valid extension found - return whole path and empty string as // no valid extension found - return whole path and empty string as
@ -147,5 +147,5 @@ file_helper::split_by_extension(const filename_t &fname) {
return std::make_tuple(fname.substr(0, ext_index), fname.substr(ext_index)); return std::make_tuple(fname.substr(0, ext_index), fname.substr(ext_index));
} }
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

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

@ -53,8 +53,8 @@ private:
filename_t filename_; filename_t filename_;
file_event_handlers event_handlers_; file_event_handlers event_handlers_;
}; };
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
#include "file_helper-inl.h" #include "file_helper-inl.h"

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

@ -53,14 +53,10 @@ SPDLOG_CONSTEXPR_FUNC unsigned int count_digits_fallback(T n) {
// Integer division is slow so do it for a group of four digits instead // Integer division is slow so do it for a group of four digits instead
// of for every digit. The idea comes from the talk by Alexandrescu // of for every digit. The idea comes from the talk by Alexandrescu
// "Three Optimization Tips for C++". See speed-test for a comparison. // "Three Optimization Tips for C++". See speed-test for a comparison.
if (n < 10) if (n < 10) return count;
return count; if (n < 100) return count + 1;
if (n < 100) if (n < 1000) return count + 2;
return count + 1; if (n < 10000) return count + 3;
if (n < 1000)
return count + 2;
if (n < 10000)
return count + 3;
n /= 10000u; n /= 10000u;
count += 4; count += 4;
} }
@ -86,11 +82,11 @@ inline unsigned int count_digits(T n) {
} }
inline void pad2(int n, memory_buf_t &dest) { inline void pad2(int n, memory_buf_t &dest) {
if (n >= 0 && n < 100) // 0-99 if (n >= 0 && n < 100) // 0-99
{ {
dest.push_back(static_cast<char>('0' + n / 10)); dest.push_back(static_cast<char>('0' + n / 10));
dest.push_back(static_cast<char>('0' + n % 10)); dest.push_back(static_cast<char>('0' + n % 10));
} else // unlikely, but just in case, let fmt deal with it } else // unlikely, but just in case, let fmt deal with it
{ {
fmt_lib::format_to(std::back_inserter(dest), SPDLOG_FMT_STRING("{:02}"), n); fmt_lib::format_to(std::back_inserter(dest), SPDLOG_FMT_STRING("{:02}"), n);
} }
@ -140,6 +136,6 @@ inline ToDuration time_fraction(log_clock::time_point tp) {
return duration_cast<ToDuration>(duration) - duration_cast<ToDuration>(secs); return duration_cast<ToDuration>(duration) - duration_cast<ToDuration>(secs);
} }
} // namespace fmt_helper } // namespace fmt_helper
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

4
include/spdlog/details/log_msg-inl.h
View File

@ -40,5 +40,5 @@ SPDLOG_INLINE log_msg::log_msg(string_view_t a_logger_name,
spdlog::string_view_t msg) spdlog::string_view_t msg)
: log_msg(os::now(), source_loc{}, a_logger_name, lvl, msg) {} : log_msg(os::now(), source_loc{}, a_logger_name, lvl, msg) {}
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

4
include/spdlog/details/log_msg.h
View File

@ -32,8 +32,8 @@ struct SPDLOG_API log_msg {
source_loc source; source_loc source;
string_view_t payload; string_view_t payload;
}; };
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
#include "log_msg-inl.h" #include "log_msg-inl.h"

4
include/spdlog/details/log_msg_buffer-inl.h
View File

@ -50,5 +50,5 @@ SPDLOG_INLINE void log_msg_buffer::update_string_views() {
payload = string_view_t{buffer.data() + logger_name.size(), payload.size()}; payload = string_view_t{buffer.data() + logger_name.size(), payload.size()};
} }
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

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

@ -24,8 +24,8 @@ public:
log_msg_buffer &operator=(log_msg_buffer &&other) SPDLOG_NOEXCEPT; log_msg_buffer &operator=(log_msg_buffer &&other) SPDLOG_NOEXCEPT;
}; };
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
#include "log_msg_buffer-inl.h" #include "log_msg_buffer-inl.h"

4
include/spdlog/details/mpmc_blocking_q.h
View File

@ -173,5 +173,5 @@ private:
spdlog::details::circular_q<T> q_; spdlog::details::circular_q<T> q_;
std::atomic<size_t> discard_counter_{0}; std::atomic<size_t> discard_counter_{0};
}; };
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

6
include/spdlog/details/null_mutex.h
View File

@ -27,9 +27,9 @@ struct null_atomic_int {
int exchange(int new_value, std::memory_order = std::memory_order_relaxed) { int exchange(int new_value, std::memory_order = std::memory_order_relaxed) {
std::swap(new_value, value); std::swap(new_value, value);
return new_value; // return value before the call return new_value; // return value before the call
} }
}; };
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

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

@ -23,9 +23,9 @@
#ifdef _WIN32 #ifdef _WIN32
#include <spdlog/details/windows_include.h> #include <spdlog/details/windows_include.h>
#include <fileapi.h> // for FlushFileBuffers #include <fileapi.h> // for FlushFileBuffers
#include <io.h> // for _get_osfhandle, _isatty, _fileno #include <io.h> // for _get_osfhandle, _isatty, _fileno
#include <process.h> // for _get_pid #include <process.h> // for _get_pid
#ifdef __MINGW32__ #ifdef __MINGW32__
#include <share.h> #include <share.h>
@ -36,37 +36,37 @@
#include <limits> #include <limits>
#endif #endif
#include <direct.h> // for _mkdir/_wmkdir #include <direct.h> // for _mkdir/_wmkdir
#else // unix #else // unix
#include <fcntl.h> #include <fcntl.h>
#include <unistd.h> #include <unistd.h>
#ifdef __linux__ #ifdef __linux__
#include <sys/syscall.h> //Use gettid() syscall under linux to get thread id #include <sys/syscall.h> //Use gettid() syscall under linux to get thread id
#elif defined(_AIX) #elif defined(_AIX)
#include <pthread.h> // for pthread_getthrds_np #include <pthread.h> // for pthread_getthrds_np
#elif defined(__DragonFly__) || defined(__FreeBSD__) #elif defined(__DragonFly__) || defined(__FreeBSD__)
#include <pthread_np.h> // for pthread_getthreadid_np #include <pthread_np.h> // for pthread_getthreadid_np
#elif defined(__NetBSD__) #elif defined(__NetBSD__)
#include <lwp.h> // for _lwp_self #include <lwp.h> // for _lwp_self
#elif defined(__sun) #elif defined(__sun)
#include <thread.h> // for thr_self #include <thread.h> // for thr_self
#endif #endif
#endif // unix #endif // unix
#if defined __APPLE__ #if defined __APPLE__
#include <AvailabilityMacros.h> #include <AvailabilityMacros.h>
#endif #endif
#ifndef __has_feature // Clang - feature checking macros. #ifndef __has_feature // Clang - feature checking macros.
#define __has_feature(x) 0 // Compatibility with non-clang compilers. #define __has_feature(x) 0 // Compatibility with non-clang compilers.
#endif #endif
namespace spdlog { namespace spdlog {
@ -74,7 +74,6 @@ namespace details {
namespace os { namespace os {
SPDLOG_INLINE spdlog::log_clock::time_point now() SPDLOG_NOEXCEPT { SPDLOG_INLINE spdlog::log_clock::time_point now() SPDLOG_NOEXCEPT {
#if defined __linux__ && defined SPDLOG_CLOCK_COARSE #if defined __linux__ && defined SPDLOG_CLOCK_COARSE
timespec ts; timespec ts;
::clock_gettime(CLOCK_REALTIME_COARSE, &ts); ::clock_gettime(CLOCK_REALTIME_COARSE, &ts);
@ -87,7 +86,6 @@ SPDLOG_INLINE spdlog::log_clock::time_point now() SPDLOG_NOEXCEPT {
#endif #endif
} }
SPDLOG_INLINE std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT { SPDLOG_INLINE std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT {
#ifdef _WIN32 #ifdef _WIN32
std::tm tm; std::tm tm;
::localtime_s(&tm, &time_tt); ::localtime_s(&tm, &time_tt);
@ -104,7 +102,6 @@ SPDLOG_INLINE std::tm localtime() SPDLOG_NOEXCEPT {
} }
SPDLOG_INLINE std::tm gmtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT { SPDLOG_INLINE std::tm gmtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT {
#ifdef _WIN32 #ifdef _WIN32
std::tm tm; std::tm tm;
::gmtime_s(&tm, &time_tt); ::gmtime_s(&tm, &time_tt);
@ -137,7 +134,7 @@ SPDLOG_INLINE bool fopen_s(FILE **fp, const filename_t &filename, const filename
} }
} }
#endif #endif
#else // unix #else // unix
#if defined(SPDLOG_PREVENT_CHILD_FD) #if defined(SPDLOG_PREVENT_CHILD_FD)
const int mode_flag = mode == SPDLOG_FILENAME_T("ab") ? O_APPEND : O_TRUNC; const int mode_flag = mode == SPDLOG_FILENAME_T("ab") ? O_APPEND : O_TRUNC;
const int fd = const int fd =
@ -186,7 +183,7 @@ SPDLOG_INLINE bool path_exists(const filename_t &filename) SPDLOG_NOEXCEPT {
auto attribs = ::GetFileAttributesA(filename.c_str()); auto attribs = ::GetFileAttributesA(filename.c_str());
#endif #endif
return attribs != INVALID_FILE_ATTRIBUTES; return attribs != INVALID_FILE_ATTRIBUTES;
#else // common linux/unix all have the stat system call #else // common linux/unix all have the stat system call
struct stat buffer; struct stat buffer;
return (::stat(filename.c_str(), &buffer) == 0); return (::stat(filename.c_str(), &buffer) == 0);
#endif #endif
@ -205,20 +202,20 @@ SPDLOG_INLINE size_t filesize(FILE *f) {
} }
#if defined(_WIN32) && !defined(__CYGWIN__) #if defined(_WIN32) && !defined(__CYGWIN__)
int fd = ::_fileno(f); int fd = ::_fileno(f);
#if defined(_WIN64) // 64 bits #if defined(_WIN64) // 64 bits
__int64 ret = ::_filelengthi64(fd); __int64 ret = ::_filelengthi64(fd);
if (ret >= 0) { if (ret >= 0) {
return static_cast<size_t>(ret); return static_cast<size_t>(ret);
} }
#else // windows 32 bits #else // windows 32 bits
long ret = ::_filelength(fd); long ret = ::_filelength(fd);
if (ret >= 0) { if (ret >= 0) {
return static_cast<size_t>(ret); return static_cast<size_t>(ret);
} }
#endif #endif
#else // unix #else // unix
// OpenBSD and AIX doesn't compile with :: before the fileno(..) // OpenBSD and AIX doesn't compile with :: before the fileno(..)
#if defined(__OpenBSD__) || defined(_AIX) #if defined(__OpenBSD__) || defined(_AIX)
int fd = fileno(f); int fd = fileno(f);
@ -232,7 +229,7 @@ SPDLOG_INLINE size_t filesize(FILE *f) {
if (::fstat64(fd, &st) == 0) { if (::fstat64(fd, &st) == 0) {
return static_cast<size_t>(st.st_size); return static_cast<size_t>(st.st_size);
} }
#else // other unix or linux 32 bits or cygwin #else // other unix or linux 32 bits or cygwin
struct stat st; struct stat st;
if (::fstat(fd, &st) == 0) { if (::fstat(fd, &st) == 0) {
return static_cast<size_t>(st.st_size); return static_cast<size_t>(st.st_size);
@ -240,7 +237,7 @@ SPDLOG_INLINE size_t filesize(FILE *f) {
#endif #endif
#endif #endif
throw_spdlog_ex("Failed getting file size from fd", errno); throw_spdlog_ex("Failed getting file size from fd", errno);
return 0; // will not be reached. return 0; // will not be reached.
} }
#ifdef _MSC_VER #ifdef _MSC_VER
@ -249,7 +246,6 @@ SPDLOG_INLINE size_t filesize(FILE *f) {
// Return utc offset in minutes or throw spdlog_ex on failure // Return utc offset in minutes or throw spdlog_ex on failure
SPDLOG_INLINE int utc_minutes_offset(const std::tm &tm) { SPDLOG_INLINE int utc_minutes_offset(const std::tm &tm) {
#ifdef _WIN32 #ifdef _WIN32
#if _WIN32_WINNT < _WIN32_WINNT_WS08 #if _WIN32_WINNT < _WIN32_WINNT_WS08
TIME_ZONE_INFORMATION tzinfo; TIME_ZONE_INFORMATION tzinfo;
@ -258,8 +254,7 @@ SPDLOG_INLINE int utc_minutes_offset(const std::tm &tm) {
DYNAMIC_TIME_ZONE_INFORMATION tzinfo; DYNAMIC_TIME_ZONE_INFORMATION tzinfo;
auto rv = ::GetDynamicTimeZoneInformation(&tzinfo); auto rv = ::GetDynamicTimeZoneInformation(&tzinfo);
#endif #endif
if (rv == TIME_ZONE_ID_INVALID) if (rv == TIME_ZONE_ID_INVALID) throw_spdlog_ex("Failed getting timezone info. ", errno);
throw_spdlog_ex("Failed getting timezone info. ", errno);
int offset = -tzinfo.Bias; int offset = -tzinfo.Bias;
if (tm.tm_isdst) { if (tm.tm_isdst) {
@ -351,7 +346,7 @@ SPDLOG_INLINE size_t _thread_id() SPDLOG_NOEXCEPT {
pthread_threadid_np(nullptr, &tid); pthread_threadid_np(nullptr, &tid);
#endif #endif
return static_cast<size_t>(tid); return static_cast<size_t>(tid);
#else // Default to standard C++11 (other Unix) #else // Default to standard C++11 (other Unix)
return static_cast<size_t>(std::hash<std::thread::id>()(std::this_thread::get_id())); return static_cast<size_t>(std::hash<std::thread::id>()(std::this_thread::get_id()));
#endif #endif
} }
@ -360,7 +355,7 @@ SPDLOG_INLINE size_t _thread_id() SPDLOG_NOEXCEPT {
SPDLOG_INLINE size_t thread_id() SPDLOG_NOEXCEPT { SPDLOG_INLINE size_t thread_id() SPDLOG_NOEXCEPT {
#if defined(SPDLOG_NO_TLS) #if defined(SPDLOG_NO_TLS)
return _thread_id(); return _thread_id();
#else // cache thread id in tls #else // cache thread id in tls
static thread_local const size_t tid = _thread_id(); static thread_local const size_t tid = _thread_id();
return tid; return tid;
#endif #endif
@ -388,7 +383,6 @@ SPDLOG_INLINE std::string filename_to_str(const filename_t &filename) { return f
#endif #endif
SPDLOG_INLINE int pid() SPDLOG_NOEXCEPT { SPDLOG_INLINE int pid() SPDLOG_NOEXCEPT {
#ifdef _WIN32 #ifdef _WIN32
return conditional_static_cast<int>(::GetCurrentProcessId()); return conditional_static_cast<int>(::GetCurrentProcessId());
#else #else
@ -430,7 +424,6 @@ SPDLOG_INLINE bool is_color_terminal() SPDLOG_NOEXCEPT {
// Determine if the terminal attached // Determine if the terminal attached
// Source: https://github.com/agauniyal/rang/ // Source: https://github.com/agauniyal/rang/
SPDLOG_INLINE bool in_terminal(FILE *file) SPDLOG_NOEXCEPT { SPDLOG_INLINE bool in_terminal(FILE *file) SPDLOG_NOEXCEPT {
#ifdef _WIN32 #ifdef _WIN32
return ::_isatty(_fileno(file)) != 0; return ::_isatty(_fileno(file)) != 0;
#else #else
@ -499,8 +492,8 @@ SPDLOG_INLINE void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target) {
throw_spdlog_ex( throw_spdlog_ex(
fmt_lib::format("MultiByteToWideChar failed. Last error: {}", ::GetLastError())); fmt_lib::format("MultiByteToWideChar failed. Last error: {}", ::GetLastError()));
} }
#endif // (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && #endif // (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) &&
// defined(_WIN32) // defined(_WIN32)
// return true on success // return true on success
static SPDLOG_INLINE bool mkdir_(const filename_t &path) { static SPDLOG_INLINE bool mkdir_(const filename_t &path) {
@ -537,7 +530,7 @@ SPDLOG_INLINE bool create_dir(const filename_t &path) {
auto subdir = path.substr(0, token_pos); auto subdir = path.substr(0, token_pos);
if (!subdir.empty() && !path_exists(subdir) && !mkdir_(subdir)) { if (!subdir.empty() && !path_exists(subdir) && !mkdir_(subdir)) {
return false; // return error if failed creating dir return false; // return error if failed creating dir
} }
search_offset = token_pos + 1; search_offset = token_pos + 1;
} while (search_offset < path.size()); } while (search_offset < path.size());
@ -556,17 +549,16 @@ SPDLOG_INLINE filename_t dir_name(const filename_t &path) {
} }
std::string SPDLOG_INLINE getenv(const char *field) { std::string SPDLOG_INLINE getenv(const char *field) {
#if defined(_MSC_VER) #if defined(_MSC_VER)
#if defined(__cplusplus_winrt) #if defined(__cplusplus_winrt)
return std::string{}; // not supported under uwp return std::string{}; // not supported under uwp
#else #else
size_t len = 0; size_t len = 0;
char buf[128]; char buf[128];
bool ok = ::getenv_s(&len, buf, sizeof(buf), field) == 0; bool ok = ::getenv_s(&len, buf, sizeof(buf), field) == 0;
return ok ? buf : std::string{}; return ok ? buf : std::string{};
#endif #endif
#else // revert to getenv #else // revert to getenv
char *buf = ::getenv(field); char *buf = ::getenv(field);
return buf ? buf : std::string{}; return buf ? buf : std::string{};
#endif #endif
@ -582,6 +574,6 @@ SPDLOG_INLINE bool fsync(FILE *fp) {
#endif #endif
} }
} // namespace os } // namespace os
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

8
include/spdlog/details/os.h
View File

@ -3,7 +3,7 @@
#pragma once #pragma once
#include <ctime> // std::time_t #include <ctime> // std::time_t
#include <spdlog/common.h> #include <spdlog/common.h>
namespace spdlog { namespace spdlog {
@ -114,9 +114,9 @@ SPDLOG_API std::string getenv(const char *field);
// Return true on success. // Return true on success.
SPDLOG_API bool fsync(FILE *fp); SPDLOG_API bool fsync(FILE *fp);
} // namespace os } // namespace os
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
#include "os-inl.h" #include "os-inl.h"

4
include/spdlog/details/periodic_worker-inl.h
View File

@ -22,5 +22,5 @@ SPDLOG_INLINE periodic_worker::~periodic_worker() {
} }
} }
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

6
include/spdlog/details/periodic_worker.h
View File

@ -32,7 +32,7 @@ public:
for (;;) { for (;;) {
std::unique_lock<std::mutex> lock(this->mutex_); std::unique_lock<std::mutex> lock(this->mutex_);
if (this->cv_.wait_for(lock, interval, [this] { return !this->active_; })) { if (this->cv_.wait_for(lock, interval, [this] { return !this->active_; })) {
return; // active_ == false, so exit this thread return; // active_ == false, so exit this thread
} }
callback_fun(); callback_fun();
} }
@ -49,8 +49,8 @@ private:
std::mutex mutex_; std::mutex mutex_;
std::condition_variable cv_; std::condition_variable cv_;
}; };
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
#include "periodic_worker-inl.h" #include "periodic_worker-inl.h"

13
include/spdlog/details/registry-inl.h
View File

@ -19,7 +19,7 @@
#else #else
#include <spdlog/sinks/ansicolor_sink.h> #include <spdlog/sinks/ansicolor_sink.h>
#endif #endif
#endif // SPDLOG_DISABLE_DEFAULT_LOGGER #endif // SPDLOG_DISABLE_DEFAULT_LOGGER
#include <chrono> #include <chrono>
#include <functional> #include <functional>
@ -32,7 +32,6 @@ namespace details {
SPDLOG_INLINE registry::registry() SPDLOG_INLINE registry::registry()
: formatter_(new pattern_formatter()) { : formatter_(new pattern_formatter()) {
#ifndef SPDLOG_DISABLE_DEFAULT_LOGGER #ifndef SPDLOG_DISABLE_DEFAULT_LOGGER
// create default logger (ansicolor_stdout_sink_mt or wincolor_stdout_sink_mt in windows). // create default logger (ansicolor_stdout_sink_mt or wincolor_stdout_sink_mt in windows).
#ifdef _WIN32 #ifdef _WIN32
@ -45,7 +44,7 @@ SPDLOG_INLINE registry::registry()
default_logger_ = std::make_shared<spdlog::logger>(default_logger_name, std::move(color_sink)); default_logger_ = std::make_shared<spdlog::logger>(default_logger_name, std::move(color_sink));
loggers_[default_logger_name] = default_logger_; loggers_[default_logger_name] = default_logger_;
#endif // SPDLOG_DISABLE_DEFAULT_LOGGER #endif // SPDLOG_DISABLE_DEFAULT_LOGGER
} }
SPDLOG_INLINE registry::~registry() = default; SPDLOG_INLINE registry::~registry() = default;
@ -170,8 +169,8 @@ SPDLOG_INLINE void registry::set_error_handler(err_handler handler) {
err_handler_ = std::move(handler); err_handler_ = std::move(handler);
} }
SPDLOG_INLINE void SPDLOG_INLINE void registry::apply_all(
registry::apply_all(const std::function<void(const std::shared_ptr<logger>)> &fun) { const std::function<void(const std::shared_ptr<logger>)> &fun) {
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_) {
fun(l.second); fun(l.second);
@ -262,5 +261,5 @@ SPDLOG_INLINE void registry::register_logger_(std::shared_ptr<logger> new_logger
loggers_[logger_name] = std::move(new_logger); loggers_[logger_name] = std::move(new_logger);
} }
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

4
include/spdlog/details/registry.h
View File

@ -114,8 +114,8 @@ private:
size_t backtrace_n_messages_ = 0; size_t backtrace_n_messages_ = 0;
}; };
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
#include "registry-inl.h" #include "registry-inl.h"

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

@ -19,4 +19,4 @@ struct synchronous_factory {
return new_logger; return new_logger;
} }
}; };
} // namespace spdlog } // namespace spdlog

12
include/spdlog/details/tcp_client-windows.h
View File

@ -66,9 +66,9 @@ public:
struct addrinfo hints {}; struct addrinfo hints {};
ZeroMemory(&hints, sizeof(hints)); ZeroMemory(&hints, sizeof(hints));
hints.ai_family = AF_UNSPEC; // To work with IPv4, IPv6, and so on hints.ai_family = AF_UNSPEC; // To work with IPv4, IPv6, and so on
hints.ai_socktype = SOCK_STREAM; // TCP hints.ai_socktype = SOCK_STREAM; // TCP
hints.ai_flags = AI_NUMERICSERV; // port passed as as numeric value hints.ai_flags = AI_NUMERICSERV; // port passed as as numeric value
hints.ai_protocol = 0; hints.ai_protocol = 0;
auto port_str = std::to_string(port); auto port_str = std::to_string(port);
@ -123,7 +123,7 @@ public:
throw_winsock_error_("send failed", last_error); throw_winsock_error_("send failed", last_error);
} }
if (write_result == 0) // (probably should not happen but in any case..) if (write_result == 0) // (probably should not happen but in any case..)
{ {
break; break;
} }
@ -131,5 +131,5 @@ public:
} }
} }
}; };
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

12
include/spdlog/details/tcp_client.h
View File

@ -44,9 +44,9 @@ public:
close(); close();
struct addrinfo hints {}; struct addrinfo hints {};
memset(&hints, 0, sizeof(struct addrinfo)); memset(&hints, 0, sizeof(struct addrinfo));
hints.ai_family = AF_UNSPEC; // To work with IPv4, IPv6, and so on hints.ai_family = AF_UNSPEC; // To work with IPv4, IPv6, and so on
hints.ai_socktype = SOCK_STREAM; // TCP hints.ai_socktype = SOCK_STREAM; // TCP
hints.ai_flags = AI_NUMERICSERV; // port passed as as numeric value hints.ai_flags = AI_NUMERICSERV; // port passed as as numeric value
hints.ai_protocol = 0; hints.ai_protocol = 0;
auto port_str = std::to_string(port); auto port_str = std::to_string(port);
@ -115,7 +115,7 @@ public:
throw_spdlog_ex("write(2) failed", errno); throw_spdlog_ex("write(2) failed", errno);
} }
if (write_result == 0) // (probably should not happen but in any case..) if (write_result == 0) // (probably should not happen but in any case..)
{ {
break; break;
} }
@ -123,5 +123,5 @@ public:
} }
} }
}; };
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

37
include/spdlog/details/thread_pool-inl.h
View File

@ -19,8 +19,9 @@ SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items,
std::function<void()> on_thread_stop) std::function<void()> on_thread_stop)
: q_(q_max_items) { : q_(q_max_items) {
if (threads_n == 0 || threads_n > 1000) { if (threads_n == 0 || threads_n > 1000) {
throw_spdlog_ex("spdlog::thread_pool(): invalid threads_n param (valid " throw_spdlog_ex(
"range is 1-1000)"); "spdlog::thread_pool(): invalid threads_n param (valid "
"range is 1-1000)");
} }
for (size_t i = 0; i < threads_n; i++) { for (size_t i = 0; i < threads_n; i++) {
threads_.emplace_back([this, on_thread_start, on_thread_stop] { threads_.emplace_back([this, on_thread_start, on_thread_stop] {
@ -101,26 +102,26 @@ bool SPDLOG_INLINE thread_pool::process_next_msg_() {
q_.dequeue(incoming_async_msg); q_.dequeue(incoming_async_msg);
switch (incoming_async_msg.msg_type) { switch (incoming_async_msg.msg_type) {
case async_msg_type::log: { case async_msg_type::log: {
incoming_async_msg.worker_ptr->backend_sink_it_(incoming_async_msg); incoming_async_msg.worker_ptr->backend_sink_it_(incoming_async_msg);
return true; return true;
} }
case async_msg_type::flush: { case async_msg_type::flush: {
incoming_async_msg.worker_ptr->backend_flush_(); incoming_async_msg.worker_ptr->backend_flush_();
return true; return true;
} }
case async_msg_type::terminate: { case async_msg_type::terminate: {
return false; return false;
} }
default: { default: {
assert(false); assert(false);
} }
} }
return true; return true;
} }
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

6
include/spdlog/details/thread_pool.h
View File

@ -47,7 +47,7 @@ struct async_msg : log_msg_buffer {
worker_ptr = std::move(other.worker_ptr); worker_ptr = std::move(other.worker_ptr);
return *this; return *this;
} }
#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
@ -109,8 +109,8 @@ private:
bool process_next_msg_(); bool process_next_msg_();
}; };
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
#include "thread_pool-inl.h" #include "thread_pool-inl.h"

4
include/spdlog/details/udp_client-windows.h
View File

@ -94,5 +94,5 @@ public:
} }
} }
}; };
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

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

@ -77,5 +77,5 @@ public:
} }
} }
}; };
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

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

@ -1,7 +1,7 @@
#pragma once #pragma once
#ifndef NOMINMAX #ifndef NOMINMAX
#define NOMINMAX // prevent windows redefining min/max #define NOMINMAX // prevent windows redefining min/max
#endif #endif
#ifndef WIN32_LEAN_AND_MEAN #ifndef WIN32_LEAN_AND_MEAN

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

@ -56,7 +56,7 @@ private:
It begin_, end_; It begin_, end_;
size_t size_per_line_; size_t size_per_line_;
}; };
} // namespace details } // namespace details
// create a dump_info that wraps the given container // create a dump_info that wraps the given container
template <typename Container> template <typename Container>
@ -71,8 +71,8 @@ inline details::dump_info<typename Container::const_iterator> to_hex(const Conta
#if __cpp_lib_span >= 202002L #if __cpp_lib_span >= 202002L
template <typename Value, size_t Extent> template <typename Value, size_t Extent>
inline details::dump_info<typename std::span<Value, Extent>::iterator> inline details::dump_info<typename std::span<Value, Extent>::iterator> to_hex(
to_hex(const std::span<Value, Extent> &container, size_t size_per_line = 32) { const std::span<Value, Extent> &container, size_t size_per_line = 32) {
using Container = std::span<Value, Extent>; using Container = std::span<Value, Extent>;
static_assert(sizeof(typename Container::value_type) == 1, static_assert(sizeof(typename Container::value_type) == 1,
"sizeof(Container::value_type) != 1"); "sizeof(Container::value_type) != 1");
@ -84,12 +84,13 @@ to_hex(const std::span<Value, Extent> &container, size_t size_per_line = 32) {
// create dump_info from ranges // create dump_info from ranges
template <typename It> template <typename It>
inline details::dump_info<It> inline details::dump_info<It> to_hex(const It range_begin,
to_hex(const It range_begin, const It range_end, size_t size_per_line = 32) { const It range_end,
size_t size_per_line = 32) {
return details::dump_info<It>(range_begin, range_end, size_per_line); return details::dump_info<It>(range_begin, range_end, size_per_line);
} }
} // namespace spdlog } // namespace spdlog
namespace namespace
#ifdef SPDLOG_USE_STD_FORMAT #ifdef SPDLOG_USE_STD_FORMAT
@ -105,7 +106,7 @@ struct formatter<spdlog::details::dump_info<T>, char> {
bool put_newlines = true; bool put_newlines = true;
bool put_delimiters = true; bool put_delimiters = true;
bool use_uppercase = false; bool use_uppercase = false;
bool put_positions = true; // position on start of each line bool put_positions = true; // position on start of each line
bool show_ascii = false; bool show_ascii = false;
// parse the format string flags // parse the format string flags
@ -114,24 +115,24 @@ struct formatter<spdlog::details::dump_info<T>, char> {
auto it = ctx.begin(); auto it = ctx.begin();
while (it != ctx.end() && *it != '}') { while (it != ctx.end() && *it != '}') {
switch (*it) { switch (*it) {
case 'X': case 'X':
use_uppercase = true; use_uppercase = true;
break; break;
case 's': case 's':
put_delimiters = false; put_delimiters = false;
break; break;
case 'p': case 'p':
put_positions = false; put_positions = false;
break; break;
case 'n': case 'n':
put_newlines = false; put_newlines = false;
show_ascii = false; show_ascii = false;
break; break;
case 'a': case 'a':
if (put_newlines) { if (put_newlines) {
show_ascii = true; show_ascii = true;
} }
break; break;
} }
++it; ++it;
@ -185,7 +186,7 @@ struct formatter<spdlog::details::dump_info<T>, char> {
*inserter++ = hex_chars[(ch >> 4) & 0x0f]; *inserter++ = hex_chars[(ch >> 4) & 0x0f];
*inserter++ = hex_chars[ch & 0x0f]; *inserter++ = hex_chars[ch & 0x0f];
} }
if (show_ascii) // add ascii to last line if (show_ascii) // add ascii to last line
{ {
if (the_range.get_end() - the_range.get_begin() > size_per_line) { if (the_range.get_end() - the_range.get_begin() > size_per_line) {
auto blank_num = size_per_line - (the_range.get_end() - start_of_line); auto blank_num = size_per_line - (the_range.get_end() - start_of_line);
@ -220,4 +221,4 @@ struct formatter<spdlog::details::dump_info<T>, char> {
} }
} }
}; };
} // namespace std } // namespace std

4
include/spdlog/fmt/fmt.h
View File

@ -10,7 +10,7 @@
// By default spdlog include its own copy. // By default spdlog include its own copy.
// //
#if defined(SPDLOG_USE_STD_FORMAT) // SPDLOG_USE_STD_FORMAT is defined - use std::format #if defined(SPDLOG_USE_STD_FORMAT) // SPDLOG_USE_STD_FORMAT is defined - use std::format
#include <format> #include <format>
#elif !defined(SPDLOG_FMT_EXTERNAL) #elif !defined(SPDLOG_FMT_EXTERNAL)
#if !defined(SPDLOG_COMPILED_LIB) && !defined(FMT_HEADER_ONLY) #if !defined(SPDLOG_COMPILED_LIB) && !defined(FMT_HEADER_ONLY)
@ -27,7 +27,7 @@
#include <spdlog/fmt/bundled/core.h> #include <spdlog/fmt/bundled/core.h>
#include <spdlog/fmt/bundled/format.h> #include <spdlog/fmt/bundled/format.h>
#else // SPDLOG_FMT_EXTERNAL is defined - use external fmtlib #else // SPDLOG_FMT_EXTERNAL is defined - use external fmtlib
#include <fmt/core.h> #include <fmt/core.h>
#include <fmt/format.h> #include <fmt/format.h>
#endif #endif

2
include/spdlog/formatter.h
View File

@ -14,4 +14,4 @@ public:
virtual void format(const details::log_msg &msg, memory_buf_t &dest) = 0; virtual void format(const details::log_msg &msg, memory_buf_t &dest) = 0;
virtual std::unique_ptr<formatter> clone() const = 0; virtual std::unique_ptr<formatter> clone() const = 0;
}; };
} // namespace spdlog } // namespace spdlog

2
include/spdlog/fwd.h
View File

@ -15,4 +15,4 @@ namespace level {
enum level_enum : int; enum level_enum : int;
} }
} // namespace spdlog } // namespace spdlog

11
include/spdlog/logger-inl.h
View File

@ -74,7 +74,7 @@ SPDLOG_INLINE void logger::set_formatter(std::unique_ptr<formatter> f) {
if (std::next(it) == sinks_.end()) { if (std::next(it) == sinks_.end()) {
// last element - we can be move it. // last element - we can be move it.
(*it)->set_formatter(std::move(f)); (*it)->set_formatter(std::move(f));
break; // to prevent clang-tidy warning break; // to prevent clang-tidy warning
} else { } else {
(*it)->set_formatter(f->clone()); (*it)->set_formatter(f->clone());
} }
@ -121,8 +121,9 @@ SPDLOG_INLINE std::shared_ptr<logger> logger::clone(std::string logger_name) {
} }
// protected methods // protected methods
SPDLOG_INLINE void SPDLOG_INLINE void logger::log_it_(const spdlog::details::log_msg &log_msg,
logger::log_it_(const spdlog::details::log_msg &log_msg, bool log_enabled, bool traceback_enabled) { bool log_enabled,
bool traceback_enabled) {
if (log_enabled) { if (log_enabled) {
sink_it_(log_msg); sink_it_(log_msg);
} }
@ -185,7 +186,7 @@ SPDLOG_INLINE void logger::err_handler_(const std::string &msg) {
auto tm_time = details::os::localtime(system_clock::to_time_t(now)); auto tm_time = details::os::localtime(system_clock::to_time_t(now));
char date_buf[64]; char date_buf[64];
std::strftime(date_buf, sizeof(date_buf), "%Y-%m-%d %H:%M:%S", &tm_time); std::strftime(date_buf, sizeof(date_buf), "%Y-%m-%d %H:%M:%S", &tm_time);
#if defined(USING_R) && defined(R_R_H) // if in R environment #if defined(USING_R) && defined(R_R_H) // if in R environment
REprintf("[*** LOG ERROR #%04zu ***] [%s] [%s] %s\n", err_counter, date_buf, name().c_str(), REprintf("[*** LOG ERROR #%04zu ***] [%s] [%s] %s\n", err_counter, date_buf, name().c_str(),
msg.c_str()); msg.c_str());
#else #else
@ -194,4 +195,4 @@ SPDLOG_INLINE void logger::err_handler_(const std::string &msg) {
#endif #endif
} }
} }
} // namespace spdlog } // namespace spdlog

16
include/spdlog/logger.h
View File

@ -98,8 +98,10 @@ public:
log(loc, lvl, "{}", msg); log(loc, lvl, "{}", msg);
} }
void void log(log_clock::time_point log_time,
log(log_clock::time_point log_time, source_loc loc, level::level_enum lvl, string_view_t msg) { source_loc loc,
level::level_enum lvl,
string_view_t msg) {
bool log_enabled = should_log(lvl); bool log_enabled = should_log(lvl);
bool traceback_enabled = tracer_.enabled(); bool traceback_enabled = tracer_.enabled();
if (!log_enabled && !traceback_enabled) { if (!log_enabled && !traceback_enabled) {
@ -164,8 +166,10 @@ public:
log(source_loc{}, lvl, fmt, std::forward<Args>(args)...); log(source_loc{}, lvl, fmt, std::forward<Args>(args)...);
} }
void void log(log_clock::time_point log_time,
log(log_clock::time_point log_time, source_loc loc, level::level_enum lvl, wstring_view_t msg) { source_loc loc,
level::level_enum lvl,
wstring_view_t msg) {
bool log_enabled = should_log(lvl); bool log_enabled = should_log(lvl);
bool traceback_enabled = tracer_.enabled(); bool traceback_enabled = tracer_.enabled();
if (!log_enabled && !traceback_enabled) { if (!log_enabled && !traceback_enabled) {
@ -351,7 +355,7 @@ protected:
} }
SPDLOG_LOGGER_CATCH(loc) SPDLOG_LOGGER_CATCH(loc)
} }
#endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT #endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT
// log the given message (if the given log level is high enough), // log the given message (if the given log level is high enough),
// and save backtrace (if backtrace is enabled). // and save backtrace (if backtrace is enabled).
@ -368,7 +372,7 @@ protected:
void swap(logger &a, logger &b); void swap(logger &a, logger &b);
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
#include "logger-inl.h" #include "logger-inl.h"

423
include/spdlog/pattern_formatter-inl.h
View File

@ -51,7 +51,7 @@ public:
auto half_pad = remaining_pad_ / 2; auto half_pad = remaining_pad_ / 2;
auto reminder = remaining_pad_ & 1; auto reminder = remaining_pad_ & 1;
pad_it(half_pad); pad_it(half_pad);
remaining_pad_ = half_pad + reminder; // for the right side remaining_pad_ = half_pad + reminder; // for the right side
} }
} }
@ -525,9 +525,9 @@ public:
dest.push_back('+'); dest.push_back('+');
} }
fmt_helper::pad2(total_minutes / 60, dest); // hours fmt_helper::pad2(total_minutes / 60, dest); // hours
dest.push_back(':'); dest.push_back(':');
fmt_helper::pad2(total_minutes % 60, dest); // minutes fmt_helper::pad2(total_minutes % 60, dest); // minutes
} }
private: private:
@ -689,8 +689,8 @@ public:
#ifdef _MSC_VER #ifdef _MSC_VER
#pragma warning(push) #pragma warning(push)
#pragma warning(disable : 4127) // consider using 'if constexpr' instead #pragma warning(disable : 4127) // consider using 'if constexpr' instead
#endif // _MSC_VER #endif // _MSC_VER
static const char *basename(const char *filename) { static const char *basename(const char *filename) {
// if the size is 2 (1 character + null terminator) we can use the more efficient strrchr // if the size is 2 (1 character + null terminator) we can use the more efficient strrchr
// the branch will be elided by optimizations // the branch will be elided by optimizations
@ -708,7 +708,7 @@ public:
} }
#ifdef _MSC_VER #ifdef _MSC_VER
#pragma warning(pop) #pragma warning(pop)
#endif // _MSC_VER #endif // _MSC_VER
void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override {
if (msg.source.empty()) { if (msg.source.empty()) {
@ -867,7 +867,7 @@ private:
memory_buf_t cached_datetime_; memory_buf_t cached_datetime_;
}; };
} // namespace details } // namespace details
SPDLOG_INLINE pattern_formatter::pattern_formatter(std::string pattern, SPDLOG_INLINE pattern_formatter::pattern_formatter(std::string pattern,
pattern_time_type time_type, pattern_time_type time_type,
@ -954,240 +954,239 @@ SPDLOG_INLINE void pattern_formatter::handle_flag_(char flag, details::padding_i
// process built-in flags // process built-in flags
switch (flag) { switch (flag) {
case ('+'): // default formatter case ('+'): // default formatter
formatters_.push_back(details::make_unique<details::full_formatter>(padding)); formatters_.push_back(details::make_unique<details::full_formatter>(padding));
need_localtime_ = true; need_localtime_ = true;
break; break;
case 'n': // logger name case 'n': // logger name
formatters_.push_back(details::make_unique<details::name_formatter<Padder>>(padding)); formatters_.push_back(details::make_unique<details::name_formatter<Padder>>(padding));
break; break;
case 'l': // level case 'l': // level
formatters_.push_back(details::make_unique<details::level_formatter<Padder>>(padding)); formatters_.push_back(details::make_unique<details::level_formatter<Padder>>(padding));
break; break;
case 'L': // short level case 'L': // short level
formatters_.push_back( formatters_.push_back(
details::make_unique<details::short_level_formatter<Padder>>(padding)); details::make_unique<details::short_level_formatter<Padder>>(padding));
break; break;
case ('t'): // thread id case ('t'): // thread id
formatters_.push_back(details::make_unique<details::t_formatter<Padder>>(padding)); formatters_.push_back(details::make_unique<details::t_formatter<Padder>>(padding));
break; break;
case ('v'): // the message text case ('v'): // the message text
formatters_.push_back(details::make_unique<details::v_formatter<Padder>>(padding)); formatters_.push_back(details::make_unique<details::v_formatter<Padder>>(padding));
break; break;
case ('a'): // weekday case ('a'): // weekday
formatters_.push_back(details::make_unique<details::a_formatter<Padder>>(padding)); formatters_.push_back(details::make_unique<details::a_formatter<Padder>>(padding));
need_localtime_ = true; need_localtime_ = true;
break; break;
case ('A'): // short weekday case ('A'): // short weekday
formatters_.push_back(details::make_unique<details::A_formatter<Padder>>(padding)); formatters_.push_back(details::make_unique<details::A_formatter<Padder>>(padding));
need_localtime_ = true; need_localtime_ = true;
break; break;
case ('b'): case ('b'):
case ('h'): // month case ('h'): // month
formatters_.push_back(details::make_unique<details::b_formatter<Padder>>(padding)); formatters_.push_back(details::make_unique<details::b_formatter<Padder>>(padding));
need_localtime_ = true; need_localtime_ = true;
break; break;
case ('B'): // short month case ('B'): // short month
formatters_.push_back(details::make_unique<details::B_formatter<Padder>>(padding)); formatters_.push_back(details::make_unique<details::B_formatter<Padder>>(padding));
need_localtime_ = true; need_localtime_ = true;
break; break;
case ('c'): // datetime case ('c'): // datetime
formatters_.push_back(details::make_unique<details::c_formatter<Padder>>(padding)); formatters_.push_back(details::make_unique<details::c_formatter<Padder>>(padding));
need_localtime_ = true; need_localtime_ = true;
break; break;
case ('C'): // year 2 digits case ('C'): // year 2 digits
formatters_.push_back(details::make_unique<details::C_formatter<Padder>>(padding)); formatters_.push_back(details::make_unique<details::C_formatter<Padder>>(padding));
need_localtime_ = true; need_localtime_ = true;
break; break;
case ('Y'): // year 4 digits case ('Y'): // year 4 digits
formatters_.push_back(details::make_unique<details::Y_formatter<Padder>>(padding)); formatters_.push_back(details::make_unique<details::Y_formatter<Padder>>(padding));
need_localtime_ = true; need_localtime_ = true;
break; break;
case ('D'): case ('D'):
case ('x'): // datetime MM/DD/YY case ('x'): // datetime MM/DD/YY
formatters_.push_back(details::make_unique<details::D_formatter<Padder>>(padding)); formatters_.push_back(details::make_unique<details::D_formatter<Padder>>(padding));
need_localtime_ = true; need_localtime_ = true;
break; break;
case ('m'): // month 1-12 case ('m'): // month 1-12
formatters_.push_back(details::make_unique<details::m_formatter<Padder>>(padding)); formatters_.push_back(details::make_unique<details::m_formatter<Padder>>(padding));
need_localtime_ = true; need_localtime_ = true;
break; break;
case ('d'): // day of month 1-31 case ('d'): // day of month 1-31
formatters_.push_back(details::make_unique<details::d_formatter<Padder>>(padding)); formatters_.push_back(details::make_unique<details::d_formatter<Padder>>(padding));
need_localtime_ = true; need_localtime_ = true;
break; break;
case ('H'): // hours 24 case ('H'): // hours 24
formatters_.push_back(details::make_unique<details::H_formatter<Padder>>(padding)); formatters_.push_back(details::make_unique<details::H_formatter<Padder>>(padding));
need_localtime_ = true; need_localtime_ = true;
break; break;
case ('I'): // hours 12 case ('I'): // hours 12
formatters_.push_back(details::make_unique<details::I_formatter<Padder>>(padding)); formatters_.push_back(details::make_unique<details::I_formatter<Padder>>(padding));
need_localtime_ = true; need_localtime_ = true;
break; break;
case ('M'): // minutes case ('M'): // minutes
formatters_.push_back(details::make_unique<details::M_formatter<Padder>>(padding)); formatters_.push_back(details::make_unique<details::M_formatter<Padder>>(padding));
need_localtime_ = true; need_localtime_ = true;
break; break;
case ('S'): // seconds case ('S'): // seconds
formatters_.push_back(details::make_unique<details::S_formatter<Padder>>(padding)); formatters_.push_back(details::make_unique<details::S_formatter<Padder>>(padding));
need_localtime_ = true; need_localtime_ = true;
break; break;
case ('e'): // milliseconds case ('e'): // milliseconds
formatters_.push_back(details::make_unique<details::e_formatter<Padder>>(padding)); formatters_.push_back(details::make_unique<details::e_formatter<Padder>>(padding));
break; break;
case ('f'): // microseconds case ('f'): // microseconds
formatters_.push_back(details::make_unique<details::f_formatter<Padder>>(padding)); formatters_.push_back(details::make_unique<details::f_formatter<Padder>>(padding));
break; break;
case ('F'): // nanoseconds case ('F'): // nanoseconds
formatters_.push_back(details::make_unique<details::F_formatter<Padder>>(padding)); formatters_.push_back(details::make_unique<details::F_formatter<Padder>>(padding));
break; break;
case ('E'): // seconds since epoch case ('E'): // seconds since epoch
formatters_.push_back(details::make_unique<details::E_formatter<Padder>>(padding)); formatters_.push_back(details::make_unique<details::E_formatter<Padder>>(padding));
break; break;
case ('p'): // am/pm case ('p'): // am/pm
formatters_.push_back(details::make_unique<details::p_formatter<Padder>>(padding)); formatters_.push_back(details::make_unique<details::p_formatter<Padder>>(padding));
need_localtime_ = true; need_localtime_ = true;
break; break;
case ('r'): // 12 hour clock 02:55:02 pm case ('r'): // 12 hour clock 02:55:02 pm
formatters_.push_back(details::make_unique<details::r_formatter<Padder>>(padding)); formatters_.push_back(details::make_unique<details::r_formatter<Padder>>(padding));
need_localtime_ = true; need_localtime_ = true;
break; break;
case ('R'): // 24-hour HH:MM time case ('R'): // 24-hour HH:MM time
formatters_.push_back(details::make_unique<details::R_formatter<Padder>>(padding)); formatters_.push_back(details::make_unique<details::R_formatter<Padder>>(padding));
need_localtime_ = true; need_localtime_ = true;
break; break;
case ('T'): case ('T'):
case ('X'): // ISO 8601 time format (HH:MM:SS) case ('X'): // ISO 8601 time format (HH:MM:SS)
formatters_.push_back(details::make_unique<details::T_formatter<Padder>>(padding)); formatters_.push_back(details::make_unique<details::T_formatter<Padder>>(padding));
need_localtime_ = true; need_localtime_ = true;
break; break;
case ('z'): // timezone case ('z'): // timezone
formatters_.push_back(details::make_unique<details::z_formatter<Padder>>(padding)); formatters_.push_back(details::make_unique<details::z_formatter<Padder>>(padding));
need_localtime_ = true; need_localtime_ = true;
break; break;
case ('P'): // pid case ('P'): // pid
formatters_.push_back(details::make_unique<details::pid_formatter<Padder>>(padding)); formatters_.push_back(details::make_unique<details::pid_formatter<Padder>>(padding));
break; break;
case ('^'): // color range start case ('^'): // color range start
formatters_.push_back(details::make_unique<details::color_start_formatter>(padding)); formatters_.push_back(details::make_unique<details::color_start_formatter>(padding));
break; break;
case ('$'): // color range end case ('$'): // color range end
formatters_.push_back(details::make_unique<details::color_stop_formatter>(padding)); formatters_.push_back(details::make_unique<details::color_stop_formatter>(padding));
break; break;
case ('@'): // source location (filename:filenumber) case ('@'): // source location (filename:filenumber)
formatters_.push_back( formatters_.push_back(
details::make_unique<details::source_location_formatter<Padder>>(padding)); details::make_unique<details::source_location_formatter<Padder>>(padding));
break; break;
case ('s'): // short source filename - without directory name case ('s'): // short source filename - without directory name
formatters_.push_back( formatters_.push_back(
details::make_unique<details::short_filename_formatter<Padder>>(padding)); details::make_unique<details::short_filename_formatter<Padder>>(padding));
break; break;
case ('g'): // full source filename case ('g'): // full source filename
formatters_.push_back( formatters_.push_back(
details::make_unique<details::source_filename_formatter<Padder>>(padding)); details::make_unique<details::source_filename_formatter<Padder>>(padding));
break; break;
case ('#'): // source line number case ('#'): // source line number
formatters_.push_back( formatters_.push_back(
details::make_unique<details::source_linenum_formatter<Padder>>(padding)); details::make_unique<details::source_linenum_formatter<Padder>>(padding));
break; break;
case ('!'): // source funcname case ('!'): // source funcname
formatters_.push_back(
details::make_unique<details::source_funcname_formatter<Padder>>(padding));
break;
case ('%'): // % char
formatters_.push_back(details::make_unique<details::ch_formatter>('%'));
break;
case ('u'): // elapsed time since last log message in nanos
formatters_.push_back(
details::make_unique<details::elapsed_formatter<Padder, std::chrono::nanoseconds>>(
padding));
break;
case ('i'): // elapsed time since last log message in micros
formatters_.push_back(
details::make_unique<details::elapsed_formatter<Padder, std::chrono::microseconds>>(
padding));
break;
case ('o'): // elapsed time since last log message in millis
formatters_.push_back(
details::make_unique<details::elapsed_formatter<Padder, std::chrono::milliseconds>>(
padding));
break;
case ('O'): // elapsed time since last log message in seconds
formatters_.push_back(
details::make_unique<details::elapsed_formatter<Padder, std::chrono::seconds>>(
padding));
break;
default: // Unknown flag appears as is
auto unknown_flag = details::make_unique<details::aggregate_formatter>();
if (!padding.truncate_) {
unknown_flag->add_ch('%');
unknown_flag->add_ch(flag);
formatters_.push_back((std::move(unknown_flag)));
}
// fix issue #1617 (prev char was '!' and should have been treated as funcname flag instead
// of truncating flag) spdlog::set_pattern("[%10!] %v") => "[ main] some message"
// spdlog::set_pattern("[%3!!] %v") => "[mai] some message"
else {
padding.truncate_ = false;
formatters_.push_back( formatters_.push_back(
details::make_unique<details::source_funcname_formatter<Padder>>(padding)); details::make_unique<details::source_funcname_formatter<Padder>>(padding));
unknown_flag->add_ch(flag); break;
formatters_.push_back((std::move(unknown_flag)));
}
break; case ('%'): // % char
formatters_.push_back(details::make_unique<details::ch_formatter>('%'));
break;
case ('u'): // elapsed time since last log message in nanos
formatters_.push_back(
details::make_unique<details::elapsed_formatter<Padder, std::chrono::nanoseconds>>(
padding));
break;
case ('i'): // elapsed time since last log message in micros
formatters_.push_back(
details::make_unique<details::elapsed_formatter<Padder, std::chrono::microseconds>>(
padding));
break;
case ('o'): // elapsed time since last log message in millis
formatters_.push_back(
details::make_unique<details::elapsed_formatter<Padder, std::chrono::milliseconds>>(
padding));
break;
case ('O'): // elapsed time since last log message in seconds
formatters_.push_back(
details::make_unique<details::elapsed_formatter<Padder, std::chrono::seconds>>(
padding));
break;
default: // Unknown flag appears as is
auto unknown_flag = details::make_unique<details::aggregate_formatter>();
if (!padding.truncate_) {
unknown_flag->add_ch('%');
unknown_flag->add_ch(flag);
formatters_.push_back((std::move(unknown_flag)));
}
// fix issue #1617 (prev char was '!' and should have been treated as funcname flag
// instead of truncating flag) spdlog::set_pattern("[%10!] %v") => "[ main] some
// message" spdlog::set_pattern("[%3!!] %v") => "[mai] some message"
else {
padding.truncate_ = false;
formatters_.push_back(
details::make_unique<details::source_funcname_formatter<Padder>>(padding));
unknown_flag->add_ch(flag);
formatters_.push_back((std::move(unknown_flag)));
}
break;
} }
} }
// Extract given pad spec (e.g. %8X, %=8X, %-8!X, %8!X, %=8!X, %-8!X, %+8!X) // Extract given pad spec (e.g. %8X, %=8X, %-8!X, %8!X, %=8!X, %-8!X, %+8!X)
// Advance the given it pass the end of the padding spec found (if any) // Advance the given it pass the end of the padding spec found (if any)
// Return padding. // Return padding.
SPDLOG_INLINE details::padding_info SPDLOG_INLINE details::padding_info pattern_formatter::handle_padspec_(
pattern_formatter::handle_padspec_(std::string::const_iterator &it, std::string::const_iterator &it, std::string::const_iterator end) {
std::string::const_iterator end) {
using details::padding_info; using details::padding_info;
using details::scoped_padder; using details::scoped_padder;
const size_t max_width = 64; const size_t max_width = 64;
@ -1197,21 +1196,21 @@ pattern_formatter::handle_padspec_(std::string::const_iterator &it,
padding_info::pad_side side; padding_info::pad_side side;
switch (*it) { switch (*it) {
case '-': case '-':
side = padding_info::pad_side::right; side = padding_info::pad_side::right;
++it; ++it;
break; break;
case '=': case '=':
side = padding_info::pad_side::center; side = padding_info::pad_side::center;
++it; ++it;
break; break;
default: default:
side = details::padding_info::pad_side::left; side = details::padding_info::pad_side::left;
break; break;
} }
if (it == end || !std::isdigit(static_cast<unsigned char>(*it))) { if (it == end || !std::isdigit(static_cast<unsigned char>(*it))) {
return padding_info{}; // no padding if no digit found here return padding_info{}; // no padding if no digit found here
} }
auto width = static_cast<size_t>(*it) - '0'; auto width = static_cast<size_t>(*it) - '0';
@ -1237,7 +1236,7 @@ SPDLOG_INLINE void pattern_formatter::compile_pattern_(const std::string &patter
formatters_.clear(); formatters_.clear();
for (auto it = pattern.begin(); it != end; ++it) { for (auto it = pattern.begin(); it != end; ++it) {
if (*it == '%') { if (*it == '%') {
if (user_chars) // append user chars found so far if (user_chars) // append user chars found so far
{ {
formatters_.push_back(std::move(user_chars)); formatters_.push_back(std::move(user_chars));
} }
@ -1253,7 +1252,7 @@ SPDLOG_INLINE void pattern_formatter::compile_pattern_(const std::string &patter
} else { } else {
break; break;
} }
} else // chars not following the % sign should be displayed as is } else // chars not following the % sign should be displayed as is
{ {
if (!user_chars) { if (!user_chars) {
user_chars = details::make_unique<details::aggregate_formatter>(); user_chars = details::make_unique<details::aggregate_formatter>();
@ -1261,9 +1260,9 @@ SPDLOG_INLINE void pattern_formatter::compile_pattern_(const std::string &patter
user_chars->add_ch(*it); user_chars->add_ch(*it);
} }
} }
if (user_chars) // append raw chars found so far if (user_chars) // append raw chars found so far
{ {
formatters_.push_back(std::move(user_chars)); formatters_.push_back(std::move(user_chars));
} }
} }
} // namespace spdlog } // namespace spdlog

9
include/spdlog/pattern_formatter.h
View File

@ -43,14 +43,15 @@ public:
: padinfo_(padinfo) {} : padinfo_(padinfo) {}
flag_formatter() = default; flag_formatter() = default;
virtual ~flag_formatter() = default; virtual ~flag_formatter() = default;
virtual void virtual void format(const details::log_msg &msg,
format(const details::log_msg &msg, const std::tm &tm_time, memory_buf_t &dest) = 0; const std::tm &tm_time,
memory_buf_t &dest) = 0;
protected: protected:
padding_info padinfo_; padding_info padinfo_;
}; };
} // namespace details } // namespace details
class SPDLOG_API custom_flag_formatter : public details::flag_formatter { class SPDLOG_API custom_flag_formatter : public details::flag_formatter {
public: public:
@ -110,7 +111,7 @@ private:
void compile_pattern_(const std::string &pattern); void compile_pattern_(const std::string &pattern);
}; };
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
#include "pattern_formatter-inl.h" #include "pattern_formatter-inl.h"

44
include/spdlog/sinks/android_sink.h
View File

@ -52,7 +52,7 @@ protected:
// See system/core/liblog/logger_write.c for explanation of return value // See system/core/liblog/logger_write.c for explanation of return value
int ret = android_log(priority, tag_.c_str(), msg_output); int ret = android_log(priority, tag_.c_str(), msg_output);
if (ret == -EPERM) { if (ret == -EPERM) {
return; // !__android_log_is_loggable return; // !__android_log_is_loggable
} }
int retry_count = 0; int retry_count = 0;
while ((ret == -11 /*EAGAIN*/) && (retry_count < SPDLOG_ANDROID_RETRIES)) { while ((ret == -11 /*EAGAIN*/) && (retry_count < SPDLOG_ANDROID_RETRIES)) {
@ -74,33 +74,33 @@ private:
// __android_log_buf_write, if user explicitly provides a non-default log buffer. Otherwise, // __android_log_buf_write, if user explicitly provides a non-default log buffer. Otherwise,
// when using the default log buffer, always log via __android_log_write. // when using the default log buffer, always log via __android_log_write.
template <int ID = BufferID> template <int ID = BufferID>
typename std::enable_if<ID == static_cast<int>(log_id::LOG_ID_MAIN), int>::type typename std::enable_if<ID == static_cast<int>(log_id::LOG_ID_MAIN), int>::type android_log(
android_log(int prio, const char *tag, const char *text) { int prio, const char *tag, const char *text) {
return __android_log_write(prio, tag, text); return __android_log_write(prio, tag, text);
} }
template <int ID = BufferID> template <int ID = BufferID>
typename std::enable_if<ID != static_cast<int>(log_id::LOG_ID_MAIN), int>::type typename std::enable_if<ID != static_cast<int>(log_id::LOG_ID_MAIN), int>::type android_log(
android_log(int prio, const char *tag, const char *text) { int prio, const char *tag, const char *text) {
return __android_log_buf_write(ID, prio, tag, text); return __android_log_buf_write(ID, prio, tag, text);
} }
static android_LogPriority convert_to_android_(spdlog::level::level_enum level) { static android_LogPriority convert_to_android_(spdlog::level::level_enum level) {
switch (level) { switch (level) {
case spdlog::level::trace: case spdlog::level::trace:
return ANDROID_LOG_VERBOSE; return ANDROID_LOG_VERBOSE;
case spdlog::level::debug: case spdlog::level::debug:
return ANDROID_LOG_DEBUG; return ANDROID_LOG_DEBUG;
case spdlog::level::info: case spdlog::level::info:
return ANDROID_LOG_INFO; return ANDROID_LOG_INFO;
case spdlog::level::warn: case spdlog::level::warn:
return ANDROID_LOG_WARN; return ANDROID_LOG_WARN;
case spdlog::level::err: case spdlog::level::err:
return ANDROID_LOG_ERROR; return ANDROID_LOG_ERROR;
case spdlog::level::critical: case spdlog::level::critical:
return ANDROID_LOG_FATAL; return ANDROID_LOG_FATAL;
default: default:
return ANDROID_LOG_DEFAULT; return ANDROID_LOG_DEFAULT;
} }
} }
@ -116,7 +116,7 @@ using android_sink_buf_mt = android_sink<std::mutex, BufferId>;
template <int BufferId = log_id::LOG_ID_MAIN> template <int BufferId = log_id::LOG_ID_MAIN>
using android_sink_buf_st = android_sink<details::null_mutex, BufferId>; using android_sink_buf_st = android_sink<details::null_mutex, BufferId>;
} // namespace sinks } // namespace sinks
// Create and register android syslog logger // Create and register android syslog logger
@ -132,6 +132,6 @@ inline std::shared_ptr<logger> android_logger_st(const std::string &logger_name,
return Factory::template create<sinks::android_sink_st>(logger_name, tag); return Factory::template create<sinks::android_sink_st>(logger_name, tag);
} }
} // namespace spdlog } // namespace spdlog
#endif // __ANDROID__ #endif // __ANDROID__

34
include/spdlog/sinks/ansicolor_sink-inl.h
View File

@ -55,7 +55,7 @@ SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::log(const details::log_msg &msg
print_ccode_(reset); print_ccode_(reset);
// after color range // after color range
print_range_(formatted, msg.color_range_end, formatted.size()); print_range_(formatted, msg.color_range_end, formatted.size());
} else // no color } else // no color
{ {
print_range_(formatted, 0, formatted.size()); print_range_(formatted, 0, formatted.size());
} }
@ -75,8 +75,8 @@ SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_pattern(const std::string &
} }
template <typename ConsoleMutex> template <typename ConsoleMutex>
SPDLOG_INLINE void SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_formatter(
ansicolor_sink<ConsoleMutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) { std::unique_ptr<spdlog::formatter> sink_formatter) {
std::lock_guard<mutex_t> lock(mutex_); std::lock_guard<mutex_t> lock(mutex_);
formatter_ = std::move(sink_formatter); formatter_ = std::move(sink_formatter);
} }
@ -89,18 +89,18 @@ SPDLOG_INLINE bool ansicolor_sink<ConsoleMutex>::should_color() {
template <typename ConsoleMutex> template <typename ConsoleMutex>
SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color_mode(color_mode mode) { SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color_mode(color_mode mode) {
switch (mode) { switch (mode) {
case color_mode::always: case color_mode::always:
should_do_colors_ = true; should_do_colors_ = true;
return; return;
case color_mode::automatic: case color_mode::automatic:
should_do_colors_ = should_do_colors_ =
details::os::in_terminal(target_file_) && details::os::is_color_terminal(); details::os::in_terminal(target_file_) && details::os::is_color_terminal();
return; return;
case color_mode::never: case color_mode::never:
should_do_colors_ = false; should_do_colors_ = false;
return; return;
default: default:
should_do_colors_ = false; should_do_colors_ = false;
} }
} }
@ -131,5 +131,5 @@ template <typename ConsoleMutex>
SPDLOG_INLINE ansicolor_stderr_sink<ConsoleMutex>::ansicolor_stderr_sink(color_mode mode) SPDLOG_INLINE ansicolor_stderr_sink<ConsoleMutex>::ansicolor_stderr_sink(color_mode mode)
: ansicolor_sink<ConsoleMutex>(stderr, mode) {} : ansicolor_sink<ConsoleMutex>(stderr, mode) {}
} // namespace sinks } // namespace sinks
} // namespace spdlog } // namespace spdlog

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

@ -107,8 +107,8 @@ using ansicolor_stdout_sink_st = ansicolor_stdout_sink<details::console_nullmute
using ansicolor_stderr_sink_mt = ansicolor_stderr_sink<details::console_mutex>; using ansicolor_stderr_sink_mt = ansicolor_stderr_sink<details::console_mutex>;
using ansicolor_stderr_sink_st = ansicolor_stderr_sink<details::console_nullmutex>; using ansicolor_stderr_sink_st = ansicolor_stderr_sink<details::console_nullmutex>;
} // namespace sinks } // namespace sinks
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
#include "ansicolor_sink-inl.h" #include "ansicolor_sink-inl.h"

4
include/spdlog/sinks/base_sink-inl.h
View File

@ -18,8 +18,8 @@ SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::base_sink()
: formatter_{details::make_unique<spdlog::pattern_formatter>()} {} : formatter_{details::make_unique<spdlog::pattern_formatter>()} {}
template <typename Mutex> template <typename Mutex>
SPDLOG_INLINE SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::base_sink(
spdlog::sinks::base_sink<Mutex>::base_sink(std::unique_ptr<spdlog::formatter> formatter) std::unique_ptr<spdlog::formatter> formatter)
: formatter_{std::move(formatter)} {} : formatter_{std::move(formatter)} {}
template <typename Mutex> template <typename Mutex>

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

@ -43,8 +43,8 @@ protected:
virtual void set_pattern_(const std::string &pattern); virtual void set_pattern_(const std::string &pattern);
virtual void set_formatter_(std::unique_ptr<spdlog::formatter> sink_formatter); virtual void set_formatter_(std::unique_ptr<spdlog::formatter> sink_formatter);
}; };
} // namespace sinks } // namespace sinks
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
#include "base_sink-inl.h" #include "base_sink-inl.h"

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

@ -38,5 +38,5 @@ SPDLOG_INLINE void basic_file_sink<Mutex>::flush_() {
file_helper_.flush(); file_helper_.flush();
} }
} // namespace sinks } // namespace sinks
} // namespace spdlog } // namespace spdlog

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

@ -35,7 +35,7 @@ private:
using basic_file_sink_mt = basic_file_sink<std::mutex>; using basic_file_sink_mt = basic_file_sink<std::mutex>;
using basic_file_sink_st = basic_file_sink<details::null_mutex>; using basic_file_sink_st = basic_file_sink<details::null_mutex>;
} // namespace sinks } // namespace sinks
// //
// factory functions // factory functions
@ -58,7 +58,7 @@ inline std::shared_ptr<logger> basic_logger_st(const std::string &logger_name,
event_handlers); event_handlers);
} }
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
#include "basic_file_sink-inl.h" #include "basic_file_sink-inl.h"

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

@ -36,7 +36,7 @@ private:
using callback_sink_mt = callback_sink<std::mutex>; using callback_sink_mt = callback_sink<std::mutex>;
using callback_sink_st = callback_sink<details::null_mutex>; using callback_sink_st = callback_sink<details::null_mutex>;
} // namespace sinks } // namespace sinks
// //
// factory functions // factory functions
@ -53,4 +53,4 @@ inline std::shared_ptr<logger> callback_logger_st(const std::string &logger_name
return Factory::template create<sinks::callback_sink_st>(logger_name, callback); return Factory::template create<sinks::callback_sink_st>(logger_name, callback);
} }
} // namespace spdlog } // namespace spdlog

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

@ -195,7 +195,7 @@ using daily_file_format_sink_mt = daily_file_sink<std::mutex, daily_filename_for
using daily_file_format_sink_st = using daily_file_format_sink_st =
daily_file_sink<details::null_mutex, daily_filename_format_calculator>; daily_file_sink<details::null_mutex, daily_filename_format_calculator>;
} // namespace sinks } // namespace sinks
// //
// factory functions // factory functions
@ -213,14 +213,14 @@ inline std::shared_ptr<logger> daily_logger_mt(const std::string &logger_name,
} }
template <typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> inline std::shared_ptr<logger> daily_logger_format_mt(
daily_logger_format_mt(const std::string &logger_name, const std::string &logger_name,
const filename_t &filename, const filename_t &filename,
int hour = 0, int hour = 0,
int minute = 0, int minute = 0,
bool truncate = false, bool truncate = false,
uint16_t max_files = 0, uint16_t max_files = 0,
const file_event_handlers &event_handlers = {}) { const file_event_handlers &event_handlers = {}) {
return Factory::template create<sinks::daily_file_format_sink_mt>( return Factory::template create<sinks::daily_file_format_sink_mt>(
logger_name, filename, hour, minute, truncate, max_files, event_handlers); logger_name, filename, hour, minute, truncate, max_files, event_handlers);
} }
@ -238,15 +238,15 @@ inline std::shared_ptr<logger> daily_logger_st(const std::string &logger_name,
} }
template <typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> inline std::shared_ptr<logger> daily_logger_format_st(
daily_logger_format_st(const std::string &logger_name, const std::string &logger_name,
const filename_t &filename, const filename_t &filename,
int hour = 0, int hour = 0,
int minute = 0, int minute = 0,
bool truncate = false, bool truncate = false,
uint16_t max_files = 0, uint16_t max_files = 0,
const file_event_handlers &event_handlers = {}) { const file_event_handlers &event_handlers = {}) {
return Factory::template create<sinks::daily_file_format_sink_st>( return Factory::template create<sinks::daily_file_format_sink_st>(
logger_name, filename, hour, minute, truncate, max_files, event_handlers); logger_name, filename, hour, minute, truncate, max_files, event_handlers);
} }
} // namespace spdlog } // namespace spdlog

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

@ -77,5 +77,5 @@ protected:
using dist_sink_mt = dist_sink<std::mutex>; using dist_sink_mt = dist_sink<std::mutex>;
using dist_sink_st = dist_sink<details::null_mutex>; using dist_sink_st = dist_sink<details::null_mutex>;
} // namespace sinks } // namespace sinks
} // namespace spdlog } // namespace spdlog

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

@ -88,5 +88,5 @@ protected:
using dup_filter_sink_mt = dup_filter_sink<std::mutex>; using dup_filter_sink_mt = dup_filter_sink<std::mutex>;
using dup_filter_sink_st = dup_filter_sink<details::null_mutex>; using dup_filter_sink_st = dup_filter_sink<details::null_mutex>;
} // namespace sinks } // namespace sinks
} // namespace spdlog } // namespace spdlog

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

@ -164,7 +164,7 @@ private:
using hourly_file_sink_mt = hourly_file_sink<std::mutex>; using hourly_file_sink_mt = hourly_file_sink<std::mutex>;
using hourly_file_sink_st = hourly_file_sink<details::null_mutex>; using hourly_file_sink_st = hourly_file_sink<details::null_mutex>;
} // namespace sinks } // namespace sinks
// //
// factory functions // factory functions
@ -188,4 +188,4 @@ inline std::shared_ptr<logger> hourly_logger_st(const std::string &logger_name,
return Factory::template create<sinks::hourly_file_sink_st>(logger_name, filename, truncate, return Factory::template create<sinks::hourly_file_sink_st>(logger_name, filename, truncate,
max_files, event_handlers); max_files, event_handlers);
} }
} // namespace spdlog } // namespace spdlog

12
include/spdlog/sinks/kafka_sink.h
View File

@ -90,7 +90,7 @@ private:
using kafka_sink_mt = kafka_sink<std::mutex>; using kafka_sink_mt = kafka_sink<std::mutex>;
using kafka_sink_st = kafka_sink<spdlog::details::null_mutex>; using kafka_sink_st = kafka_sink<spdlog::details::null_mutex>;
} // namespace sinks } // namespace sinks
template <typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> kafka_logger_mt(const std::string &logger_name, inline std::shared_ptr<logger> kafka_logger_mt(const std::string &logger_name,
@ -105,15 +105,15 @@ inline std::shared_ptr<logger> kafka_logger_st(const std::string &logger_name,
} }
template <typename Factory = spdlog::async_factory> template <typename Factory = spdlog::async_factory>
inline std::shared_ptr<spdlog::logger> inline std::shared_ptr<spdlog::logger> kafka_logger_async_mt(
kafka_logger_async_mt(std::string logger_name, spdlog::sinks::kafka_sink_config config) { std::string logger_name, spdlog::sinks::kafka_sink_config config) {
return Factory::template create<sinks::kafka_sink_mt>(logger_name, config); return Factory::template create<sinks::kafka_sink_mt>(logger_name, config);
} }
template <typename Factory = spdlog::async_factory> template <typename Factory = spdlog::async_factory>
inline std::shared_ptr<spdlog::logger> inline std::shared_ptr<spdlog::logger> kafka_logger_async_st(
kafka_logger_async_st(std::string logger_name, spdlog::sinks::kafka_sink_config config) { std::string logger_name, spdlog::sinks::kafka_sink_config config) {
return Factory::template create<sinks::kafka_sink_st>(logger_name, config); return Factory::template create<sinks::kafka_sink_st>(logger_name, config);
} }
} // namespace spdlog } // namespace spdlog

24
include/spdlog/sinks/mongo_sink.h
View File

@ -83,26 +83,26 @@ private:
using mongo_sink_mt = mongo_sink<std::mutex>; using mongo_sink_mt = mongo_sink<std::mutex>;
using mongo_sink_st = mongo_sink<spdlog::details::null_mutex>; using mongo_sink_st = mongo_sink<spdlog::details::null_mutex>;
} // namespace sinks } // namespace sinks
template <typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> inline std::shared_ptr<logger> mongo_logger_mt(
mongo_logger_mt(const std::string &logger_name, const std::string &logger_name,
const std::string &db_name, const std::string &db_name,
const std::string &collection_name, const std::string &collection_name,
const std::string &uri = "mongodb://localhost:27017") { const std::string &uri = "mongodb://localhost:27017") {
return Factory::template create<sinks::mongo_sink_mt>(logger_name, db_name, collection_name, return Factory::template create<sinks::mongo_sink_mt>(logger_name, db_name, collection_name,
uri); uri);
} }
template <typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> inline std::shared_ptr<logger> mongo_logger_st(
mongo_logger_st(const std::string &logger_name, const std::string &logger_name,
const std::string &db_name, const std::string &db_name,
const std::string &collection_name, const std::string &collection_name,
const std::string &uri = "mongodb://localhost:27017") { const std::string &uri = "mongodb://localhost:27017") {
return Factory::template create<sinks::mongo_sink_st>(logger_name, db_name, collection_name, return Factory::template create<sinks::mongo_sink_st>(logger_name, db_name, collection_name,
uri); uri);
} }
} // namespace spdlog } // namespace spdlog

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

@ -41,7 +41,7 @@ protected:
} }
memory_buf_t formatted; memory_buf_t formatted;
base_sink<Mutex>::formatter_->format(msg, formatted); base_sink<Mutex>::formatter_->format(msg, formatted);
formatted.push_back('\0'); // add a null terminator for OutputDebugString formatted.push_back('\0'); // add a null terminator for OutputDebugString
#if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) #if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
wmemory_buf_t wformatted; wmemory_buf_t wformatted;
details::os::utf8_to_wstrbuf(string_view_t(formatted.data(), formatted.size()), wformatted); details::os::utf8_to_wstrbuf(string_view_t(formatted.data(), formatted.size()), wformatted);
@ -62,7 +62,7 @@ using msvc_sink_st = msvc_sink<details::null_mutex>;
using windebug_sink_mt = msvc_sink_mt; using windebug_sink_mt = msvc_sink_mt;
using windebug_sink_st = msvc_sink_st; using windebug_sink_st = msvc_sink_st;
} // namespace sinks } // namespace sinks
} // namespace spdlog } // namespace spdlog
#endif #endif

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

@ -22,7 +22,7 @@ protected:
using null_sink_mt = null_sink<details::null_mutex>; using null_sink_mt = null_sink<details::null_mutex>;
using null_sink_st = null_sink<details::null_mutex>; using null_sink_st = null_sink<details::null_mutex>;
} // namespace sinks } // namespace sinks
template <typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> null_logger_mt(const std::string &logger_name) { inline std::shared_ptr<logger> null_logger_mt(const std::string &logger_name) {
@ -38,4 +38,4 @@ inline std::shared_ptr<logger> null_logger_st(const std::string &logger_name) {
return null_logger; return null_logger;
} }
} // namespace spdlog } // namespace spdlog

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

@ -39,5 +39,5 @@ protected:
using ostream_sink_mt = ostream_sink<std::mutex>; using ostream_sink_mt = ostream_sink<std::mutex>;
using ostream_sink_st = ostream_sink<details::null_mutex>; using ostream_sink_st = ostream_sink<details::null_mutex>;
} // namespace sinks } // namespace sinks
} // namespace spdlog } // namespace spdlog

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

@ -167,13 +167,13 @@ protected:
payload = QString::fromLatin1(str.data(), static_cast<int>(str.size())); payload = QString::fromLatin1(str.data(), static_cast<int>(str.size()));
} }
invoke_params params{max_lines_, // max lines invoke_params params{max_lines_, // max lines
qt_text_edit_, // text edit to append to qt_text_edit_, // text edit to append to
std::move(payload), // text to append std::move(payload), // text to append
default_color_, // default color default_color_, // default color
colors_.at(msg.level), // color to apply colors_.at(msg.level), // color to apply
color_range_start, // color range start color_range_start, // color range start
color_range_end}; // color range end color_range_end}; // color range end
QMetaObject::invokeMethod( QMetaObject::invokeMethod(
qt_text_edit_, [params]() { invoke_method_(params); }, Qt::AutoConnection); qt_text_edit_, [params]() { invoke_method_(params); }, Qt::AutoConnection);
@ -193,7 +193,7 @@ protected:
while (document->blockCount() > params.max_lines) { while (document->blockCount() > params.max_lines) {
cursor.select(QTextCursor::BlockUnderCursor); cursor.select(QTextCursor::BlockUnderCursor);
cursor.removeSelectedText(); cursor.removeSelectedText();
cursor.deleteChar(); // delete the newline after the block cursor.deleteChar(); // delete the newline after the block
} }
cursor.movePosition(QTextCursor::End); cursor.movePosition(QTextCursor::End);
@ -232,7 +232,7 @@ using qt_sink_mt = qt_sink<std::mutex>;
using qt_sink_st = qt_sink<details::null_mutex>; using qt_sink_st = qt_sink<details::null_mutex>;
using qt_color_sink_mt = qt_color_sink<std::mutex>; using qt_color_sink_mt = qt_color_sink<std::mutex>;
using qt_color_sink_st = qt_color_sink<details::null_mutex>; using qt_color_sink_st = qt_color_sink<details::null_mutex>;
} // namespace sinks } // namespace sinks
// //
// Factory functions // Factory functions
@ -269,14 +269,16 @@ inline std::shared_ptr<logger> qt_logger_st(const std::string &logger_name,
} }
// log to QObject // log to QObject
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,
qt_logger_mt(const std::string &logger_name, QObject *qt_object, const std::string &meta_method) { 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,
qt_logger_st(const std::string &logger_name, QObject *qt_object, const std::string &meta_method) { 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);
} }
@ -299,4 +301,4 @@ inline std::shared_ptr<logger> qt_color_logger_st(const std::string &logger_name
false, is_utf8); false, is_utf8);
} }
} // namespace spdlog } // namespace spdlog

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

@ -62,6 +62,6 @@ private:
using ringbuffer_sink_mt = ringbuffer_sink<std::mutex>; using ringbuffer_sink_mt = ringbuffer_sink<std::mutex>;
using ringbuffer_sink_st = ringbuffer_sink<details::null_mutex>; using ringbuffer_sink_st = ringbuffer_sink<details::null_mutex>;
} // namespace sinks } // namespace sinks
} // namespace spdlog } // namespace spdlog

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

@ -24,12 +24,12 @@ namespace spdlog {
namespace sinks { namespace sinks {
template <typename Mutex> template <typename Mutex>
SPDLOG_INLINE SPDLOG_INLINE rotating_file_sink<Mutex>::rotating_file_sink(
rotating_file_sink<Mutex>::rotating_file_sink(filename_t base_filename, filename_t base_filename,
std::size_t max_size, std::size_t max_size,
std::size_t max_files, std::size_t max_files,
bool rotate_on_open, bool rotate_on_open,
const file_event_handlers &event_handlers) 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),
@ -42,7 +42,7 @@ rotating_file_sink<Mutex>::rotating_file_sink(filename_t base_filename,
throw_spdlog_ex("rotating sink constructor: max_files arg cannot exceed 200000"); throw_spdlog_ex("rotating sink constructor: max_files arg cannot exceed 200000");
} }
file_helper_.open(calc_filename(base_filename_, 0)); file_helper_.open(calc_filename(base_filename_, 0));
current_size_ = file_helper_.size(); // expensive. called only once current_size_ = file_helper_.size(); // expensive. called only once
if (rotate_on_open && current_size_ > 0) { if (rotate_on_open && current_size_ > 0) {
rotate_(); rotate_();
current_size_ = 0; current_size_ = 0;
@ -119,7 +119,7 @@ SPDLOG_INLINE void rotating_file_sink<Mutex>::rotate_() {
details::os::sleep_for_millis(100); details::os::sleep_for_millis(100);
if (!rename_file_(src, target)) { if (!rename_file_(src, target)) {
file_helper_.reopen( file_helper_.reopen(
true); // truncate the log file anyway to prevent it to grow beyond its limit! true); // truncate the log file anyway to prevent it to grow beyond its limit!
current_size_ = 0; current_size_ = 0;
throw_spdlog_ex("rotating_file_sink: failed renaming " + filename_to_str(src) + throw_spdlog_ex("rotating_file_sink: failed renaming " + filename_to_str(src) +
" to " + filename_to_str(target), " to " + filename_to_str(target),
@ -140,5 +140,5 @@ SPDLOG_INLINE bool rotating_file_sink<Mutex>::rename_file_(const filename_t &src
return details::os::rename(src_filename, target_filename) == 0; return details::os::rename(src_filename, target_filename) == 0;
} }
} // namespace sinks } // namespace sinks
} // namespace spdlog } // namespace spdlog

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

@ -55,7 +55,7 @@ private:
using rotating_file_sink_mt = rotating_file_sink<std::mutex>; using rotating_file_sink_mt = rotating_file_sink<std::mutex>;
using rotating_file_sink_st = rotating_file_sink<details::null_mutex>; using rotating_file_sink_st = rotating_file_sink<details::null_mutex>;
} // namespace sinks } // namespace sinks
// //
// factory functions // factory functions
@ -82,7 +82,7 @@ inline std::shared_ptr<logger> rotating_logger_st(const std::string &logger_name
return Factory::template create<sinks::rotating_file_sink_st>( return Factory::template create<sinks::rotating_file_sink_st>(
logger_name, filename, max_file_size, max_files, rotate_on_open, event_handlers); logger_name, filename, max_file_size, max_files, rotate_on_open, event_handlers);
} }
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
#include "rotating_file_sink-inl.h" #include "rotating_file_sink-inl.h"

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

@ -26,8 +26,8 @@ protected:
level_t level_{level::trace}; level_t level_{level::trace};
}; };
} // namespace sinks } // namespace sinks
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
#include "sink-inl.h" #include "sink-inl.h"

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

@ -35,4 +35,4 @@ SPDLOG_INLINE std::shared_ptr<logger> stderr_color_st(const std::string &logger_
color_mode mode) { color_mode mode) {
return Factory::template create<sinks::stderr_color_sink_st>(logger_name, mode); return Factory::template create<sinks::stderr_color_sink_st>(logger_name, mode);
} }
} // namespace spdlog } // namespace spdlog

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

@ -24,7 +24,7 @@ using stdout_color_sink_st = ansicolor_stdout_sink_st;
using stderr_color_sink_mt = ansicolor_stderr_sink_mt; using stderr_color_sink_mt = ansicolor_stderr_sink_mt;
using stderr_color_sink_st = ansicolor_stderr_sink_st; using stderr_color_sink_st = ansicolor_stderr_sink_st;
#endif #endif
} // namespace sinks } // namespace sinks
template <typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
std::shared_ptr<logger> stdout_color_mt(const std::string &logger_name, std::shared_ptr<logger> stdout_color_mt(const std::string &logger_name,
@ -42,7 +42,7 @@ template <typename Factory = spdlog::synchronous_factory>
std::shared_ptr<logger> stderr_color_st(const std::string &logger_name, std::shared_ptr<logger> stderr_color_st(const std::string &logger_name,
color_mode mode = color_mode::automatic); color_mode mode = color_mode::automatic);
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
#include "stdout_color_sinks-inl.h" #include "stdout_color_sinks-inl.h"

24
include/spdlog/sinks/stdout_sinks-inl.h
View File

@ -16,13 +16,13 @@
// so instead we use ::FileWrite // so instead we use ::FileWrite
#include <spdlog/details/windows_include.h> #include <spdlog/details/windows_include.h>
#ifndef _USING_V110_SDK71_ // fileapi.h doesn't exist in winxp #ifndef _USING_V110_SDK71_ // fileapi.h doesn't exist in winxp
#include <fileapi.h> // WriteFile (..) #include <fileapi.h> // WriteFile (..)
#endif #endif
#include <io.h> // _get_osfhandle(..) #include <io.h> // _get_osfhandle(..)
#include <stdio.h> // _fileno(..) #include <stdio.h> // _fileno(..)
#endif // WIN32 #endif // WIN32
namespace spdlog { namespace spdlog {
@ -44,7 +44,7 @@ SPDLOG_INLINE stdout_sink_base<ConsoleMutex>::stdout_sink_base(FILE *file)
if (handle_ == INVALID_HANDLE_VALUE && file != stdout && file != stderr) { if (handle_ == INVALID_HANDLE_VALUE && file != stdout && file != stderr) {
throw_spdlog_ex("spdlog::stdout_sink_base: _get_osfhandle() failed", errno); throw_spdlog_ex("spdlog::stdout_sink_base: _get_osfhandle() failed", errno);
} }
#endif // WIN32 #endif // WIN32
} }
template <typename ConsoleMutex> template <typename ConsoleMutex>
@ -68,8 +68,8 @@ SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::log(const details::log_msg &m
memory_buf_t formatted; memory_buf_t formatted;
formatter_->format(msg, formatted); formatter_->format(msg, formatted);
::fwrite(formatted.data(), sizeof(char), formatted.size(), file_); ::fwrite(formatted.data(), sizeof(char), formatted.size(), file_);
#endif // WIN32 #endif // WIN32
::fflush(file_); // flush every line to terminal ::fflush(file_); // flush every line to terminal
} }
template <typename ConsoleMutex> template <typename ConsoleMutex>
@ -85,8 +85,8 @@ SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::set_pattern(const std::string
} }
template <typename ConsoleMutex> template <typename ConsoleMutex>
SPDLOG_INLINE void SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::set_formatter(
stdout_sink_base<ConsoleMutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) { std::unique_ptr<spdlog::formatter> sink_formatter) {
std::lock_guard<mutex_t> lock(mutex_); std::lock_guard<mutex_t> lock(mutex_);
formatter_ = std::move(sink_formatter); formatter_ = std::move(sink_formatter);
} }
@ -101,7 +101,7 @@ template <typename ConsoleMutex>
SPDLOG_INLINE stderr_sink<ConsoleMutex>::stderr_sink() SPDLOG_INLINE stderr_sink<ConsoleMutex>::stderr_sink()
: stdout_sink_base<ConsoleMutex>(stderr) {} : stdout_sink_base<ConsoleMutex>(stderr) {}
} // namespace sinks } // namespace sinks
// factory methods // factory methods
template <typename Factory> template <typename Factory>
@ -123,4 +123,4 @@ template <typename Factory>
SPDLOG_INLINE std::shared_ptr<logger> stderr_logger_st(const std::string &logger_name) { SPDLOG_INLINE std::shared_ptr<logger> stderr_logger_st(const std::string &logger_name) {
return Factory::template create<sinks::stderr_sink_st>(logger_name); return Factory::template create<sinks::stderr_sink_st>(logger_name);
} }
} // namespace spdlog } // namespace spdlog

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

@ -41,7 +41,7 @@ protected:
std::unique_ptr<spdlog::formatter> formatter_; std::unique_ptr<spdlog::formatter> formatter_;
#ifdef _WIN32 #ifdef _WIN32
HANDLE handle_; HANDLE handle_;
#endif // WIN32 #endif // WIN32
}; };
template <typename ConsoleMutex> template <typename ConsoleMutex>
@ -62,7 +62,7 @@ using stdout_sink_st = stdout_sink<details::console_nullmutex>;
using stderr_sink_mt = stderr_sink<details::console_mutex>; using stderr_sink_mt = stderr_sink<details::console_mutex>;
using stderr_sink_st = stderr_sink<details::console_nullmutex>; using stderr_sink_st = stderr_sink<details::console_nullmutex>;
} // namespace sinks } // namespace sinks
// factory methods // factory methods
template <typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
@ -77,7 +77,7 @@ std::shared_ptr<logger> stderr_logger_mt(const std::string &logger_name);
template <typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
std::shared_ptr<logger> stderr_logger_st(const std::string &logger_name); std::shared_ptr<logger> stderr_logger_st(const std::string &logger_name);
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
#include "stdout_sinks-inl.h" #include "stdout_sinks-inl.h"

5
include/spdlog/sinks/syslog_sink.h
View File

@ -18,7 +18,6 @@ namespace sinks {
*/ */
template <typename Mutex> template <typename Mutex>
class syslog_sink : public base_sink<Mutex> { class syslog_sink : public base_sink<Mutex> {
public: public:
syslog_sink(std::string ident, int syslog_option, int syslog_facility, bool enable_formatting) syslog_sink(std::string ident, int syslog_option, int syslog_facility, bool enable_formatting)
: enable_formatting_{enable_formatting}, : enable_formatting_{enable_formatting},
@ -79,7 +78,7 @@ private:
using syslog_sink_mt = syslog_sink<std::mutex>; using syslog_sink_mt = syslog_sink<std::mutex>;
using syslog_sink_st = syslog_sink<details::null_mutex>; using syslog_sink_st = syslog_sink<details::null_mutex>;
} // namespace sinks } // namespace sinks
// Create and register a syslog logger // Create and register a syslog logger
template <typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
@ -101,4 +100,4 @@ inline std::shared_ptr<logger> syslog_logger_st(const std::string &logger_name,
return Factory::template create<sinks::syslog_sink_st>(logger_name, syslog_ident, syslog_option, return Factory::template create<sinks::syslog_sink_st>(logger_name, syslog_ident, syslog_option,
syslog_facility, enable_formatting); syslog_facility, enable_formatting);
} }
} // namespace spdlog } // namespace spdlog

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

@ -102,7 +102,7 @@ protected:
using systemd_sink_mt = systemd_sink<std::mutex>; using systemd_sink_mt = systemd_sink<std::mutex>;
using systemd_sink_st = systemd_sink<details::null_mutex>; using systemd_sink_st = systemd_sink<details::null_mutex>;
} // namespace sinks } // namespace sinks
// Create and register a syslog logger // Create and register a syslog logger
template <typename Factory = spdlog::synchronous_factory> template <typename Factory = spdlog::synchronous_factory>
@ -118,4 +118,4 @@ inline std::shared_ptr<logger> systemd_logger_st(const std::string &logger_name,
bool enable_formatting = false) { bool enable_formatting = false) {
return Factory::template create<sinks::systemd_sink_st>(logger_name, ident, enable_formatting); return Factory::template create<sinks::systemd_sink_st>(logger_name, ident, enable_formatting);
} }
} // namespace spdlog } // namespace spdlog

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

@ -31,7 +31,7 @@ namespace sinks {
struct tcp_sink_config { struct tcp_sink_config {
std::string server_host; std::string server_host;
int server_port; int server_port;
bool lazy_connect = false; // if true connect on first log call instead of on construction bool lazy_connect = false; // if true connect on first log call instead of on construction
tcp_sink_config(std::string host, int port) tcp_sink_config(std::string host, int port)
: server_host{std::move(host)}, : server_host{std::move(host)},
@ -71,5 +71,5 @@ protected:
using tcp_sink_mt = tcp_sink<std::mutex>; using tcp_sink_mt = tcp_sink<std::mutex>;
using tcp_sink_st = tcp_sink<spdlog::details::null_mutex>; using tcp_sink_st = tcp_sink<spdlog::details::null_mutex>;
} // namespace sinks } // namespace sinks
} // namespace spdlog } // namespace spdlog

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

@ -55,7 +55,7 @@ protected:
using udp_sink_mt = udp_sink<std::mutex>; using udp_sink_mt = udp_sink<std::mutex>;
using udp_sink_st = udp_sink<spdlog::details::null_mutex>; using udp_sink_st = udp_sink<spdlog::details::null_mutex>;
} // namespace sinks } // namespace sinks
// //
// factory functions // factory functions
@ -66,4 +66,4 @@ inline std::shared_ptr<logger> udp_logger_mt(const std::string &logger_name,
return Factory::template create<sinks::udp_sink_mt>(logger_name, skin_config); return Factory::template create<sinks::udp_sink_mt>(logger_name, skin_config);
} }
} // namespace spdlog } // namespace spdlog

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

@ -130,7 +130,7 @@ public:
~process_token_t() { ::CloseHandle(token_handle_); } ~process_token_t() { ::CloseHandle(token_handle_); }
} current_process_token( } current_process_token(
::GetCurrentProcess()); // GetCurrentProcess returns pseudohandle, no leak here! ::GetCurrentProcess()); // GetCurrentProcess returns pseudohandle, no leak here!
// Get the required size, this is expected to fail with ERROR_INSUFFICIENT_BUFFER and return // Get the required size, this is expected to fail with ERROR_INSUFFICIENT_BUFFER and return
// the token size // the token size
@ -155,30 +155,30 @@ public:
struct eventlog { struct eventlog {
static WORD get_event_type(details::log_msg const &msg) { static WORD get_event_type(details::log_msg const &msg) {
switch (msg.level) { switch (msg.level) {
case level::trace: case level::trace:
case level::debug: case level::debug:
return EVENTLOG_SUCCESS; return EVENTLOG_SUCCESS;
case level::info: case level::info:
return EVENTLOG_INFORMATION_TYPE; return EVENTLOG_INFORMATION_TYPE;
case level::warn: case level::warn:
return EVENTLOG_WARNING_TYPE; return EVENTLOG_WARNING_TYPE;
case level::err: case level::err:
case level::critical: case level::critical:
case level::off: case level::off:
return EVENTLOG_ERROR_TYPE; return EVENTLOG_ERROR_TYPE;
default: default:
return EVENTLOG_INFORMATION_TYPE; return EVENTLOG_INFORMATION_TYPE;
} }
} }
static WORD get_event_category(details::log_msg const &msg) { return (WORD)msg.level; } static WORD get_event_category(details::log_msg const &msg) { return (WORD)msg.level; }
}; };
} // namespace internal } // namespace internal
/* /*
* Windows Event Log sink * Windows Event Log sink
@ -247,15 +247,14 @@ public:
} }
~win_eventlog_sink() { ~win_eventlog_sink() {
if (hEventLog_) if (hEventLog_) DeregisterEventSource(hEventLog_);
DeregisterEventSource(hEventLog_);
} }
}; };
} // namespace win_eventlog } // namespace win_eventlog
using win_eventlog_sink_mt = win_eventlog::win_eventlog_sink<std::mutex>; using win_eventlog_sink_mt = win_eventlog::win_eventlog_sink<std::mutex>;
using win_eventlog_sink_st = win_eventlog::win_eventlog_sink<details::null_mutex>; using win_eventlog_sink_st = win_eventlog::win_eventlog_sink<details::null_mutex>;
} // namespace sinks } // namespace sinks
} // namespace spdlog } // namespace spdlog

21
include/spdlog/sinks/wincolor_sink-inl.h
View File

@ -20,18 +20,17 @@ SPDLOG_INLINE wincolor_sink<ConsoleMutex>::wincolor_sink(void *out_handle, color
: out_handle_(out_handle), : out_handle_(out_handle),
mutex_(ConsoleMutex::mutex()), mutex_(ConsoleMutex::mutex()),
formatter_(details::make_unique<spdlog::pattern_formatter>()) { formatter_(details::make_unique<spdlog::pattern_formatter>()) {
set_color_mode_impl(mode); set_color_mode_impl(mode);
// set level colors // set level colors
colors_[level::trace] = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; // white colors_[level::trace] = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; // white
colors_[level::debug] = FOREGROUND_GREEN | FOREGROUND_BLUE; // cyan colors_[level::debug] = FOREGROUND_GREEN | FOREGROUND_BLUE; // cyan
colors_[level::info] = FOREGROUND_GREEN; // green colors_[level::info] = FOREGROUND_GREEN; // green
colors_[level::warn] = colors_[level::warn] =
FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY; // intense yellow FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY; // intense yellow
colors_[level::err] = FOREGROUND_RED | FOREGROUND_INTENSITY; // intense red colors_[level::err] = FOREGROUND_RED | FOREGROUND_INTENSITY; // intense red
colors_[level::critical] = BACKGROUND_RED | FOREGROUND_RED | FOREGROUND_GREEN | colors_[level::critical] = BACKGROUND_RED | FOREGROUND_RED | FOREGROUND_GREEN |
FOREGROUND_BLUE | FOREGROUND_BLUE |
FOREGROUND_INTENSITY; // intense white on red background FOREGROUND_INTENSITY; // intense white on red background
colors_[level::off] = 0; colors_[level::off] = 0;
} }
@ -69,7 +68,7 @@ void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::log(const details::log_msg &msg)
// reset to orig colors // reset to orig colors
::SetConsoleTextAttribute(static_cast<HANDLE>(out_handle_), orig_attribs); ::SetConsoleTextAttribute(static_cast<HANDLE>(out_handle_), orig_attribs);
print_range_(formatted, msg.color_range_end, formatted.size()); print_range_(formatted, msg.color_range_end, formatted.size());
} else // print without colors if color range is invalid (or color is disabled) } else // print without colors if color range is invalid (or color is disabled)
{ {
write_to_file_(formatted); write_to_file_(formatted);
} }
@ -126,7 +125,7 @@ wincolor_sink<ConsoleMutex>::set_foreground_color_(std::uint16_t attribs) {
auto ignored = auto ignored =
::SetConsoleTextAttribute(static_cast<HANDLE>(out_handle_), static_cast<WORD>(new_attribs)); ::SetConsoleTextAttribute(static_cast<HANDLE>(out_handle_), static_cast<WORD>(new_attribs));
(void)(ignored); (void)(ignored);
return static_cast<std::uint16_t>(orig_buffer_info.wAttributes); // return orig attribs return static_cast<std::uint16_t>(orig_buffer_info.wAttributes); // return orig attribs
} }
// print a range of formatted message to console // print a range of formatted message to console
@ -160,5 +159,5 @@ SPDLOG_INLINE wincolor_stdout_sink<ConsoleMutex>::wincolor_stdout_sink(color_mod
template <typename ConsoleMutex> template <typename ConsoleMutex>
SPDLOG_INLINE wincolor_stderr_sink<ConsoleMutex>::wincolor_stderr_sink(color_mode mode) SPDLOG_INLINE wincolor_stderr_sink<ConsoleMutex>::wincolor_stderr_sink(color_mode mode)
: wincolor_sink<ConsoleMutex>(::GetStdHandle(STD_ERROR_HANDLE), mode) {} : wincolor_sink<ConsoleMutex>(::GetStdHandle(STD_ERROR_HANDLE), mode) {}
} // namespace sinks } // namespace sinks
} // namespace spdlog } // namespace spdlog

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

@ -74,8 +74,8 @@ using wincolor_stdout_sink_st = wincolor_stdout_sink<details::console_nullmutex>
using wincolor_stderr_sink_mt = wincolor_stderr_sink<details::console_mutex>; using wincolor_stderr_sink_mt = wincolor_stderr_sink<details::console_mutex>;
using wincolor_stderr_sink_st = wincolor_stderr_sink<details::console_nullmutex>; using wincolor_stderr_sink_st = wincolor_stderr_sink<details::console_nullmutex>;
} // namespace sinks } // namespace sinks
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
#include "wincolor_sink-inl.h" #include "wincolor_sink-inl.h"

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

@ -89,4 +89,4 @@ SPDLOG_INLINE void apply_logger_env_levels(std::shared_ptr<logger> logger) {
details::registry::instance().apply_logger_env_levels(std::move(logger)); details::registry::instance().apply_logger_env_levels(std::move(logger));
} }
} // namespace spdlog } // namespace spdlog

16
include/spdlog/spdlog.h
View File

@ -141,8 +141,10 @@ SPDLOG_API void set_default_logger(std::shared_ptr<spdlog::logger> default_logge
SPDLOG_API void apply_logger_env_levels(std::shared_ptr<logger> logger); SPDLOG_API void apply_logger_env_levels(std::shared_ptr<logger> logger);
template <typename... Args> template <typename... Args>
inline void inline void log(source_loc source,
log(source_loc source, level::level_enum lvl, format_string_t<Args...> fmt, Args &&...args) { 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)...);
} }
@ -193,8 +195,10 @@ 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 inline void log(source_loc source,
log(source_loc source, level::level_enum lvl, wformat_string_t<Args...> fmt, Args &&...args) { 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)...);
} }
@ -264,7 +268,7 @@ inline void critical(const T &msg) {
default_logger_raw()->critical(msg); default_logger_raw()->critical(msg);
} }
} // namespace spdlog } // namespace spdlog
// //
// enable/disable log calls at compile time according to global level. // enable/disable log calls at compile time according to global level.
@ -345,4 +349,4 @@ inline void critical(const T &msg) {
#include "spdlog-inl.h" #include "spdlog-inl.h"
#endif #endif
#endif // SPDLOG_H #endif // SPDLOG_H

4
include/spdlog/stopwatch.h
View File

@ -41,7 +41,7 @@ public:
void reset() { start_tp_ = clock::now(); } void reset() { start_tp_ = clock::now(); }
}; };
} // namespace spdlog } // namespace spdlog
// Support for fmt formatting (e.g. "{:012.9}" or just "{}") // Support for fmt formatting (e.g. "{:012.9}" or just "{}")
namespace namespace
@ -59,4 +59,4 @@ struct formatter<spdlog::stopwatch> : formatter<double> {
return formatter<double>::format(sw.elapsed().count(), ctx); return formatter<double>::format(sw.elapsed().count(), ctx);
} }
}; };
} // namespace std } // namespace std

10
src/bundled_fmtlib_format.cpp
View File

@ -31,8 +31,10 @@ template FMT_API void buffer<char>::append(const char *, const char *);
// DEPRECATED! // DEPRECATED!
// There is no correspondent extern template in format.h because of // There is no correspondent extern template in format.h because of
// incompatibility between clang and gcc (#2377). // incompatibility between clang and gcc (#2377).
template FMT_API void template FMT_API void vformat_to(buffer<char> &,
vformat_to(buffer<char> &, string_view, basic_format_args<FMT_BUFFER_CONTEXT(char)>, locale_ref); string_view,
basic_format_args<FMT_BUFFER_CONTEXT(char)>,
locale_ref);
// Explicit instantiations for wchar_t. // Explicit instantiations for wchar_t.
@ -41,7 +43,7 @@ template FMT_API auto decimal_point_impl(locale_ref) -> wchar_t;
template FMT_API void buffer<wchar_t>::append(const wchar_t *, const wchar_t *); template FMT_API void buffer<wchar_t>::append(const wchar_t *, const wchar_t *);
} // namespace detail } // namespace detail
FMT_END_NAMESPACE FMT_END_NAMESPACE
#endif // !SPDLOG_FMT_EXTERNAL #endif // !SPDLOG_FMT_EXTERNAL

16
src/color_sinks.cpp
View File

@ -45,11 +45,11 @@ template SPDLOG_API std::shared_ptr<spdlog::logger>
spdlog::stderr_color_st<spdlog::synchronous_factory>(const std::string &logger_name, spdlog::stderr_color_st<spdlog::synchronous_factory>(const std::string &logger_name,
color_mode mode); color_mode mode);
template SPDLOG_API std::shared_ptr<spdlog::logger> template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stdout_color_mt<spdlog::async_factory>(
spdlog::stdout_color_mt<spdlog::async_factory>(const std::string &logger_name, color_mode mode); const std::string &logger_name, color_mode mode);
template SPDLOG_API std::shared_ptr<spdlog::logger> template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stdout_color_st<spdlog::async_factory>(
spdlog::stdout_color_st<spdlog::async_factory>(const std::string &logger_name, color_mode mode); const std::string &logger_name, color_mode mode);
template SPDLOG_API std::shared_ptr<spdlog::logger> template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stderr_color_mt<spdlog::async_factory>(
spdlog::stderr_color_mt<spdlog::async_factory>(const std::string &logger_name, color_mode mode); const std::string &logger_name, color_mode mode);
template SPDLOG_API std::shared_ptr<spdlog::logger> template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stderr_color_st<spdlog::async_factory>(
spdlog::stderr_color_st<spdlog::async_factory>(const std::string &logger_name, color_mode mode); const std::string &logger_name, color_mode mode);

16
src/stdout_sinks.cpp
View File

@ -27,11 +27,11 @@ spdlog::stderr_logger_mt<spdlog::synchronous_factory>(const std::string &logger_
template SPDLOG_API std::shared_ptr<spdlog::logger> template SPDLOG_API std::shared_ptr<spdlog::logger>
spdlog::stderr_logger_st<spdlog::synchronous_factory>(const std::string &logger_name); spdlog::stderr_logger_st<spdlog::synchronous_factory>(const std::string &logger_name);
template SPDLOG_API std::shared_ptr<spdlog::logger> template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stdout_logger_mt<spdlog::async_factory>(
spdlog::stdout_logger_mt<spdlog::async_factory>(const std::string &logger_name); const std::string &logger_name);
template SPDLOG_API std::shared_ptr<spdlog::logger> template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stdout_logger_st<spdlog::async_factory>(
spdlog::stdout_logger_st<spdlog::async_factory>(const std::string &logger_name); const std::string &logger_name);
template SPDLOG_API std::shared_ptr<spdlog::logger> template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stderr_logger_mt<spdlog::async_factory>(
spdlog::stderr_logger_mt<spdlog::async_factory>(const std::string &logger_name); const std::string &logger_name);
template SPDLOG_API std::shared_ptr<spdlog::logger> template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stderr_logger_st<spdlog::async_factory>(
spdlog::stderr_logger_st<spdlog::async_factory>(const std::string &logger_name); const std::string &logger_name);

2
tests/includes.h
View File

@ -2,7 +2,7 @@
#if defined(__GNUC__) && __GNUC__ == 12 #if defined(__GNUC__) && __GNUC__ == 12
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wmaybe-uninitialized" // Workaround for GCC 12 #pragma GCC diagnostic ignored "-Wmaybe-uninitialized" // Workaround for GCC 12
#endif #endif
#include <catch2/catch_all.hpp> #include <catch2/catch_all.hpp>
#if defined(__GNUC__) && __GNUC__ == 12 #if defined(__GNUC__) && __GNUC__ == 12

2
tests/main.cpp
View File

@ -1,6 +1,6 @@
#if defined(__GNUC__) && __GNUC__ == 12 #if defined(__GNUC__) && __GNUC__ == 12
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wmaybe-uninitialized" // Workaround for GCC 12 #pragma GCC diagnostic ignored "-Wmaybe-uninitialized" // Workaround for GCC 12
#endif #endif
#include <catch2/catch_all.hpp> #include <catch2/catch_all.hpp>

1
tests/test_async.cpp
View File

@ -94,7 +94,6 @@ TEST_CASE("flush", "[async]") {
} }
TEST_CASE("async periodic flush", "[async]") { TEST_CASE("async periodic flush", "[async]") {
auto logger = spdlog::create_async<spdlog::sinks::test_sink_mt>("as"); auto logger = spdlog::create_async<spdlog::sinks::test_sink_mt>("as");
auto test_sink = std::static_pointer_cast<spdlog::sinks::test_sink_mt>(logger->sinks()[0]); auto test_sink = std::static_pointer_cast<spdlog::sinks::test_sink_mt>(logger->sinks()[0]);

9
tests/test_backtrace.cpp
View File

@ -3,7 +3,6 @@
#include "spdlog/async.h" #include "spdlog/async.h"
TEST_CASE("bactrace1", "[bactrace]") { TEST_CASE("bactrace1", "[bactrace]") {
using spdlog::sinks::test_sink_st; using spdlog::sinks::test_sink_st;
auto test_sink = std::make_shared<test_sink_st>(); auto test_sink = std::make_shared<test_sink_st>();
size_t backtrace_size = 5; size_t backtrace_size = 5;
@ -13,8 +12,7 @@ TEST_CASE("bactrace1", "[bactrace]") {
logger.enable_backtrace(backtrace_size); logger.enable_backtrace(backtrace_size);
logger.info("info message"); logger.info("info message");
for (int i = 0; i < 100; i++) for (int i = 0; i < 100; i++) logger.debug("debug message {}", i);
logger.debug("debug message {}", i);
REQUIRE(test_sink->lines().size() == 1); REQUIRE(test_sink->lines().size() == 1);
REQUIRE(test_sink->lines()[0] == "info message"); REQUIRE(test_sink->lines()[0] == "info message");
@ -56,15 +54,14 @@ TEST_CASE("bactrace-async", "[bactrace]") {
logger->enable_backtrace(backtrace_size); logger->enable_backtrace(backtrace_size);
logger->info("info message"); logger->info("info message");
for (int i = 0; i < 100; i++) for (int i = 0; i < 100; i++) logger->debug("debug message {}", i);
logger->debug("debug message {}", i);
sleep_for_millis(100); sleep_for_millis(100);
REQUIRE(test_sink->lines().size() == 1); REQUIRE(test_sink->lines().size() == 1);
REQUIRE(test_sink->lines()[0] == "info message"); REQUIRE(test_sink->lines()[0] == "info message");
logger->dump_backtrace(); logger->dump_backtrace();
sleep_for_millis(100); // give time for the async dump to complete sleep_for_millis(100); // give time for the async dump to complete
REQUIRE(test_sink->lines().size() == backtrace_size + 3); REQUIRE(test_sink->lines().size() == backtrace_size + 3);
REQUIRE(test_sink->lines()[1] == "****************** Backtrace Start ******************"); REQUIRE(test_sink->lines()[1] == "****************** Backtrace Start ******************");
REQUIRE(test_sink->lines()[2] == "debug message 95"); REQUIRE(test_sink->lines()[2] == "debug message 95");

2
tests/test_create_dir.cpp
View File

@ -19,7 +19,7 @@ TEST_CASE("create_dir", "[create_dir]") {
REQUIRE(try_create_dir(SPDLOG_FILENAME_T("test_logs/dir1/dir1"), REQUIRE(try_create_dir(SPDLOG_FILENAME_T("test_logs/dir1/dir1"),
SPDLOG_FILENAME_T("test_logs/dir1/dir1"))); SPDLOG_FILENAME_T("test_logs/dir1/dir1")));
REQUIRE(try_create_dir(SPDLOG_FILENAME_T("test_logs/dir1/dir1"), REQUIRE(try_create_dir(SPDLOG_FILENAME_T("test_logs/dir1/dir1"),
SPDLOG_FILENAME_T("test_logs/dir1/dir1"))); // test existing SPDLOG_FILENAME_T("test_logs/dir1/dir1"))); // test existing
REQUIRE(try_create_dir(SPDLOG_FILENAME_T("test_logs/dir1///dir2//"), REQUIRE(try_create_dir(SPDLOG_FILENAME_T("test_logs/dir1///dir2//"),
SPDLOG_FILENAME_T("test_logs/dir1/dir2"))); SPDLOG_FILENAME_T("test_logs/dir1/dir2")));
REQUIRE(try_create_dir(SPDLOG_FILENAME_T("./test_logs/dir1/dir3"), REQUIRE(try_create_dir(SPDLOG_FILENAME_T("./test_logs/dir1/dir3"),

1
tests/test_daily_logger.cpp
View File

@ -37,7 +37,6 @@ TEST_CASE("daily_logger with dateonly calculator", "[daily_logger]") {
auto logger = spdlog::create<sink_type>("logger", basename, 0, 0); auto logger = spdlog::create<sink_type>("logger", basename, 0, 0);
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
logger->info("Test message {}", i); logger->info("Test message {}", i);
} }
logger->flush(); logger->flush();

2
tests/test_dup_filter.cpp
View File

@ -78,6 +78,6 @@ TEST_CASE("dup_filter_test5", "[dup_filter_sink]") {
dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message2"}); dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message2"});
REQUIRE(test_sink->msg_counter() == REQUIRE(test_sink->msg_counter() ==
3); // skip 2 messages but log the "skipped.." message before message2 3); // skip 2 messages but log the "skipped.." message before message2
REQUIRE(test_sink->lines()[1] == "Skipped 2 duplicate messages.."); REQUIRE(test_sink->lines()[1] == "Skipped 2 duplicate messages..");
} }

9
tests/test_errors.cpp
View File

@ -19,7 +19,7 @@ protected:
}; };
struct custom_ex {}; struct custom_ex {};
#if !defined(SPDLOG_USE_STD_FORMAT) // std formt doesn't fully support tuntime strings #if !defined(SPDLOG_USE_STD_FORMAT) // std formt doesn't fully support tuntime strings
TEST_CASE("default_error_handler", "[errors]") { TEST_CASE("default_error_handler", "[errors]") {
prepare_logdir(); prepare_logdir();
spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_LOG); spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_LOG);
@ -82,7 +82,7 @@ TEST_CASE("async_error_handler", "[errors]") {
logger->info("Good message #1"); logger->info("Good message #1");
logger->info(SPDLOG_FMT_RUNTIME("Bad format msg {} {}"), "xxx"); logger->info(SPDLOG_FMT_RUNTIME("Bad format msg {} {}"), "xxx");
logger->info("Good message #2"); logger->info("Good message #2");
spdlog::drop("logger"); // force logger to drain the queue and shutdown spdlog::drop("logger"); // force logger to drain the queue and shutdown
} }
spdlog::init_thread_pool(128, 1); spdlog::init_thread_pool(128, 1);
require_message_count(SIMPLE_ASYNC_LOG, 2); require_message_count(SIMPLE_ASYNC_LOG, 2);
@ -100,12 +100,11 @@ TEST_CASE("async_error_handler2", "[errors]") {
auto logger = spdlog::create_async<failing_sink>("failed_logger"); auto logger = spdlog::create_async<failing_sink>("failed_logger");
logger->set_error_handler([=](const std::string &) { logger->set_error_handler([=](const std::string &) {
std::ofstream ofs("test_logs/custom_err2.txt"); std::ofstream ofs("test_logs/custom_err2.txt");
if (!ofs) if (!ofs) throw std::runtime_error("Failed open test_logs/custom_err2.txt");
throw std::runtime_error("Failed open test_logs/custom_err2.txt");
ofs << err_msg; ofs << err_msg;
}); });
logger->info("Hello failure"); logger->info("Hello failure");
spdlog::drop("failed_logger"); // force logger to drain the queue and shutdown spdlog::drop("failed_logger"); // force logger to drain the queue and shutdown
} }
spdlog::init_thread_pool(128, 1); spdlog::init_thread_pool(128, 1);

2
tests/test_eventlog.cpp
View File

@ -72,4 +72,4 @@ TEST_CASE("eventlog", "[eventlog]") {
"my critical message", EVENTLOG_ERROR_TYPE); "my critical message", EVENTLOG_ERROR_TYPE);
} }
#endif //_WIN32 #endif //_WIN32

1
tests/test_file_logging.cpp
View File

@ -85,7 +85,6 @@ TEST_CASE("rotating_file_logger2", "[rotating_logger]") {
require_message_count(ROTATING_LOG, 10); require_message_count(ROTATING_LOG, 10);
for (int i = 0; i < 1000; i++) { for (int i = 0; i < 1000; i++) {
logger->info("Test message {}", i); logger->info("Test message {}", i);
} }

1
tests/test_macros.cpp
View File

@ -12,7 +12,6 @@
#define TEST_FILENAME "test_logs/simple_log" #define TEST_FILENAME "test_logs/simple_log"
TEST_CASE("debug and trace w/o format string", "[macros]") { TEST_CASE("debug and trace w/o format string", "[macros]") {
prepare_logdir(); prepare_logdir();
spdlog::filename_t filename = SPDLOG_FILENAME_T(TEST_FILENAME); spdlog::filename_t filename = SPDLOG_FILENAME_T(TEST_FILENAME);

1
tests/test_misc.cpp
View File

@ -3,7 +3,6 @@
template <class T> template <class T>
std::string log_info(const T &what, spdlog::level::level_enum logger_level = spdlog::level::info) { std::string log_info(const T &what, spdlog::level::level_enum logger_level = spdlog::level::info) {
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);

Some files were not shown because too many files have changed in this diff Show More