Mirror/spdlog
1
0
Fork 0
mirror of https://github.com/gabime/spdlog.git synced 2025-11-16 09:28:56 +08:00
Code Issues Packages Projects Releases Wiki Activity

update clang format again

Browse Source
This commit is contained in:
gabime
2023-09-25 16:40:05 +03:00
parent 968048ced6
commit 6dffd7c6e8
101 changed files with 667 additions and 686 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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));
}
inline void
init_thread_pool(size_t q_size, size_t thread_count, std::function<void()> on_thread_start) {
inline void init_thread_pool(size_t q_size,
size_t thread_count,
std::function<void()> 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() {
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.
enum class async_overflow_policy {
block, // Block until message can be enqueued
overrun_oldest, // Discard oldest message in the queue if full when trying to
// add new item.
discard_new // Discard new message if the queue is full when trying to add new item.
block, // Block until message can be enqueued
overrun_oldest, // Discard oldest message in the queue if 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 {
@@ -67,4 +67,4 @@ private:
std::weak_ptr<details::thread_pool> thread_pool_;
async_overflow_policy overflow_policy_;
};
} // namespace spdlog
} // namespace spdlog

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));
}
} // namespace cfg
} // namespace spdlog
} // namespace cfg
} // namespace spdlog

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

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

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

@@ -19,6 +19,6 @@ namespace helpers {
// turn off all logging except for logger1 and logger2: "off,logger1=debug,logger2=info"
//
SPDLOG_API void load_levels(const std::string &txt);
} // namespace helpers
} // namespace cfg
} // namespace spdlog
} // namespace helpers
} // namespace cfg
} // namespace spdlog

44
include/spdlog/common.h
View File

@@ -41,20 +41,20 @@
#if defined(_WIN32)
#ifdef spdlog_EXPORTS
#define SPDLOG_API __declspec(dllexport)
#else // !spdlog_EXPORTS
#else // !spdlog_EXPORTS
#define SPDLOG_API __declspec(dllimport)
#endif
#else // !defined(_WIN32)
#else // !defined(_WIN32)
#define SPDLOG_API __attribute__((visibility("default")))
#endif
#else // !defined(SPDLOG_SHARED_LIB)
#else // !defined(SPDLOG_SHARED_LIB)
#define SPDLOG_API
#endif
#include <spdlog/fmt/fmt.h>
#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)
#if defined(SPDLOG_WCHAR_FILENAMES)
#include <spdlog/fmt/xchar.h>
@@ -121,7 +121,7 @@ using format_string_t = std::string_view;
#endif
#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;
using string_view_t = fmt::basic_string_view<char>;
@@ -131,7 +131,7 @@ using format_string_t = fmt::format_string<Args...>;
using wstring_view_t = fmt::basic_string_view<wchar_t>;
using wmemory_buf_t = fmt::basic_memory_buffer<wchar_t, 250>;
#define SPDLOG_BUF_TO_STRING(x) fmt::to_string(x)
#endif // SPDLOG_USE_STD_FORMAT
#endif // SPDLOG_USE_STD_FORMAT
#define SPDLOG_LEVEL_TRACE 0
#define SPDLOG_LEVEL_DEBUG 1
@@ -204,8 +204,8 @@ enum class color_mode { always, automatic, never };
// local time by default
//
enum class pattern_time_type {
local, // log localtime
utc // log utc
local, // log localtime
utc // log utc
};
//
@@ -234,8 +234,8 @@ struct source_loc {
funcname{funcname_in} {}
#ifdef SPDLOG_HAVE_STD_SOURCE_LOCATION
static constexpr source_loc
current(const std::source_location source_location = std::source_location::current()) {
static constexpr source_loc current(
const std::source_location source_location = std::source_location::current()) {
return source_loc{source_location.file_name(), source_location.line(),
source_location.function_name()};
}
@@ -245,7 +245,7 @@ struct source_loc {
return source_loc{source_location.file_name(), source_location.line(),
source_location.function_name()};
}
#else // no source location support
#else // no source location support
static constexpr source_loc current() { return source_loc{}; }
#endif
@@ -310,26 +310,26 @@ namespace details {
// convert format_string<...> to string_view depending on format lib versions
#if defined(SPDLOG_USE_STD_FORMAT)
#if __cpp_lib_format >= 202207L // std::format and __cpp_lib_format >= 202207L
#if __cpp_lib_format >= 202207L // std::format and __cpp_lib_format >= 202207L
template <typename T, typename... Args>
[[nodiscard]] constexpr std::basic_string_view<T>
to_string_view(std::basic_format_string<T, Args...> fmt) noexcept {
[[nodiscard]] constexpr std::basic_string_view<T> to_string_view(
std::basic_format_string<T, Args...> fmt) noexcept {
return fmt.get();
}
#else // std::format and __cpp_lib_format < 202207L
#else // std::format and __cpp_lib_format < 202207L
template <typename T, typename... Args>
[[nodiscard]] constexpr std::basic_string_view<T>
to_string_view(std::basic_format_string<T, Args...> fmt) noexcept {
[[nodiscard]] constexpr std::basic_string_view<T> to_string_view(
std::basic_format_string<T, Args...> fmt) noexcept {
return fmt;
}
#endif
#else // {fmt} version
#else // {fmt} version
template <typename T, typename... Args>
[[nodiscard]] constexpr fmt::basic_string_view<T>
to_string_view(fmt::basic_format_string<T, Args...> fmt) noexcept {
[[nodiscard]] constexpr fmt::basic_string_view<T> to_string_view(
fmt::basic_format_string<T, Args...> fmt) noexcept {
return fmt;
}
#endif
} // namespace details
} // namespace spdlog
} // namespace details
} // namespace spdlog

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

@@ -24,7 +24,7 @@ public:
circular_q() = default;
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_) {}
@@ -46,7 +46,7 @@ public:
v_[tail_] = std::move(item);
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_;
++overrun_counter_;
@@ -115,5 +115,5 @@ private:
other.overrun_counter_ = 0;
}
};
} // namespace details
} // namespace spdlog
} // namespace details
} // namespace spdlog

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

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

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

