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

clang format

Browse Source
pull/2775/head
gabime 2 years ago
parent 31cefdce79
commit 1f61f5e019
25 changed files with 294 additions and 309 deletions
Show Stats Download Patch File Download Diff File

18
CMakeLists.txt
Unescape Escape View File

@ -185,7 +185,8 @@ target_include_directories(spdlog ${SPDLOG_INCLUDES_LEVEL} PUBLIC "$<BUILD_INTER
target_link_libraries(spdlog PUBLIC Threads::Threads) target_link_libraries(spdlog PUBLIC Threads::Threads)
spdlog_enable_warnings(spdlog) spdlog_enable_warnings(spdlog)
set_target_properties(spdlog PROPERTIES VERSION ${SPDLOG_VERSION} SOVERSION ${SPDLOG_VERSION_MAJOR}.${SPDLOG_VERSION_MINOR}) set_target_properties(spdlog PROPERTIES VERSION ${SPDLOG_VERSION} SOVERSION
${SPDLOG_VERSION_MAJOR}.${SPDLOG_VERSION_MINOR})
set_target_properties(spdlog PROPERTIES DEBUG_POSTFIX d) set_target_properties(spdlog PROPERTIES DEBUG_POSTFIX d)
if(COMMAND target_precompile_headers AND SPDLOG_ENABLE_PCH) if(COMMAND target_precompile_headers AND SPDLOG_ENABLE_PCH)
@ -199,7 +200,8 @@ endif()
add_library(spdlog_header_only INTERFACE) add_library(spdlog_header_only INTERFACE)
add_library(spdlog::spdlog_header_only ALIAS spdlog_header_only) add_library(spdlog::spdlog_header_only ALIAS spdlog_header_only)
target_include_directories(spdlog_header_only ${SPDLOG_INCLUDES_LEVEL} INTERFACE "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>" target_include_directories(
spdlog_header_only ${SPDLOG_INCLUDES_LEVEL} INTERFACE "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>"
"$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>") "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>")
target_link_libraries(spdlog_header_only INTERFACE Threads::Threads) target_link_libraries(spdlog_header_only INTERFACE Threads::Threads)
@ -323,12 +325,12 @@ if(SPDLOG_INSTALL)
# --------------------------------------------------------------------------------------- # ---------------------------------------------------------------------------------------
# Install pkg-config file # Install pkg-config file
# --------------------------------------------------------------------------------------- # ---------------------------------------------------------------------------------------
if (IS_ABSOLUTE "${CMAKE_INSTALL_INCLUDEDIR}") if(IS_ABSOLUTE "${CMAKE_INSTALL_INCLUDEDIR}")
set(PKG_CONFIG_INCLUDEDIR "${CMAKE_INSTALL_INCLUDEDIR}") set(PKG_CONFIG_INCLUDEDIR "${CMAKE_INSTALL_INCLUDEDIR}")
else() else()
set(PKG_CONFIG_INCLUDEDIR "\${prefix}/${CMAKE_INSTALL_INCLUDEDIR}") set(PKG_CONFIG_INCLUDEDIR "\${prefix}/${CMAKE_INSTALL_INCLUDEDIR}")
endif() endif()
if (IS_ABSOLUTE "${CMAKE_INSTALL_LIBDIR}") if(IS_ABSOLUTE "${CMAKE_INSTALL_LIBDIR}")
set(PKG_CONFIG_LIBDIR "${CMAKE_INSTALL_LIBDIR}") set(PKG_CONFIG_LIBDIR "${CMAKE_INSTALL_LIBDIR}")
else() else()
set(PKG_CONFIG_LIBDIR "\${exec_prefix}/${CMAKE_INSTALL_LIBDIR}") set(PKG_CONFIG_LIBDIR "\${exec_prefix}/${CMAKE_INSTALL_LIBDIR}")
@ -342,15 +344,11 @@ if(SPDLOG_INSTALL)
# --------------------------------------------------------------------------------------- # ---------------------------------------------------------------------------------------
# Install CMake config files # Install CMake config files
# --------------------------------------------------------------------------------------- # ---------------------------------------------------------------------------------------
export( export(TARGETS spdlog NAMESPACE spdlog:: FILE "${CMAKE_CURRENT_BINARY_DIR}/${config_targets_file}")
TARGETS spdlog
NAMESPACE spdlog::
FILE "${CMAKE_CURRENT_BINARY_DIR}/${config_targets_file}")
install(EXPORT spdlog DESTINATION ${export_dest_dir} NAMESPACE spdlog:: FILE ${config_targets_file}) install(EXPORT spdlog DESTINATION ${export_dest_dir} NAMESPACE spdlog:: FILE ${config_targets_file})
include(CMakePackageConfigHelpers) include(CMakePackageConfigHelpers)
configure_package_config_file("${project_config_in}" "${project_config_out}" configure_package_config_file("${project_config_in}" "${project_config_out}" INSTALL_DESTINATION ${export_dest_dir})
INSTALL_DESTINATION ${export_dest_dir})
write_basic_package_version_file("${version_config_file}" COMPATIBILITY SameMajorVersion) write_basic_package_version_file("${version_config_file}" COMPATIBILITY SameMajorVersion)
install(FILES "${project_config_out}" "${version_config_file}" DESTINATION "${export_dest_dir}") install(FILES "${project_config_out}" "${version_config_file}" DESTINATION "${export_dest_dir}")

3
bench/latency.cpp
Unescape Escape View File

@ -116,9 +116,6 @@ int main(int argc, char *argv[])
tracing_null_logger_st->enable_backtrace(64); tracing_null_logger_st->enable_backtrace(64);
benchmark::RegisterBenchmark("null_sink_st/backtrace", bench_logger, tracing_null_logger_st); benchmark::RegisterBenchmark("null_sink_st/backtrace", bench_logger, tracing_null_logger_st);
#ifdef __linux #ifdef __linux
bench_dev_null(); bench_dev_null();
#endif // __linux__ #endif // __linux__

2
example/example.cpp
Unescape Escape View File

@ -142,7 +142,7 @@ void daily_example()
void callback_example() void callback_example()
{ {
// Create the logger // Create the logger
auto logger = spdlog::callback_logger_mt("custom_callback_logger", [](const spdlog::details::log_msg &/*msg*/) { auto logger = spdlog::callback_logger_mt("custom_callback_logger", [](const spdlog::details::log_msg & /*msg*/) {
// do what you need to do with msg // do what you need to do with msg
}); });
} }

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

@ -35,7 +35,7 @@ template<async_overflow_policy OverflowPolicy = async_overflow_policy::block>
struct async_factory_impl struct async_factory_impl
{ {
template<typename Sink, typename... SinkArgs> template<typename Sink, typename... SinkArgs>
static std::shared_ptr<async_logger> create(std::string logger_name, SinkArgs &&... args) static std::shared_ptr<async_logger> create(std::string logger_name, SinkArgs &&...args)
{ {
auto &registry_inst = details::registry::instance(); auto &registry_inst = details::registry::instance();
@ -61,13 +61,13 @@ using async_factory = async_factory_impl<async_overflow_policy::block>;
using async_factory_nonblock = async_factory_impl<async_overflow_policy::overrun_oldest>; using async_factory_nonblock = async_factory_impl<async_overflow_policy::overrun_oldest>;
template<typename Sink, typename... SinkArgs> template<typename Sink, typename... SinkArgs>
inline std::shared_ptr<spdlog::logger> create_async(std::string logger_name, SinkArgs &&... sink_args) inline std::shared_ptr<spdlog::logger> create_async(std::string logger_name, SinkArgs &&...sink_args)
{ {
return async_factory::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...); return async_factory::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...);
} }
template<typename Sink, typename... SinkArgs> template<typename Sink, typename... SinkArgs>
inline std::shared_ptr<spdlog::logger> create_async_nb(std::string logger_name, SinkArgs &&... sink_args) inline std::shared_ptr<spdlog::logger> create_async_nb(std::string logger_name, SinkArgs &&...sink_args)
{ {
return async_factory_nonblock::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...); return async_factory_nonblock::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...);
} }

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

@ -24,37 +24,27 @@ SPDLOG_INLINE spdlog::async_logger::async_logger(
{} {}
// send the log message to the thread pool // send the log message to the thread pool
SPDLOG_INLINE void spdlog::async_logger::sink_it_(const details::log_msg &msg) SPDLOG_INLINE void spdlog::async_logger::sink_it_(const details::log_msg &msg){
SPDLOG_TRY{if (auto pool_ptr = thread_pool_.lock()){pool_ptr->post_log(shared_from_this(), msg, overflow_policy_);
}
else
{ {
SPDLOG_TRY
{
if (auto pool_ptr = thread_pool_.lock())
{
pool_ptr->post_log(shared_from_this(), msg, overflow_policy_);
}
else
{
throw_spdlog_ex("async log: thread pool doesn't exist anymore"); throw_spdlog_ex("async log: thread pool doesn't exist anymore");
} }
} }
SPDLOG_LOGGER_CATCH(msg.source) SPDLOG_LOGGER_CATCH(msg.source)
} }
// send flush request to the thread pool // send flush request to the thread pool
SPDLOG_INLINE void spdlog::async_logger::flush_() SPDLOG_INLINE void spdlog::async_logger::flush_(){
SPDLOG_TRY{if (auto pool_ptr = thread_pool_.lock()){pool_ptr->post_flush(shared_from_this(), overflow_policy_);
}
else
{ {
SPDLOG_TRY
{
if (auto pool_ptr = thread_pool_.lock())
{
pool_ptr->post_flush(shared_from_this(), overflow_policy_);
}
else
{
throw_spdlog_ex("async flush: thread pool doesn't exist anymore"); throw_spdlog_ex("async flush: thread pool doesn't exist anymore");
} }
} }
SPDLOG_LOGGER_CATCH(source_loc()) SPDLOG_LOGGER_CATCH(source_loc())
} }
// //

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

@ -107,7 +107,8 @@
# define SPDLOG_TRY try # define SPDLOG_TRY try
# define SPDLOG_THROW(ex) throw(ex) # define SPDLOG_THROW(ex) throw(ex)
# define SPDLOG_CATCH_STD \ # define SPDLOG_CATCH_STD \
catch (const std::exception &) {} catch (const std::exception &) \
{}
#endif #endif
namespace spdlog { namespace spdlog {
@ -173,12 +174,12 @@ using format_string_t = fmt::format_string<Args...>;
template<class T> template<class T>
using remove_cvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type; using remove_cvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
template <typename Char> template<typename Char>
#if FMT_VERSION >= 90101 # if FMT_VERSION >= 90101
using fmt_runtime_string = fmt::runtime_format_string<Char>; using fmt_runtime_string = fmt::runtime_format_string<Char>;
#else # else
using fmt_runtime_string = fmt::basic_runtime<Char>; using fmt_runtime_string = fmt::basic_runtime<Char>;
#endif # endif
// clang doesn't like SFINAE disabled constructor in std::is_convertible<> so have to repeat the condition from basic_format_string here, // clang doesn't like SFINAE disabled constructor in std::is_convertible<> so have to repeat the condition from basic_format_string here,
// in addition, fmt::basic_runtime<Char> is only convertible to basic_format_string<Char> but not basic_string_view<Char> // in addition, fmt::basic_runtime<Char> is only convertible to basic_format_string<Char> but not basic_string_view<Char>
@ -391,7 +392,7 @@ template<bool B, class T = void>
using enable_if_t = typename std::enable_if<B, T>::type; using enable_if_t = typename std::enable_if<B, T>::type;
template<typename T, typename... Args> template<typename T, typename... Args>
std::unique_ptr<T> make_unique(Args &&... args) std::unique_ptr<T> make_unique(Args &&...args)
{ {
static_assert(!std::is_array<T>::value, "arrays not supported"); static_assert(!std::is_array<T>::value, "arrays not supported");
return std::unique_ptr<T>(new T(std::forward<Args>(args)...)); return std::unique_ptr<T>(new T(std::forward<Args>(args)...));

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

@ -92,7 +92,7 @@ SPDLOG_INLINE void file_helper::flush()
SPDLOG_INLINE void file_helper::sync() SPDLOG_INLINE void file_helper::sync()
{ {
if(!os::fsync(fd_)) if (!os::fsync(fd_))
{ {
throw_spdlog_ex("Failed to fsync file " + os::filename_to_str(filename_), errno); throw_spdlog_ex("Failed to fsync file " + os::filename_to_str(filename_), errno);
} }

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

@ -292,7 +292,8 @@ SPDLOG_INLINE int utc_minutes_offset(const std::tm &tm)
return offset; return offset;
#else #else
# if defined(sun) || defined(__sun) || defined(_AIX) || (defined(__NEWLIB__) && !defined(__TM_GMTOFF)) || (!defined(_BSD_SOURCE) && !defined(_GNU_SOURCE)) # if defined(sun) || defined(__sun) || defined(_AIX) || (defined(__NEWLIB__) && !defined(__TM_GMTOFF)) || \
(!defined(_BSD_SOURCE) && !defined(_GNU_SOURCE))
// 'tm_gmtoff' field is BSD extension and it's missing on SunOS/Solaris // 'tm_gmtoff' field is BSD extension and it's missing on SunOS/Solaris
struct helper struct helper
{ {
@ -364,9 +365,12 @@ SPDLOG_INLINE size_t _thread_id() SPDLOG_NOEXCEPT
# if (MAC_OS_X_VERSION_MAX_ALLOWED < 1060) || defined(__POWERPC__) # if (MAC_OS_X_VERSION_MAX_ALLOWED < 1060) || defined(__POWERPC__)
tid = pthread_mach_thread_np(pthread_self()); tid = pthread_mach_thread_np(pthread_self());
# elif MAC_OS_X_VERSION_MIN_REQUIRED < 1060 # elif MAC_OS_X_VERSION_MIN_REQUIRED < 1060
if (&pthread_threadid_np) { if (&pthread_threadid_np)
{
pthread_threadid_np(nullptr, &tid); pthread_threadid_np(nullptr, &tid);
} else { }
else
{
tid = pthread_mach_thread_np(pthread_self()); tid = pthread_mach_thread_np(pthread_self());
} }
# else # else

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

@ -111,7 +111,7 @@ SPDLOG_API std::string getenv(const char *field);
// Do fsync by FILE objectpointer. // Do fsync by FILE objectpointer.
// 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

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

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

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

@ -85,13 +85,13 @@ public:
void swap(spdlog::logger &other) SPDLOG_NOEXCEPT; void swap(spdlog::logger &other) SPDLOG_NOEXCEPT;
template<typename... Args> template<typename... Args>
void log(source_loc loc, level::level_enum lvl, format_string_t<Args...> fmt, Args &&... args) void log(source_loc loc, level::level_enum lvl, format_string_t<Args...> fmt, Args &&...args)
{ {
log_(loc, lvl, details::to_string_view(fmt), std::forward<Args>(args)...); log_(loc, lvl, details::to_string_view(fmt), std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
void log(level::level_enum lvl, format_string_t<Args...> fmt, Args &&... args) void log(level::level_enum lvl, format_string_t<Args...> fmt, Args &&...args)
{ {
log(source_loc{}, lvl, fmt, std::forward<Args>(args)...); log(source_loc{}, lvl, fmt, std::forward<Args>(args)...);
} }
@ -141,50 +141,50 @@ public:
} }
template<typename... Args> template<typename... Args>
void trace(format_string_t<Args...> fmt, Args &&... args) void trace(format_string_t<Args...> fmt, Args &&...args)
{ {
log(level::trace, fmt, std::forward<Args>(args)...); log(level::trace, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
void debug(format_string_t<Args...> fmt, Args &&... args) void debug(format_string_t<Args...> fmt, Args &&...args)
{ {
log(level::debug, fmt, std::forward<Args>(args)...); log(level::debug, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
void info(format_string_t<Args...> fmt, Args &&... args) void info(format_string_t<Args...> fmt, Args &&...args)
{ {
log(level::info, fmt, std::forward<Args>(args)...); log(level::info, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
void warn(format_string_t<Args...> fmt, Args &&... args) void warn(format_string_t<Args...> fmt, Args &&...args)
{ {
log(level::warn, fmt, std::forward<Args>(args)...); log(level::warn, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
void error(format_string_t<Args...> fmt, Args &&... args) void error(format_string_t<Args...> fmt, Args &&...args)
{ {
log(level::err, fmt, std::forward<Args>(args)...); log(level::err, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
void critical(format_string_t<Args...> fmt, Args &&... args) void critical(format_string_t<Args...> fmt, Args &&...args)
{ {
log(level::critical, fmt, std::forward<Args>(args)...); log(level::critical, fmt, std::forward<Args>(args)...);
} }
#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
template<typename... Args> template<typename... Args>
void log(source_loc loc, level::level_enum lvl, wformat_string_t<Args...> fmt, Args &&... args) void log(source_loc loc, level::level_enum lvl, wformat_string_t<Args...> fmt, Args &&...args)
{ {
log_(loc, lvl, details::to_string_view(fmt), std::forward<Args>(args)...); log_(loc, lvl, details::to_string_view(fmt), std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
void log(level::level_enum lvl, wformat_string_t<Args...> fmt, Args &&... args) void log(level::level_enum lvl, wformat_string_t<Args...> fmt, Args &&...args)
{ {
log(source_loc{}, lvl, fmt, std::forward<Args>(args)...); log(source_loc{}, lvl, fmt, std::forward<Args>(args)...);
} }
@ -225,37 +225,37 @@ public:
} }
template<typename... Args> template<typename... Args>
void trace(wformat_string_t<Args...> fmt, Args &&... args) void trace(wformat_string_t<Args...> fmt, Args &&...args)
{ {
log(level::trace, fmt, std::forward<Args>(args)...); log(level::trace, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
void debug(wformat_string_t<Args...> fmt, Args &&... args) void debug(wformat_string_t<Args...> fmt, Args &&...args)
{ {
log(level::debug, fmt, std::forward<Args>(args)...); log(level::debug, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
void info(wformat_string_t<Args...> fmt, Args &&... args) void info(wformat_string_t<Args...> fmt, Args &&...args)
{ {
log(level::info, fmt, std::forward<Args>(args)...); log(level::info, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
void warn(wformat_string_t<Args...> fmt, Args &&... args) void warn(wformat_string_t<Args...> fmt, Args &&...args)
{ {
log(level::warn, fmt, std::forward<Args>(args)...); log(level::warn, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
void error(wformat_string_t<Args...> fmt, Args &&... args) void error(wformat_string_t<Args...> fmt, Args &&...args)
{ {
log(level::err, fmt, std::forward<Args>(args)...); log(level::err, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
void critical(wformat_string_t<Args...> fmt, Args &&... args) void critical(wformat_string_t<Args...> fmt, Args &&...args)
{ {
log(level::critical, fmt, std::forward<Args>(args)...); log(level::critical, fmt, std::forward<Args>(args)...);
} }
@ -357,7 +357,7 @@ protected:
// common implementation for after templated public api has been resolved // common implementation for after templated public api has been resolved
template<typename... Args> template<typename... Args>
void log_(source_loc loc, level::level_enum lvl, string_view_t fmt, Args &&... args) void log_(source_loc loc, level::level_enum lvl, string_view_t fmt, Args &&...args)
{ {
bool log_enabled = should_log(lvl); bool log_enabled = should_log(lvl);
bool traceback_enabled = tracer_.enabled(); bool traceback_enabled = tracer_.enabled();
@ -382,7 +382,7 @@ protected:
#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
template<typename... Args> template<typename... Args>
void log_(source_loc loc, level::level_enum lvl, wstring_view_t fmt, Args &&... args) void log_(source_loc loc, level::level_enum lvl, wstring_view_t fmt, Args &&...args)
{ {
bool log_enabled = should_log(lvl); bool log_enabled = should_log(lvl);
bool traceback_enabled = tracer_.enabled(); bool traceback_enabled = tracer_.enabled();
@ -394,8 +394,7 @@ protected:
{ {
// format to wmemory_buffer and convert to utf8 // format to wmemory_buffer and convert to utf8
wmemory_buf_t wbuf; wmemory_buf_t wbuf;
fmt_lib::vformat_to( fmt_lib::vformat_to(std::back_inserter(wbuf), fmt, fmt_lib::make_format_args<fmt_lib::wformat_context>(args...));
std::back_inserter(wbuf), fmt, fmt_lib::make_format_args<fmt_lib::wformat_context>(args...));
memory_buf_t buf; memory_buf_t buf;
details::os::wstr_to_utf8buf(wstring_view_t(wbuf.data(), wbuf.size()), buf); details::os::wstr_to_utf8buf(wstring_view_t(wbuf.data(), wbuf.size()), buf);

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

@ -92,7 +92,7 @@ public:
void format(const details::log_msg &msg, memory_buf_t &dest) override; void format(const details::log_msg &msg, memory_buf_t &dest) override;
template<typename T, typename... Args> template<typename T, typename... Args>
pattern_formatter &add_flag(char flag, Args &&... args) pattern_formatter &add_flag(char flag, Args &&...args)
{ {
custom_handlers_[flag] = details::make_unique<T>(std::forward<Args>(args)...); custom_handlers_[flag] = details::make_unique<T>(std::forward<Args>(args)...);
return *this; return *this;

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

@ -52,7 +52,7 @@ SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::log(const details::log_msg &msg
// before color range // before color range
print_range_(formatted, 0, msg.color_range_start); print_range_(formatted, 0, msg.color_range_start);
// in color range // in color range
print_ccode_(colors_[static_cast<size_t>(msg.level)]); print_ccode_(colors_.at(static_cast<size_t>(msg.level)));
print_range_(formatted, msg.color_range_start, msg.color_range_end); print_range_(formatted, msg.color_range_start, msg.color_range_end);
print_ccode_(reset); print_ccode_(reset);
// after color range // after color range

4
include/spdlog/sinks/kafka_sink.h
Unescape Escape View File

@ -32,8 +32,8 @@ struct kafka_sink_config
kafka_sink_config(std::string addr, std::string topic, int flush_timeout_ms = 1000) kafka_sink_config(std::string addr, std::string topic, int flush_timeout_ms = 1000)
: server_addr{std::move(addr)} : server_addr{std::move(addr)}
,produce_topic{std::move(topic)} , produce_topic{std::move(topic)}
,flush_timeout_ms(flush_timeout_ms) , flush_timeout_ms(flush_timeout_ms)
{} {}
}; };

13
include/spdlog/sinks/msvc_sink.h
Unescape Escape View File

@ -3,7 +3,6 @@
#pragma once #pragma once
#if defined(_WIN32) #if defined(_WIN32)
# include <spdlog/details/null_mutex.h> # include <spdlog/details/null_mutex.h>
@ -16,11 +15,11 @@
# include <string> # include <string>
// Avoid including windows.h (https://stackoverflow.com/a/30741042) // Avoid including windows.h (https://stackoverflow.com/a/30741042)
#if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) # if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
extern "C" __declspec(dllimport) void __stdcall OutputDebugStringW(const wchar_t *lpOutputString); extern "C" __declspec(dllimport) void __stdcall OutputDebugStringW(const wchar_t *lpOutputString);
#else # else
extern "C" __declspec(dllimport) void __stdcall OutputDebugStringA(const char *lpOutputString); extern "C" __declspec(dllimport) void __stdcall OutputDebugStringA(const char *lpOutputString);
#endif # endif
extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent(); extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
namespace spdlog { namespace spdlog {
@ -46,13 +45,13 @@ 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);
OutputDebugStringW(wformatted.data()); OutputDebugStringW(wformatted.data());
#else # else
OutputDebugStringA(formatted.data()); OutputDebugStringA(formatted.data());
#endif # endif
} }
void flush_() override {} void flush_() override {}

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

@ -11,7 +11,7 @@
// auto edit = new QTextEdit(); // auto edit = new QTextEdit();
// setCentralWidget(edit); // setCentralWidget(edit);
// auto logger = spdlog::qt_color_logger_mt("my_logger", my_edit_widget); // auto logger = spdlog::qt_color_logger_mt("my_logger", my_edit_widget);
//
// Warning: those sinks won't be notified if the target widget is destroyed. // Warning: those sinks won't be notified if the target widget is destroyed.
// If the widget's lifetime can be shorter than the logger's one, you should provide some permanent QObject, // If the widget's lifetime can be shorter than the logger's one, you should provide some permanent QObject,
// and then use a standard signal/slot. // and then use a standard signal/slot.
@ -72,7 +72,6 @@ private:
QMetaMethod meta_method_; QMetaMethod meta_method_;
}; };
// QT color sink to QTextEdit. // QT color sink to QTextEdit.
// Color location is determined by the sink log pattern like in the rest of spdlog sinks. // Color location is determined by the sink log pattern like in the rest of spdlog sinks.
// Colors can be modified if needed using sink->set_color(level, qtTextCharFormat). // Colors can be modified if needed using sink->set_color(level, qtTextCharFormat).
@ -81,9 +80,10 @@ template<typename Mutex>
class qt_color_sink : public base_sink<Mutex> class qt_color_sink : public base_sink<Mutex>
{ {
public: public:
qt_color_sink(QTextEdit *qt_text_edit) : qt_text_edit_(qt_text_edit) qt_color_sink(QTextEdit *qt_text_edit)
: qt_text_edit_(qt_text_edit)
{ {
if(!qt_text_edit_) if (!qt_text_edit_)
{ {
throw_spdlog_ex("qt_color_text_sink: text_edit is null"); throw_spdlog_ex("qt_color_text_sink: text_edit is null");
} }
@ -118,23 +118,23 @@ public:
void set_default_color(QTextCharFormat format) void set_default_color(QTextCharFormat format)
{ {
//std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_); // std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
default_color_ = format; default_color_ = format;
} }
void set_level_color(level::level_enum color_level, QTextCharFormat format) void set_level_color(level::level_enum color_level, QTextCharFormat format)
{ {
//std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_); // std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
colors_.at(static_cast<size_t>(color_level)) = format; colors_.at(static_cast<size_t>(color_level)) = format;
} }
QTextCharFormat& get_level_color(level::level_enum color_level) QTextCharFormat &get_level_color(level::level_enum color_level)
{ {
std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_); std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
return colors_.at(static_cast<size_t>(color_level)); return colors_.at(static_cast<size_t>(color_level));
} }
QTextCharFormat& get_default_color() QTextCharFormat &get_default_color()
{ {
std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_); std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
return default_color_; return default_color_;
@ -149,7 +149,7 @@ protected:
// apply the color to the color range in the formatted message. // apply the color to the color range in the formatted message.
auto payload = QString::fromLatin1(str.data(), static_cast<int>(str.size())); auto payload = QString::fromLatin1(str.data(), static_cast<int>(str.size()));
if(msg.color_range_end > msg.color_range_start) if (msg.color_range_end > msg.color_range_start)
{ {
QTextCursor cursor(qt_text_edit_->document()); QTextCursor cursor(qt_text_edit_->document());
cursor.movePosition(QTextCursor::End); cursor.movePosition(QTextCursor::End);
@ -177,8 +177,7 @@ protected:
QTextEdit *qt_text_edit_; QTextEdit *qt_text_edit_;
QTextCharFormat default_color_; QTextCharFormat default_color_;
std::array<QTextCharFormat, level::n_levels> colors_; std::array<QTextCharFormat, level::n_levels> colors_;
};
};
#include "spdlog/details/null_mutex.h" #include "spdlog/details/null_mutex.h"
#include <mutex> #include <mutex>
@ -194,13 +193,15 @@ using qt_color_sink_st = qt_color_sink<spdlog::details::null_mutex>;
// create logger using QTextEdit object // create logger using QTextEdit object
template<typename Factory = spdlog::synchronous_factory> template<typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> qt_logger_mt(const std::string &logger_name, QTextEdit *qt_object, const std::string &meta_method = "append(QString)") inline std::shared_ptr<logger> qt_logger_mt(
const std::string &logger_name, QTextEdit *qt_object, const std::string &meta_method = "append(QString)")
{ {
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> qt_logger_st(const std::string &logger_name, QTextEdit *qt_object, const std::string &meta_method = "append(QString)") inline std::shared_ptr<logger> qt_logger_st(
const std::string &logger_name, QTextEdit *qt_object, const std::string &meta_method = "append(QString)")
{ {
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);
} }

8
include/spdlog/sinks/win_eventlog_sink.h
Unescape Escape View File

@ -241,12 +241,12 @@ protected:
details::os::utf8_to_wstrbuf(string_view_t(formatted.data(), formatted.size()), buf); details::os::utf8_to_wstrbuf(string_view_t(formatted.data(), formatted.size()), buf);
LPCWSTR lp_wstr = buf.data(); LPCWSTR lp_wstr = buf.data();
succeeded = static_cast<bool>(::ReportEventW(event_log_handle(), eventlog::get_event_type(msg), eventlog::get_event_category(msg), event_id_, succeeded = static_cast<bool>(::ReportEventW(event_log_handle(), eventlog::get_event_type(msg), eventlog::get_event_category(msg),
current_user_sid_.as_sid(), 1, 0, &lp_wstr, nullptr)); event_id_, current_user_sid_.as_sid(), 1, 0, &lp_wstr, nullptr));
#else #else
LPCSTR lp_str = formatted.data(); LPCSTR lp_str = formatted.data();
succeeded = static_cast<bool>(::ReportEventA(event_log_handle(), eventlog::get_event_type(msg), eventlog::get_event_category(msg), event_id_, succeeded = static_cast<bool>(::ReportEventA(event_log_handle(), eventlog::get_event_type(msg), eventlog::get_event_category(msg),
current_user_sid_.as_sid(), 1, 0, &lp_str, nullptr)); event_id_, current_user_sid_.as_sid(), 1, 0, &lp_str, nullptr));
#endif #endif
if (!succeeded) if (!succeeded)

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

@ -31,7 +31,7 @@ using default_factory = synchronous_factory;
// Example: // Example:
// spdlog::create<daily_file_sink_st>("logger_name", "dailylog_filename", 11, 59); // spdlog::create<daily_file_sink_st>("logger_name", "dailylog_filename", 11, 59);
template<typename Sink, typename... SinkArgs> template<typename Sink, typename... SinkArgs>
inline std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&... sink_args) inline std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&...sink_args)
{ {
return default_factory::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...); return default_factory::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...);
} }
@ -141,49 +141,49 @@ 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 log(source_loc source, level::level_enum lvl, format_string_t<Args...> fmt, Args &&... args) inline void log(source_loc source, level::level_enum lvl, format_string_t<Args...> fmt, Args &&...args)
{ {
default_logger_raw()->log(source, lvl, fmt, std::forward<Args>(args)...); default_logger_raw()->log(source, lvl, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void log(level::level_enum lvl, format_string_t<Args...> fmt, Args &&... args) inline void log(level::level_enum lvl, format_string_t<Args...> fmt, Args &&...args)
{ {
default_logger_raw()->log(source_loc{}, lvl, fmt, std::forward<Args>(args)...); default_logger_raw()->log(source_loc{}, lvl, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void trace(format_string_t<Args...> fmt, Args &&... args) inline void trace(format_string_t<Args...> fmt, Args &&...args)
{ {
default_logger_raw()->trace(fmt, std::forward<Args>(args)...); default_logger_raw()->trace(fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void debug(format_string_t<Args...> fmt, Args &&... args) inline void debug(format_string_t<Args...> fmt, Args &&...args)
{ {
default_logger_raw()->debug(fmt, std::forward<Args>(args)...); default_logger_raw()->debug(fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void info(format_string_t<Args...> fmt, Args &&... args) inline void info(format_string_t<Args...> fmt, Args &&...args)
{ {
default_logger_raw()->info(fmt, std::forward<Args>(args)...); default_logger_raw()->info(fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void warn(format_string_t<Args...> fmt, Args &&... args) inline void warn(format_string_t<Args...> fmt, Args &&...args)
{ {
default_logger_raw()->warn(fmt, std::forward<Args>(args)...); default_logger_raw()->warn(fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void error(format_string_t<Args...> fmt, Args &&... args) inline void error(format_string_t<Args...> fmt, Args &&...args)
{ {
default_logger_raw()->error(fmt, std::forward<Args>(args)...); default_logger_raw()->error(fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void critical(format_string_t<Args...> fmt, Args &&... args) inline void critical(format_string_t<Args...> fmt, Args &&...args)
{ {
default_logger_raw()->critical(fmt, std::forward<Args>(args)...); default_logger_raw()->critical(fmt, std::forward<Args>(args)...);
} }
@ -202,49 +202,49 @@ inline void log(level::level_enum lvl, const T &msg)
#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
template<typename... Args> template<typename... Args>
inline void log(source_loc source, level::level_enum lvl, wformat_string_t<Args...> fmt, Args &&... args) inline void log(source_loc source, level::level_enum lvl, wformat_string_t<Args...> fmt, Args &&...args)
{ {
default_logger_raw()->log(source, lvl, fmt, std::forward<Args>(args)...); default_logger_raw()->log(source, lvl, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void log(level::level_enum lvl, wformat_string_t<Args...> fmt, Args &&... args) inline void log(level::level_enum lvl, wformat_string_t<Args...> fmt, Args &&...args)
{ {
default_logger_raw()->log(source_loc{}, lvl, fmt, std::forward<Args>(args)...); default_logger_raw()->log(source_loc{}, lvl, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void trace(wformat_string_t<Args...> fmt, Args &&... args) inline void trace(wformat_string_t<Args...> fmt, Args &&...args)
{ {
default_logger_raw()->trace(fmt, std::forward<Args>(args)...); default_logger_raw()->trace(fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void debug(wformat_string_t<Args...> fmt, Args &&... args) inline void debug(wformat_string_t<Args...> fmt, Args &&...args)
{ {
default_logger_raw()->debug(fmt, std::forward<Args>(args)...); default_logger_raw()->debug(fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void info(wformat_string_t<Args...> fmt, Args &&... args) inline void info(wformat_string_t<Args...> fmt, Args &&...args)
{ {
default_logger_raw()->info(fmt, std::forward<Args>(args)...); default_logger_raw()->info(fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void warn(wformat_string_t<Args...> fmt, Args &&... args) inline void warn(wformat_string_t<Args...> fmt, Args &&...args)
{ {
default_logger_raw()->warn(fmt, std::forward<Args>(args)...); default_logger_raw()->warn(fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void error(wformat_string_t<Args...> fmt, Args &&... args) inline void error(wformat_string_t<Args...> fmt, Args &&...args)
{ {
default_logger_raw()->error(fmt, std::forward<Args>(args)...); default_logger_raw()->error(fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void critical(wformat_string_t<Args...> fmt, Args &&... args) inline void critical(wformat_string_t<Args...> fmt, Args &&...args)
{ {
default_logger_raw()->critical(fmt, std::forward<Args>(args)...); default_logger_raw()->critical(fmt, std::forward<Args>(args)...);
} }

8
tests/CMakeLists.txt
Unescape Escape View File

@ -14,16 +14,12 @@ if(PkgConfig_FOUND)
endif() endif()
find_package(Catch2 3 QUIET) find_package(Catch2 3 QUIET)
if (Catch2_FOUND) if(Catch2_FOUND)
message(STATUS "Packaged version of Catch will be used.") message(STATUS "Packaged version of Catch will be used.")
else() else()
message(STATUS "Bundled version of Catch will be downloaded and used.") message(STATUS "Bundled version of Catch will be downloaded and used.")
include(FetchContent) include(FetchContent)
FetchContent_Declare( FetchContent_Declare(Catch2 GIT_REPOSITORY https://github.com/catchorg/Catch2.git GIT_TAG v3.3.2)
Catch2
GIT_REPOSITORY https://github.com/catchorg/Catch2.git
GIT_TAG v3.3.2
)
FetchContent_MakeAvailable(Catch2) FetchContent_MakeAvailable(Catch2)
endif() endif()

8
tests/test_errors.cpp
Unescape Escape View File

@ -1,6 +1,6 @@
/* /*
* This content is released under the MIT License as specified in https://raw.githubusercontent.com/gabime/spdlog/master/LICENSE * This content is released under the MIT License as specified in https://raw.githubusercontent.com/gabime/spdlog/master/LICENSE
*/ */
#include "includes.h" #include "includes.h"
#include <iostream> #include <iostream>
@ -21,7 +21,8 @@ protected:
throw std::runtime_error("some error happened during flush"); throw std::runtime_error("some error happened during flush");
} }
}; };
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]")
@ -39,7 +40,6 @@ TEST_CASE("default_error_handler", "[errors]")
REQUIRE(count_lines(SIMPLE_LOG) == 1); REQUIRE(count_lines(SIMPLE_LOG) == 1);
} }
TEST_CASE("custom_error_handler", "[errors]") TEST_CASE("custom_error_handler", "[errors]")
{ {
prepare_logdir(); prepare_logdir();

2
tests/test_pattern_formatter.cpp
Unescape Escape View File

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

Write Preview
Loading…
Cancel
Save