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

clang-format

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

3
example/example.cpp
Unescape Escape View File

@ -245,7 +245,8 @@ void user_defined_example()
void err_handler_example() void err_handler_example()
{ {
// can be set globally or per logger(logger->set_error_handler(..)) // can be set globally or per logger(logger->set_error_handler(..))
spdlog::default_logger()->set_error_handler([](const std::string &msg) { printf("*** Custom log error handler: %s ***\n", msg.c_str()); }); spdlog::default_logger()->set_error_handler(
[](const std::string &msg) { printf("*** Custom log error handler: %s ***\n", msg.c_str()); });
} }
// syslog example (linux/osx/freebsd) // syslog example (linux/osx/freebsd)

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

@ -27,7 +27,7 @@ namespace details {
static const size_t default_async_q_size = 8192; static const size_t default_async_q_size = 8192;
static std::shared_ptr<thread_pool> s_thread_pool; static std::shared_ptr<thread_pool> s_thread_pool;
static std::recursive_mutex s_thread_pool_mutex; static std::recursive_mutex s_thread_pool_mutex;
} } // namespace details
// async logger factory - creates async loggers backed with thread pool. // async logger factory - creates async loggers backed with thread pool.
// if a global thread pool doesn't already exist, create it with default queue // if a global thread pool doesn't already exist, create it with default queue
@ -45,10 +45,10 @@ struct async_factory_impl
if (!details::s_thread_pool) if (!details::s_thread_pool)
{ {
details::s_thread_pool = std::make_shared<details::thread_pool>(details::default_async_q_size, 1U); details::s_thread_pool = std::make_shared<details::thread_pool>(details::default_async_q_size, 1U);
} }
auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...); auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...);
auto new_logger = std::make_shared<async_logger>(std::move(logger_name), std::move(sink), std::move(details::s_thread_pool), OverflowPolicy); auto new_logger =
std::make_shared<async_logger>(std::move(logger_name), std::move(sink), std::move(details::s_thread_pool), OverflowPolicy);
return new_logger; return new_logger;
} }
}; };

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

@ -56,7 +56,6 @@ public:
::WSACleanup(); ::WSACleanup();
} }
bool is_connected() const bool is_connected() const
{ {
return socket_ != INVALID_SOCKET; return socket_ != INVALID_SOCKET;
@ -73,7 +72,6 @@ public:
return socket_; return socket_;
} }
// try to connect or throw on failure // try to connect or throw on failure
void connect(const std::string &host, int port) void connect(const std::string &host, int port)
{ {

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

@ -64,7 +64,8 @@ public:
addr_.sin_family = PF_INET; addr_.sin_family = PF_INET;
addr_.sin_port = htons(port); addr_.sin_port = htons(port);
addr_.sin_addr.s_addr = INADDR_ANY; addr_.sin_addr.s_addr = INADDR_ANY;
if (InetPton(PF_INET, TEXT(host.c_str()), &addr_.sin_addr.s_addr) != 1) { if (InetPton(PF_INET, TEXT(host.c_str()), &addr_.sin_addr.s_addr) != 1)
{
int last_error = ::WSAGetLastError(); int last_error = ::WSAGetLastError();
::WSACleanup(); ::WSACleanup();
throw_winsock_error_("error: Invalid address!", last_error); throw_winsock_error_("error: Invalid address!", last_error);

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

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

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

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

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

@ -925,7 +925,6 @@ private:
log_clock::time_point last_message_time_; log_clock::time_point last_message_time_;
}; };
} // namespace details } // namespace details
SPDLOG_INLINE pattern_formatter::pattern_formatter( SPDLOG_INLINE pattern_formatter::pattern_formatter(

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

@ -118,7 +118,6 @@ private:
void compile_pattern_(const std::string &pattern); void compile_pattern_(const std::string &pattern);
}; };
// set pattern to logger // set pattern to logger
SPDLOG_API void set_pattern(logger &logger, std::string pattern); SPDLOG_API void set_pattern(logger &logger, std::string pattern);

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

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

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

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

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

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

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

@ -53,7 +53,6 @@ inline std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs
SPDLOG_API std::shared_ptr<spdlog::logger> &default_logger(); SPDLOG_API std::shared_ptr<spdlog::logger> &default_logger();
SPDLOG_API void set_default_logger(std::shared_ptr<spdlog::logger> default_logger); SPDLOG_API void set_default_logger(std::shared_ptr<spdlog::logger> default_logger);
template<typename... Args> template<typename... Args>
inline void log(source_loc source, level::level_enum lvl, fmt::format_string<Args...> fmt, Args &&... args) inline void log(source_loc source, level::level_enum lvl, fmt::format_string<Args...> fmt, Args &&... args)
{ {

Write Preview
Loading…
Cancel
Save