@@ -53,5 +53,5 @@ private:
filename_t filename_;
file_event_handlers event_handlers_;
};
} // namespace details
} // namespace spdlog
} // namespace details
} // namespace spdlog

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

@@ -53,14 +53,10 @@ constexpr unsigned int count_digits_fallback(T n) {
// 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
// "Three Optimization Tips for C++". See speed-test for a comparison.
if (n < 10)
return count;
if (n < 100)
return count + 1;
if (n < 1000)
return count + 2;
if (n < 10000)
return count + 3;
if (n < 10) return count;
if (n < 100) return count + 1;
if (n < 1000) return count + 2;
if (n < 10000) return count + 3;
n /= 10000u;
count += 4;
}
@@ -86,11 +82,11 @@ inline unsigned int count_digits(T n) {
}
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));
} 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), "{:02}", n);
}
@@ -140,6 +136,6 @@ inline ToDuration time_fraction(log_clock::time_point tp) {
return duration_cast<ToDuration>(duration) - duration_cast<ToDuration>(secs);
}
} // namespace fmt_helper
} // namespace details
} // namespace spdlog
} // namespace fmt_helper
} // namespace details
} // namespace spdlog

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

@@ -32,5 +32,5 @@ struct SPDLOG_API log_msg {
source_loc source;
string_view_t payload;
};
} // namespace details
} // namespace spdlog
} // namespace details
} // namespace spdlog

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

@@ -24,5 +24,5 @@ public:
log_msg_buffer &operator=(log_msg_buffer &&other) noexcept;
};
} // namespace details
} // namespace spdlog
} // namespace details
} // namespace spdlog

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

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

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

@@ -30,9 +30,9 @@ struct null_atomic {
T exchange(T new_value, std::memory_order = std::memory_order_seq_cst) {
std::swap(new_value, value);
return new_value; // return value before the call
return new_value; // return value before the call
}
};
} // namespace details
} // namespace spdlog
} // namespace details
} // namespace spdlog

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

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

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

@@ -35,7 +35,7 @@ public:
for (;;) {
std::unique_lock<std::mutex> lock(this->mutex_);
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();
}
@@ -53,5 +53,5 @@ private:
std::condition_variable cv_;
};
} // namespace details
} // namespace spdlog
} // namespace details
} // namespace spdlog

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

@@ -109,5 +109,5 @@ private:
bool automatic_registration_ = true;
};
} // namespace details
} // namespace spdlog
} // namespace details
} // namespace spdlog

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

@@ -19,4 +19,4 @@ struct synchronous_factory {
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 {};
ZeroMemory(&hints, sizeof(hints));
hints.ai_family = AF_UNSPEC; // To work with IPv4, IPv6, and so on
hints.ai_socktype = SOCK_STREAM; // TCP
hints.ai_flags = AI_NUMERICSERV; // port passed as as numeric value
hints.ai_family = AF_UNSPEC; // To work with IPv4, IPv6, and so on
hints.ai_socktype = SOCK_STREAM; // TCP
hints.ai_flags = AI_NUMERICSERV; // port passed as as numeric value
hints.ai_protocol = 0;
auto port_str = std::to_string(port);
@@ -123,7 +123,7 @@ public:
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;
}
@@ -131,5 +131,5 @@ public:
}
}
};
} // namespace details
} // namespace spdlog
} // namespace details
} // namespace spdlog

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

@@ -44,9 +44,9 @@ public:
close();
struct addrinfo hints {};
memset(&hints, 0, sizeof(struct addrinfo));
hints.ai_family = AF_UNSPEC; // To work with IPv4, IPv6, and so on
hints.ai_socktype = SOCK_STREAM; // TCP
hints.ai_flags = AI_NUMERICSERV; // port passed as as numeric value
hints.ai_family = AF_UNSPEC; // To work with IPv4, IPv6, and so on
hints.ai_socktype = SOCK_STREAM; // TCP
hints.ai_flags = AI_NUMERICSERV; // port passed as as numeric value
hints.ai_protocol = 0;
auto port_str = std::to_string(port);
@@ -115,7 +115,7 @@ public:
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;
}
@@ -123,5 +123,5 @@ public:
}
}
};
} // namespace details
} // namespace spdlog
} // namespace details
} // namespace spdlog

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

@@ -48,7 +48,7 @@ struct async_msg : log_msg_buffer {
worker_ptr = std::move(other.worker_ptr);
return *this;
}
#else // (_MSC_VER) && _MSC_VER <= 1800
#else // (_MSC_VER) && _MSC_VER <= 1800
async_msg(async_msg &&) = default;
async_msg &operator=(async_msg &&) = default;
#endif
@@ -110,5 +110,5 @@ private:
bool process_next_msg_();
};
} // namespace details
} // namespace spdlog
} // namespace details
} // namespace spdlog

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

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

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

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

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

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

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

@@ -56,7 +56,7 @@ private:
It begin_, end_;
size_t size_per_line_;
};
} // namespace details
} // namespace details
// create a dump_info that wraps the given 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
template <typename Value, size_t Extent>
inline details::dump_info<typename std::span<Value, Extent>::iterator>
to_hex(const std::span<Value, Extent> &container, size_t size_per_line = 32) {
inline details::dump_info<typename std::span<Value, Extent>::iterator> to_hex(
const std::span<Value, Extent> &container, size_t size_per_line = 32) {
using Container = std::span<Value, Extent>;
static_assert(sizeof(typename 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
template <typename It>
inline details::dump_info<It>
to_hex(const It range_begin, const It range_end, size_t size_per_line = 32) {
inline details::dump_info<It> to_hex(const It range_begin,
const It range_end,
size_t size_per_line = 32) {
return details::dump_info<It>(range_begin, range_end, size_per_line);
}
} // namespace spdlog
} // namespace spdlog
namespace
#ifdef SPDLOG_USE_STD_FORMAT
@@ -105,7 +106,7 @@ struct formatter<spdlog::details::dump_info<T>, char> {
bool put_newlines = true;
bool put_delimiters = true;
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;
// parse the format string flags
@@ -114,24 +115,24 @@ struct formatter<spdlog::details::dump_info<T>, char> {
auto it = ctx.begin();
while (it != ctx.end() && *it != '}') {
switch (*it) {
case 'X':
use_uppercase = true;
break;
case 's':
put_delimiters = false;
break;
case 'p':
put_positions = false;
break;
case 'n':
put_newlines = false;
show_ascii = false;
break;
case 'a':
if (put_newlines) {
show_ascii = true;
}
break;
case 'X':
use_uppercase = true;
break;
case 's':
put_delimiters = false;
break;
case 'p':
put_positions = false;
break;
case 'n':
put_newlines = false;
show_ascii = false;
break;
case 'a':
if (put_newlines) {
show_ascii = true;
}
break;
}
++it;
@@ -185,7 +186,7 @@ struct formatter<spdlog::details::dump_info<T>, char> {
*inserter++ = hex_chars[(ch >> 4) & 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) {
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,12 +10,12 @@
// 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>
#elif !defined(SPDLOG_FMT_EXTERNAL)
#include <spdlog/fmt/bundled/core.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/format.h>
#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 std::unique_ptr<formatter> clone() const = 0;
};
} // namespace spdlog
} // namespace spdlog

2
include/spdlog/fwd.h
View File

@@ -12,4 +12,4 @@ namespace sinks {
class sink;
}
} // namespace spdlog
} // namespace spdlog

4
include/spdlog/logger.h
View File

@@ -266,7 +266,7 @@ protected:
#ifdef SPDLOG_USE_STD_FORMAT
auto formatted = std::vformat(fmt, std::make_format_args(args...));
sink_it_(details::log_msg(loc, name_, lvl, formatted));
#else // use {fmt} lib
#else // use {fmt} lib
memory_buf_t buf;
fmt::vformat_to(std::back_inserter(buf), fmt, fmt::make_format_args(args...));
sink_it_(details::log_msg(loc, name_, lvl, string_view_t(buf.data(), buf.size())));
@@ -297,4 +297,4 @@ protected:
void err_handler_(const std::string &msg);
};
} // namespace spdlog
} // namespace spdlog

9
include/spdlog/pattern_formatter.h
View File

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

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
int ret = android_log(priority, tag_.c_str(), msg_output);
if (ret == -EPERM) {
return; // !__android_log_is_loggable
return; // !__android_log_is_loggable
}
int retry_count = 0;
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,
// when using the default log buffer, always log via __android_log_write.
template <int ID = BufferID>
typename std::enable_if<ID == static_cast<int>(log_id::LOG_ID_MAIN), int>::type
android_log(int prio, const char *tag, const char *text) {
typename std::enable_if<ID == static_cast<int>(log_id::LOG_ID_MAIN), int>::type android_log(
int prio, const char *tag, const char *text) {
return __android_log_write(prio, tag, text);
}
template <int ID = BufferID>
typename std::enable_if<ID != static_cast<int>(log_id::LOG_ID_MAIN), int>::type
android_log(int prio, const char *tag, const char *text) {
typename std::enable_if<ID != static_cast<int>(log_id::LOG_ID_MAIN), int>::type android_log(
int prio, const char *tag, const char *text) {
return __android_log_buf_write(ID, prio, tag, text);
}
static android_LogPriority convert_to_android_(spdlog::level level) {
switch (level) {
case spdlog::level::trace:
return ANDROID_LOG_VERBOSE;
case spdlog::level::debug:
return ANDROID_LOG_DEBUG;
case spdlog::level::info:
return ANDROID_LOG_INFO;
case spdlog::level::warn:
return ANDROID_LOG_WARN;
case spdlog::level::err:
return ANDROID_LOG_ERROR;
case spdlog::level::critical:
return ANDROID_LOG_FATAL;
default:
return ANDROID_LOG_DEFAULT;
case spdlog::level::trace:
return ANDROID_LOG_VERBOSE;
case spdlog::level::debug:
return ANDROID_LOG_DEBUG;
case spdlog::level::info:
return ANDROID_LOG_INFO;
case spdlog::level::warn:
return ANDROID_LOG_WARN;
case spdlog::level::err:
return ANDROID_LOG_ERROR;
case spdlog::level::critical:
return ANDROID_LOG_FATAL;
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>
using android_sink_buf_st = android_sink<details::null_mutex, BufferId>;
} // namespace sinks
} // namespace sinks
// 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);
}
} // namespace spdlog
} // namespace spdlog
#endif // __ANDROID__
#endif // __ANDROID__

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

@@ -107,5 +107,5 @@ 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_st = ansicolor_stderr_sink<details::console_nullmutex>;
} // namespace sinks
} // namespace spdlog
} // namespace sinks
} // namespace spdlog

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

@@ -43,5 +43,5 @@ protected:
virtual void set_pattern_(const std::string &pattern);
virtual void set_formatter_(std::unique_ptr<spdlog::formatter> sink_formatter);
};
} // namespace sinks
} // namespace spdlog
} // namespace sinks
} // 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_st = basic_file_sink<details::null_mutex>;
} // namespace sinks
} // namespace sinks
//
// factory functions
@@ -58,4 +58,4 @@ inline std::shared_ptr<logger> basic_logger_st(const std::string &logger_name,
event_handlers);
}
} // namespace spdlog
} // namespace spdlog

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_st = callback_sink<details::null_mutex>;
} // namespace sinks
} // namespace sinks
//
// 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);
}
} // namespace spdlog
} // namespace spdlog

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

@@ -194,7 +194,7 @@ using daily_file_format_sink_mt = daily_file_sink<std::mutex, daily_filename_for
using daily_file_format_sink_st =
daily_file_sink<details::null_mutex, daily_filename_format_calculator>;
} // namespace sinks
} // namespace sinks
//
// factory functions
@@ -212,14 +212,14 @@ inline std::shared_ptr<logger> daily_logger_mt(const std::string &logger_name,
}
template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger>
daily_logger_format_mt(const std::string &logger_name,
const filename_t &filename,
int hour = 0,
int minute = 0,
bool truncate = false,
uint16_t max_files = 0,
const file_event_handlers &event_handlers = {}) {
inline std::shared_ptr<logger> daily_logger_format_mt(
const std::string &logger_name,
const filename_t &filename,
int hour = 0,
int minute = 0,
bool truncate = false,
uint16_t max_files = 0,
const file_event_handlers &event_handlers = {}) {
return Factory::template create<sinks::daily_file_format_sink_mt>(
logger_name, filename, hour, minute, truncate, max_files, event_handlers);
}
@@ -237,15 +237,15 @@ inline std::shared_ptr<logger> daily_logger_st(const std::string &logger_name,
}
template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger>
daily_logger_format_st(const std::string &logger_name,
const filename_t &filename,
int hour = 0,
int minute = 0,
bool truncate = false,
uint16_t max_files = 0,
const file_event_handlers &event_handlers = {}) {
inline std::shared_ptr<logger> daily_logger_format_st(
const std::string &logger_name,
const filename_t &filename,
int hour = 0,
int minute = 0,
bool truncate = false,
uint16_t max_files = 0,
const file_event_handlers &event_handlers = {}) {
return Factory::template create<sinks::daily_file_format_sink_st>(
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_st = dist_sink<details::null_mutex>;
} // namespace sinks
} // namespace spdlog
} // namespace sinks
} // 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_st = dup_filter_sink<details::null_mutex>;
} // namespace sinks
} // namespace spdlog
} // namespace sinks
} // 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_st = hourly_file_sink<details::null_mutex>;
} // namespace sinks
} // namespace sinks
//
// 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,
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_st = kafka_sink<spdlog::details::null_mutex>;
} // namespace sinks
} // namespace sinks
template <typename Factory = spdlog::synchronous_factory>
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>
inline std::shared_ptr<spdlog::logger>
kafka_logger_async_mt(std::string logger_name, spdlog::sinks::kafka_sink_config config) {
inline std::shared_ptr<spdlog::logger> kafka_logger_async_mt(
std::string logger_name, spdlog::sinks::kafka_sink_config config) {
return Factory::template create<sinks::kafka_sink_mt>(logger_name, config);
}
template <typename Factory = spdlog::async_factory>
inline std::shared_ptr<spdlog::logger>
kafka_logger_async_st(std::string logger_name, spdlog::sinks::kafka_sink_config config) {
inline std::shared_ptr<spdlog::logger> kafka_logger_async_st(
std::string logger_name, spdlog::sinks::kafka_sink_config 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_st = mongo_sink<spdlog::details::null_mutex>;
} // namespace sinks
} // namespace sinks
template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger>
mongo_logger_mt(const std::string &logger_name,
const std::string &db_name,
const std::string &collection_name,
const std::string &uri = "mongodb://localhost:27017") {
inline std::shared_ptr<logger> mongo_logger_mt(
const std::string &logger_name,
const std::string &db_name,
const std::string &collection_name,
const std::string &uri = "mongodb://localhost:27017") {
return Factory::template create<sinks::mongo_sink_mt>(logger_name, db_name, collection_name,
uri);
}
template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger>
mongo_logger_st(const std::string &logger_name,
const std::string &db_name,
const std::string &collection_name,
const std::string &uri = "mongodb://localhost:27017") {
inline std::shared_ptr<logger> mongo_logger_st(
const std::string &logger_name,
const std::string &db_name,
const std::string &collection_name,
const std::string &uri = "mongodb://localhost:27017") {
return Factory::template create<sinks::mongo_sink_st>(logger_name, db_name, collection_name,
uri);
}
} // namespace spdlog
} // namespace spdlog

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

@@ -34,7 +34,7 @@ protected:
}
memory_buf_t 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
OutputDebugStringA(formatted.data());
}
@@ -49,7 +49,7 @@ using msvc_sink_st = msvc_sink<details::null_mutex>;
using windebug_sink_mt = msvc_sink_mt;
using windebug_sink_st = msvc_sink_st;
} // namespace sinks
} // namespace spdlog
} // namespace sinks
} // namespace spdlog
#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_st = null_sink<details::null_mutex>;
} // namespace sinks
} // namespace sinks
template <typename Factory = spdlog::synchronous_factory>
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;
}
} // 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_st = ostream_sink<details::null_mutex>;
} // namespace sinks
} // namespace spdlog
} // namespace sinks
} // 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()));
}
invoke_params params{max_lines_, // max lines
qt_text_edit_, // text edit to append to
std::move(payload), // text to append
default_color_, // default color
colors_.at(msg.log_level), // color to apply
color_range_start, // color range start
color_range_end}; // color range end
invoke_params params{max_lines_, // max lines
qt_text_edit_, // text edit to append to
std::move(payload), // text to append
default_color_, // default color
colors_.at(msg.log_level), // color to apply
color_range_start, // color range start
color_range_end}; // color range end
QMetaObject::invokeMethod(
qt_text_edit_, [params]() { invoke_method_(params); }, Qt::AutoConnection);
@@ -193,7 +193,7 @@ protected:
while (document->blockCount() > params.max_lines) {
cursor.select(QTextCursor::BlockUnderCursor);
cursor.removeSelectedText();
cursor.deleteChar(); // delete the newline after the block
cursor.deleteChar(); // delete the newline after the block
}
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_color_sink_mt = qt_color_sink<std::mutex>;
using qt_color_sink_st = qt_color_sink<details::null_mutex>;
} // namespace sinks
} // namespace sinks
//
// Factory functions
@@ -269,14 +269,16 @@ inline std::shared_ptr<logger> qt_logger_st(const std::string &logger_name,
}
// log to QObject
template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger>
qt_logger_mt(const std::string &logger_name, QObject *qt_object, const std::string &meta_method) {
inline std::shared_ptr<logger> qt_logger_mt(const std::string &logger_name,
QObject *qt_object,
const std::string &meta_method) {
return Factory::template create<sinks::qt_sink_mt>(logger_name, qt_object, meta_method);
}
template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger>
qt_logger_st(const std::string &logger_name, QObject *qt_object, const std::string &meta_method) {
inline std::shared_ptr<logger> qt_logger_st(const std::string &logger_name,
QObject *qt_object,
const std::string &meta_method) {
return Factory::template create<sinks::qt_sink_st>(logger_name, qt_object, meta_method);
}
@@ -299,4 +301,4 @@ inline std::shared_ptr<logger> qt_color_logger_st(const std::string &logger_name
false, is_utf8);
}
} // namespace spdlog
} // namespace spdlog

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

@@ -59,5 +59,5 @@ private:
using ringbuffer_sink_mt = ringbuffer_sink<std::mutex>;
using ringbuffer_sink_st = ringbuffer_sink<details::null_mutex>;
} // namespace sinks
} // namespace spdlog
} // namespace sinks
} // 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_st = rotating_file_sink<details::null_mutex>;
} // namespace sinks
} // namespace sinks
//
// factory functions
@@ -82,4 +82,4 @@ inline std::shared_ptr<logger> rotating_logger_st(const std::string &logger_name
return Factory::template create<sinks::rotating_file_sink_st>(
logger_name, filename, max_file_size, max_files, rotate_on_open, event_handlers);
}
} // namespace spdlog
} // namespace spdlog

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

@@ -25,5 +25,5 @@ protected:
atomic_level_t level_{level::trace};
};
} // namespace sinks
} // namespace spdlog
} // namespace sinks
} // namespace spdlog

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

@@ -25,7 +25,7 @@ using stdout_color_sink_st = ansicolor_stdout_sink_st;
using stderr_color_sink_mt = ansicolor_stderr_sink_mt;
using stderr_color_sink_st = ansicolor_stderr_sink_st;
#endif
} // namespace sinks
} // namespace sinks
// template instantations
@@ -45,4 +45,4 @@ template <typename Factory = spdlog::synchronous_factory>
std::shared_ptr<logger> stderr_color_st(const std::string &logger_name,
color_mode mode = color_mode::automatic);
} // namespace spdlog
} // namespace spdlog

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

@@ -41,7 +41,7 @@ protected:
std::unique_ptr<spdlog::formatter> formatter_;
#ifdef _WIN32
HANDLE handle_;
#endif // WIN32
#endif // WIN32
};
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_st = stderr_sink<details::console_nullmutex>;
} // namespace sinks
} // namespace sinks
// factory methods
template <typename Factory = spdlog::synchronous_factory>
@@ -77,4 +77,4 @@ std::shared_ptr<logger> stderr_logger_mt(const std::string &logger_name);
template <typename Factory = spdlog::synchronous_factory>
std::shared_ptr<logger> stderr_logger_st(const std::string &logger_name);
} // namespace spdlog
} // namespace spdlog

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

@@ -18,7 +18,6 @@ namespace sinks {
*/
template <typename Mutex>
class syslog_sink : public base_sink<Mutex> {
public:
syslog_sink(std::string ident, int syslog_option, int syslog_facility, bool enable_formatting)
: enable_formatting_{enable_formatting},
@@ -79,7 +78,7 @@ private:
using syslog_sink_mt = syslog_sink<std::mutex>;
using syslog_sink_st = syslog_sink<details::null_mutex>;
} // namespace sinks
} // namespace sinks
// Create and register a syslog logger
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,
syslog_facility, enable_formatting);
}
} // namespace spdlog
} // namespace spdlog

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

@@ -100,7 +100,7 @@ protected:
using systemd_sink_mt = systemd_sink<std::mutex>;
using systemd_sink_st = systemd_sink<details::null_mutex>;
} // namespace sinks
} // namespace sinks
// Create and register a syslog logger
template <typename Factory = spdlog::synchronous_factory>
@@ -116,4 +116,4 @@ inline std::shared_ptr<logger> systemd_logger_st(const std::string &logger_name,
bool enable_formatting = false) {
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 {
std::string server_host;
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)
: server_host{std::move(host)},
@@ -71,5 +71,5 @@ protected:
using tcp_sink_mt = tcp_sink<std::mutex>;
using tcp_sink_st = tcp_sink<spdlog::details::null_mutex>;
} // namespace sinks
} // namespace spdlog
} // namespace sinks
} // 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_st = udp_sink<spdlog::details::null_mutex>;
} // namespace sinks
} // namespace sinks
//
// 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);
}
} // namespace spdlog
} // namespace spdlog

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

@@ -131,7 +131,7 @@ public:
~process_token_t() { ::CloseHandle(token_handle_); }
} 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
// the token size
@@ -156,30 +156,30 @@ public:
struct eventlog {
static WORD get_event_type(details::log_msg const &msg) {
switch (msg.log_level) {
case level::trace:
case level::debug:
return EVENTLOG_SUCCESS;
case level::trace:
case level::debug:
return EVENTLOG_SUCCESS;
case level::info:
return EVENTLOG_INFORMATION_TYPE;
case level::info:
return EVENTLOG_INFORMATION_TYPE;
case spdlog::level::warn:
return EVENTLOG_WARNING_TYPE;
case spdlog::level::warn:
return EVENTLOG_WARNING_TYPE;
case level::err:
case level::critical:
case level::off:
return EVENTLOG_ERROR_TYPE;
case level::err:
case level::critical:
case level::off:
return EVENTLOG_ERROR_TYPE;
default:
return EVENTLOG_INFORMATION_TYPE;
default:
return EVENTLOG_INFORMATION_TYPE;
}
}
static WORD get_event_category(details::log_msg const &msg) { return (WORD)msg.log_level; }
};
} // namespace internal
} // namespace internal
/*
* Windows Event Log sink
@@ -238,15 +238,14 @@ public:
}
~win_eventlog_sink() {
if (hEventLog_)
DeregisterEventSource(hEventLog_);
if (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_st = win_eventlog::win_eventlog_sink<details::null_mutex>;
} // namespace sinks
} // namespace spdlog
} // namespace sinks
} // namespace spdlog

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

@@ -74,5 +74,5 @@ 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_st = wincolor_stderr_sink<details::console_nullmutex>;
} // namespace sinks
} // namespace spdlog
} // namespace sinks
} // namespace spdlog

4
include/spdlog/spdlog.h
View File

@@ -251,7 +251,7 @@ inline void error(string_view_t msg) { log(level::err, msg); }
inline void critical(string_view_t msg) { log(level::critical, msg); }
#endif
} // namespace spdlog
} // namespace spdlog
//
// enable/disable log calls at compile time according to global level.
@@ -328,4 +328,4 @@ inline void critical(string_view_t msg) { log(level::critical, msg); }
#define SPDLOG_CRITICAL(...) (void)0
#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(); }
};
} // namespace spdlog
} // namespace spdlog
// Support for fmt formatting (e.g. "{:012.9}" or just "{}")
namespace
@@ -59,4 +59,4 @@ struct formatter<spdlog::stopwatch> : formatter<double> {
return formatter<double>::format(sw.elapsed().count(), ctx);
}
};
} // namespace std
} // namespace std