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

[feature] Support dynamic tag setting in android.

Browse Source 
[change] Modify the Android example, and other examples fail to run error.
pull/2002/head
lilinxiong 4 years ago committed by lilinxiong
parent 70d2832c0d
commit d2979c82d9
26 changed files with 127 additions and 83 deletions
Show Stats Download Patch File Download Diff File

4
example/example.cpp
Unescape Escape View File

@ -261,8 +261,8 @@ void syslog_example()
void android_example()
{
std::string tag = "spdlog-android";
auto android_logger = spdlog::android_logger_mt("android", tag);
android_logger->critical("Use \"adb shell logcat\" to view this message.");
auto android_logger = spdlog::android_logger_mt("android");
android_logger->critical("cus_critical_tag", "Use \"adb shell logcat\" to view this message.");
}
#endif

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

@ -24,7 +24,7 @@ SPDLOG_INLINE spdlog::async_logger::async_logger(
{}
// 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 char*tag, const details::log_msg &msg)
{
if (auto pool_ptr = thread_pool_.lock())
{
@ -52,7 +52,7 @@ SPDLOG_INLINE void spdlog::async_logger::flush_()
//
// backend functions - called from the thread pool to do the actual job
//
SPDLOG_INLINE void spdlog::async_logger::backend_sink_it_(const details::log_msg &msg)
SPDLOG_INLINE void spdlog::async_logger::backend_sink_it_(const char*tag, const details::log_msg &msg)
{
for (auto &sink : sinks_)
{
@ -60,7 +60,7 @@ SPDLOG_INLINE void spdlog::async_logger::backend_sink_it_(const details::log_msg
{
SPDLOG_TRY
{
sink->log(msg);
sink->log(tag, msg);
}
SPDLOG_LOGGER_CATCH()
}

4
include/spdlog/async_logger.h
Unescape Escape View File

@ -52,9 +52,9 @@ public:
std::shared_ptr<logger> clone(std::string new_name) override;
protected:
void sink_it_(const details::log_msg &msg) override;
void sink_it_(const char*tag, const details::log_msg &msg) override;
void flush_() override;
void backend_sink_it_(const details::log_msg &incoming_log_msg);
void backend_sink_it_(const char*tag, const details::log_msg &incoming_log_msg);
void backend_flush_();
private:

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

@ -96,7 +96,7 @@ class formatter;
namespace sinks {
class sink;
}
static const char* spdlog_default_tag = "SPD_Log_TAG";
#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
using filename_t = std::wstring;
// allow macro expansion to occur in SPDLOG_FILENAME_T

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

@ -105,7 +105,7 @@ bool SPDLOG_INLINE thread_pool::process_next_msg_()
switch (incoming_async_msg.msg_type)
{
case async_msg_type::log: {
incoming_async_msg.worker_ptr->backend_sink_it_(incoming_async_msg);
incoming_async_msg.worker_ptr->backend_sink_it_("", incoming_async_msg);
return true;
}
case async_msg_type::flush: {

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

@ -163,11 +163,11 @@ SPDLOG_INLINE std::shared_ptr<logger> logger::clone(std::string logger_name)
}
// protected methods
SPDLOG_INLINE void logger::log_it_(const spdlog::details::log_msg &log_msg, bool log_enabled, bool traceback_enabled)
SPDLOG_INLINE void logger::log_it_(const char*tag, const spdlog::details::log_msg &log_msg, bool log_enabled, bool traceback_enabled)
{
if (log_enabled)
{
sink_it_(log_msg);
sink_it_(tag, log_msg);
}
if (traceback_enabled)
{
@ -175,7 +175,7 @@ SPDLOG_INLINE void logger::log_it_(const spdlog::details::log_msg &log_msg, bool
}
}
SPDLOG_INLINE void logger::sink_it_(const details::log_msg &msg)
SPDLOG_INLINE void logger::sink_it_(const char*tag, const details::log_msg &msg)
{
for (auto &sink : sinks_)
{
@ -183,7 +183,7 @@ SPDLOG_INLINE void logger::sink_it_(const details::log_msg &msg)
{
SPDLOG_TRY
{
sink->log(msg);
sink->log(tag, msg);
}
SPDLOG_LOGGER_CATCH()
}
@ -212,9 +212,9 @@ SPDLOG_INLINE void logger::dump_backtrace_()
using details::log_msg;
if (tracer_.enabled())
{
sink_it_(log_msg{name(), level::info, "****************** Backtrace Start ******************"});
tracer_.foreach_pop([this](const log_msg &msg) { this->sink_it_(msg); });
sink_it_(log_msg{name(), level::info, "****************** Backtrace End ********************"});
sink_it_("", log_msg{name(), level::info, "****************** Backtrace Start ******************"});
tracer_.foreach_pop([this](const log_msg &msg) { this->sink_it_("", msg); });
sink_it_("", log_msg{name(), level::info, "****************** Backtrace End ********************"});
}
}

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

@ -84,15 +84,15 @@ public:
// FormatString is NOT a type derived from fmt::compile_string but is a string_view_t or can be implicitly converted to one
template<typename... Args>
void log(source_loc loc, level::level_enum lvl, string_view_t fmt, Args &&...args)
void log(const char* tag, source_loc loc, level::level_enum lvl, string_view_t fmt, Args &&...args)
{
log_(loc, lvl, fmt, std::forward<Args>(args)...);
log_(tag, loc, lvl, fmt, std::forward<Args>(args)...);
}
template<typename FormatString, typename... Args>
void log(level::level_enum lvl, const FormatString &fmt, Args &&...args)
{
log(source_loc{}, lvl, fmt, std::forward<Args>(args)...);
log(default_tag(), source_loc{}, lvl, fmt, std::forward<Args>(args)...);
}
template<typename FormatString, typename... Args>
@ -132,17 +132,17 @@ public:
}
template<typename T>
void log(level::level_enum lvl, const T &msg)
void log(const char*tag, level::level_enum lvl, const T &msg)
{
log(source_loc{}, lvl, msg);
log(tag, source_loc{}, lvl, msg);
}
// T can be statically converted to string_view and isn't a fmt::compile_string
template<class T, typename std::enable_if<
std::is_convertible<const T &, spdlog::string_view_t>::value && !fmt::is_compile_string<T>::value, int>::type = 0>
void log(source_loc loc, level::level_enum lvl, const T &msg)
void log(const char* tag, source_loc loc, level::level_enum lvl, const T &msg)
{
log(loc, lvl, string_view_t{msg});
log(tag, loc, lvl, string_view_t{msg});
}
void log(log_clock::time_point log_time, source_loc loc, level::level_enum lvl, string_view_t msg)
@ -155,10 +155,10 @@ public:
}
details::log_msg log_msg(log_time, loc, name_, lvl, msg);
log_it_(log_msg, log_enabled, traceback_enabled);
log_it_("", log_msg, log_enabled, traceback_enabled);
}
void log(source_loc loc, level::level_enum lvl, string_view_t msg)
void log(const char* tag, source_loc loc, level::level_enum lvl, string_view_t msg)
{
bool log_enabled = should_log(lvl);
bool traceback_enabled = tracer_.enabled();
@ -168,12 +168,12 @@ public:
}
details::log_msg log_msg(loc, name_, lvl, msg);
log_it_(log_msg, log_enabled, traceback_enabled);
log_it_(tag, log_msg, log_enabled, traceback_enabled);
}
void log(level::level_enum lvl, string_view_t msg)
void log(const char* tag, level::level_enum lvl, string_view_t msg)
{
log(source_loc{}, lvl, msg);
log(tag, source_loc{}, lvl, msg);
}
// T cannot be statically converted to string_view or wstring_view
@ -185,42 +185,79 @@ public:
log(loc, lvl, "{}", msg);
}
template<typename T>
void trace(const char* tag, const T &msg)
{
log(tag, level::trace, msg);
}
template<typename T>
void trace(const T &msg)
{
log(level::trace, msg);
trace(default_tag(), msg);
}
template<typename T>
void debug(const char* tag, const T &msg)
{
log(tag, level::debug, msg);
}
template<typename T>
void debug(const T &msg)
{
log(level::debug, msg);
debug(default_tag(), msg);
}
template<typename T>
void info(const char* tag, const T &msg)
{
log(tag, level::info, msg);
}
template<typename T>
void info(const T &msg)
{
log(level::info, msg);
info(default_tag(), msg);
}
template<typename T>
void warn(const char* tag, const T &msg)
{
log(tag, level::warn, msg);
}
template<typename T>
void warn(const T &msg)
{
log(level::warn, msg);
warn(default_tag(), msg);
}
template<typename T>
void error(const char* tag, const T &msg)
{
log(tag, level::err, msg);
}
template<typename T>
void error(const T &msg)
{
log(level::err, msg);
error(default_tag(), msg);
}
template<typename T>
void critical(const char* tag, const T &msg)
{
log(tag, level::critical, msg);
}
template<typename T>
void critical(const T &msg)
{
log(level::critical, msg);
critical(default_tag(), msg);
}
#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
# ifndef _WIN32
# error SPDLOG_WCHAR_TO_UTF8_SUPPORT only supported on windows
@ -327,7 +364,7 @@ protected:
// common implementation for after templated public api has been resolved
template<typename FormatString, typename... Args>
void log_(source_loc loc, level::level_enum lvl, const FormatString &fmt, Args &&...args)
void log_(const char* tag, source_loc loc, level::level_enum lvl, const FormatString &fmt, Args &&...args)
{
bool log_enabled = should_log(lvl);
bool traceback_enabled = tracer_.enabled();
@ -341,15 +378,15 @@ protected:
// faster than fmt::format_to(std::back_inserter(buf), fmt, std::forward<Args>(args)...);
fmt::detail::vformat_to(buf, fmt::string_view(fmt), fmt::make_format_args(args...), {});
details::log_msg log_msg(loc, name_, lvl, string_view_t(buf.data(), buf.size()));
log_it_(log_msg, log_enabled, traceback_enabled);
log_it_(tag, log_msg, log_enabled, traceback_enabled);
}
SPDLOG_LOGGER_CATCH()
}
// log the given message (if the given log level is high enough),
// and save backtrace (if backtrace is enabled).
void log_it_(const details::log_msg &log_msg, bool log_enabled, bool traceback_enabled);
virtual void sink_it_(const details::log_msg &msg);
void log_it_(const char*tag, const details::log_msg &log_msg, bool log_enabled, bool traceback_enabled);
virtual void sink_it_(const char*tag, const details::log_msg &msg);
virtual void flush_();
void dump_backtrace_();
bool should_flush_(const details::log_msg &msg);
@ -357,6 +394,7 @@ protected:
// handle errors during logging.
// default handler prints the error to stderr at max rate of 1 message/sec.
void err_handler_(const std::string &msg);
const char* default_tag() { return spdlog_default_tag; }
};
void swap(logger &a, logger &b);

21
include/spdlog/sinks/android_sink.h
Unescape Escape View File

@ -31,13 +31,12 @@ template<typename Mutex>
class android_sink final : public base_sink<Mutex>
{
public:
explicit android_sink(std::string tag = "spdlog", bool use_raw_msg = false)
: tag_(std::move(tag))
, use_raw_msg_(use_raw_msg)
explicit android_sink(bool use_raw_msg = false)
:use_raw_msg_(use_raw_msg)
{}
protected:
void sink_it_(const details::log_msg &msg) override
void sink_it_(const char* tag, const details::log_msg &msg) override
{
const android_LogPriority priority = convert_to_android_(msg.level);
memory_buf_t formatted;
@ -53,12 +52,12 @@ protected:
const char *msg_output = formatted.data();
// See system/core/liblog/logger_write.c for explanation of return value
int ret = __android_log_write(priority, tag_.c_str(), msg_output);
int ret = __android_log_write(priority, tag, msg_output);
int retry_count = 0;
while ((ret == -11 /*EAGAIN*/) && (retry_count < SPDLOG_ANDROID_RETRIES))
{
details::os::sleep_for_millis(5);
ret = __android_log_write(priority, tag_.c_str(), msg_output);
ret = __android_log_write(priority, tag, msg_output);
retry_count++;
}
@ -91,8 +90,6 @@ private:
return ANDROID_LOG_DEFAULT;
}
}
std::string tag_;
bool use_raw_msg_;
};
@ -103,15 +100,15 @@ using android_sink_st = android_sink<details::null_mutex>;
// Create and register android syslog logger
template<typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> android_logger_mt(const std::string &logger_name, const std::string &tag = "spdlog")
inline std::shared_ptr<logger> android_logger_mt(const std::string &logger_name)
{
return Factory::template create<sinks::android_sink_mt>(logger_name, tag);
return Factory::template create<sinks::android_sink_mt>(logger_name);
}
template<typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> android_logger_st(const std::string &logger_name, const std::string &tag = "spdlog")
inline std::shared_ptr<logger> android_logger_st(const std::string &logger_name)
{
return Factory::template create<sinks::android_sink_st>(logger_name, tag);
return Factory::template create<sinks::android_sink_st>(logger_name);
}
} // namespace spdlog

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

@ -38,7 +38,7 @@ SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color(level::level_enum col
}
template<typename ConsoleMutex>
SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::log(const details::log_msg &msg)
SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::log(const char* tag, const details::log_msg &msg)
{
// Wrap the originally formatted message in color codes.
// If color is not supported in the terminal, log as is instead.

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

@ -39,7 +39,7 @@ public:
void set_color_mode(color_mode mode);
bool should_color();
void log(const details::log_msg &msg) override;
void log(const char* tag, const details::log_msg &msg) override;
void flush() override;
void set_pattern(const std::string &pattern) final;
void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) override;

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

@ -23,10 +23,10 @@ SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::base_sink(std::unique_ptr<spdlog:
{}
template<typename Mutex>
void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::log(const details::log_msg &msg)
void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::log(const char* tag, const details::log_msg &msg)
{
std::lock_guard<Mutex> lock(mutex_);
sink_it_(msg);
sink_it_(tag, msg);
}
template<typename Mutex>

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

@ -29,7 +29,7 @@ public:
base_sink &operator=(const base_sink &) = delete;
base_sink &operator=(base_sink &&) = delete;
void log(const details::log_msg &msg) final;
void log(const char* tag, const details::log_msg &msg) final;
void flush() final;
void set_pattern(const std::string &pattern) final;
void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) final;
@ -39,7 +39,7 @@ protected:
std::unique_ptr<spdlog::formatter> formatter_;
mutable Mutex mutex_;
virtual void sink_it_(const details::log_msg &msg) = 0;
virtual void sink_it_(const char* tag, const details::log_msg &msg) = 0;
virtual void flush_() = 0;
virtual void set_pattern_(const std::string &pattern);
virtual void set_formatter_(std::unique_ptr<spdlog::formatter> sink_formatter);

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

@ -26,7 +26,7 @@ SPDLOG_INLINE const filename_t &basic_file_sink<Mutex>::filename() const
}
template<typename Mutex>
SPDLOG_INLINE void basic_file_sink<Mutex>::sink_it_(const details::log_msg &msg)
SPDLOG_INLINE void basic_file_sink<Mutex>::sink_it_(const char*tag, const details::log_msg &msg)
{
memory_buf_t formatted;
base_sink<Mutex>::formatter_->format(msg, formatted);

2
include/spdlog/sinks/basic_file_sink.h
Unescape Escape View File

@ -24,7 +24,7 @@ public:
const filename_t &filename() const;
protected:
void sink_it_(const details::log_msg &msg) override;
void sink_it_(const char*tag, const details::log_msg &msg) override;
void flush_() override;
private:

2
include/spdlog/sinks/daily_file_sink.h
Unescape Escape View File

@ -99,7 +99,7 @@ public:
}
protected:
void sink_it_(const details::log_msg &msg) override
void sink_it_(const char*tag, const details::log_msg &msg) override
{
auto time = msg.time;
bool should_rotate = time >= rotation_tp_;

2
include/spdlog/sinks/dist_sink.h
Unescape Escape View File

@ -55,7 +55,7 @@ public:
}
protected:
void sink_it_(const details::log_msg &msg) override
void sink_it_(const char*tag, const details::log_msg &msg) override
{
for (auto &sink : sinks_)
{

2
include/spdlog/sinks/dup_filter_sink.h
Unescape Escape View File

@ -51,7 +51,7 @@ protected:
std::string last_msg_payload_;
size_t skip_counter_ = 0;
void sink_it_(const details::log_msg &msg) override
void sink_it_(const char*tag, const details::log_msg &msg) override
{
bool filtered = filter_(msg);
if (!filtered)

2
include/spdlog/sinks/ringbuffer_sink.h
Unescape Escape View File

@ -56,7 +56,7 @@ public:
}
protected:
void sink_it_(const details::log_msg &msg) override
void sink_it_(const char*tag, const details::log_msg &msg) override
{
q_.push_back(details::log_msg_buffer{msg});
}

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

@ -61,7 +61,7 @@ SPDLOG_INLINE filename_t rotating_file_sink<Mutex>::filename()
}
template<typename Mutex>
SPDLOG_INLINE void rotating_file_sink<Mutex>::sink_it_(const details::log_msg &msg)
SPDLOG_INLINE void rotating_file_sink<Mutex>::sink_it_(const char*tag, const details::log_msg &msg)
{
memory_buf_t formatted;
base_sink<Mutex>::formatter_->format(msg, formatted);

2
include/spdlog/sinks/rotating_file_sink.h
Unescape Escape View File

@ -27,7 +27,7 @@ public:
filename_t filename();
protected:
void sink_it_(const details::log_msg &msg) override;
void sink_it_(const char*tag, const details::log_msg &msg) override;
void flush_() override;
private:

2
include/spdlog/sinks/sink.h
Unescape Escape View File

@ -13,7 +13,7 @@ class SPDLOG_API sink
{
public:
virtual ~sink() = default;
virtual void log(const details::log_msg &msg) = 0;
virtual void log(const char* tag, const details::log_msg &msg) = 0;
virtual void flush() = 0;
virtual void set_pattern(const std::string &pattern) = 0;
virtual void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) = 0;

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

@ -50,7 +50,7 @@ SPDLOG_INLINE stdout_sink_base<ConsoleMutex>::stdout_sink_base(FILE *file)
}
template<typename ConsoleMutex>
SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::log(const details::log_msg &msg)
SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::log(const char* tag, const details::log_msg &msg)
{
#ifdef _WIN32
if (handle_ == INVALID_HANDLE_VALUE)

2
include/spdlog/sinks/stdout_sinks.h
Unescape Escape View File

@ -30,7 +30,7 @@ public:
stdout_sink_base &operator=(const stdout_sink_base &other) = delete;
stdout_sink_base &operator=(stdout_sink_base &&other) = delete;
void log(const details::log_msg &msg) override;
void log(const char* tag, const details::log_msg &msg) override;
void flush() override;
void set_pattern(const std::string &pattern) override;

2
include/spdlog/sinks/syslog_sink.h
Unescape Escape View File

@ -45,7 +45,7 @@ public:
syslog_sink &operator=(const syslog_sink &) = delete;
protected:
void sink_it_(const details::log_msg &msg) override
void sink_it_(const char* tag, const details::log_msg &msg) override
{
string_view_t payload;
memory_buf_t formatted;

4
include/spdlog/spdlog-inl.h
Unescape Escape View File

@ -16,7 +16,9 @@ SPDLOG_INLINE void initialize_logger(std::shared_ptr<logger> logger)
{
details::registry::instance().initialize_logger(std::move(logger));
}
SPDLOG_API const char* default_tag() {
return spdlog_default_tag;
}
SPDLOG_INLINE std::shared_ptr<logger> get(const std::string &name)
{
return details::registry::instance().get(name);

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

@ -46,6 +46,8 @@ inline std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs
// spdlog::initialize_logger(mylogger);
SPDLOG_API void initialize_logger(std::shared_ptr<logger> logger);
SPDLOG_API const char* default_tag();
// Return an existing logger or nullptr if a logger with such name doesn't
// exist.
// example: spdlog::get("my_logger")->info("hello {}", "world");
@ -237,52 +239,57 @@ inline void critical(const T &msg)
// SPDLOG_LEVEL_CRITICAL,
// SPDLOG_LEVEL_OFF
//
#define SPDLOG_LOGGER_CALL(logger, level, ...) (logger)->log(spdlog::source_loc{__FILE__, __LINE__, SPDLOG_FUNCTION}, level, __VA_ARGS__)
#define SPDLOG_LOGGER_CALL(logger, tag, level, ...) (logger)->log(tag, spdlog::source_loc{__FILE__, __LINE__, SPDLOG_FUNCTION}, level, __VA_ARGS__)
#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_TRACE
#define SPDLOG_LOGGER_TRACE(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::trace, __VA_ARGS__)
#define SPDLOG_TRACE(...) SPDLOG_LOGGER_TRACE(spdlog::default_logger_raw(), __VA_ARGS__)
#define SPDLOG_LOGGER_TRACE(logger, tag ...) SPDLOG_LOGGER_CALL(logger, tag, spdlog::level::trace, __VA_ARGS__)
#define SPDLOG_TAG_TRACE(tag, ...) SPDLOG_LOGGER_TRACE(spdlog::default_logger_raw(), tag, __VA_ARGS__)
#define SPDLOG_TRACE(...) SPDLOG_LOGGER_TRACE(spdlog::default_logger_raw(), spdlog::default_tag(), __VA_ARGS__)
#else
#define SPDLOG_LOGGER_TRACE(logger, ...) (void)0
#define SPDLOG_TRACE(...) (void)0
#endif
#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_DEBUG
#define SPDLOG_LOGGER_DEBUG(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::debug, __VA_ARGS__)
#define SPDLOG_DEBUG(...) SPDLOG_LOGGER_DEBUG(spdlog::default_logger_raw(), __VA_ARGS__)
#define SPDLOG_LOGGER_DEBUG(logger, tag, ...) SPDLOG_LOGGER_CALL(logger, tag, spdlog::level::debug, __VA_ARGS__)
#define SPDLOG_TAG_DEBUG(tag, ...) SPDLOG_LOGGER_DEBUG(spdlog::default_logger_raw(), tag, __VA_ARGS__)
#define SPDLOG_DEBUG(...) SPDLOG_LOGGER_DEBUG(spdlog::default_logger_raw(), spdlog::default_tag(), __VA_ARGS__)
#else
#define SPDLOG_LOGGER_DEBUG(logger, ...) (void)0
#define SPDLOG_DEBUG(...) (void)0
#endif
#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_INFO
#define SPDLOG_LOGGER_INFO(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::info, __VA_ARGS__)
#define SPDLOG_INFO(...) SPDLOG_LOGGER_INFO(spdlog::default_logger_raw(), __VA_ARGS__)
#define SPDLOG_LOGGER_INFO(logger, tag, ...) SPDLOG_LOGGER_CALL(logger, tag, spdlog::level::info, __VA_ARGS__)
#define SPDLOG_TAG_INFO(tag, ...) SPDLOG_LOGGER_INFO(spdlog::default_logger_raw(), tag, __VA_ARGS__)
#define SPDLOG_INFO(...) SPDLOG_LOGGER_INFO(spdlog::default_logger_raw(), spdlog::default_tag(), __VA_ARGS__)
#else
#define SPDLOG_LOGGER_INFO(logger, ...) (void)0
#define SPDLOG_INFO(...) (void)0
#endif
#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_WARN
#define SPDLOG_LOGGER_WARN(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::warn, __VA_ARGS__)
#define SPDLOG_WARN(...) SPDLOG_LOGGER_WARN(spdlog::default_logger_raw(), __VA_ARGS__)
#define SPDLOG_LOGGER_WARN(logger, tag, ...) SPDLOG_LOGGER_CALL(logger, tag, spdlog::level::warn, __VA_ARGS__)
#define SPDLOG_TAG_WARN(tag, ...) SPDLOG_LOGGER_WARN(spdlog::default_logger_raw(),tag, __VA_ARGS__)
#define SPDLOG_WARN(...) SPDLOG_LOGGER_WARN(spdlog::default_logger_raw(), spdlog::default_tag(), __VA_ARGS__)
#else
#define SPDLOG_LOGGER_WARN(logger, ...) (void)0
#define SPDLOG_WARN(...) (void)0
#endif
#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_ERROR
#define SPDLOG_LOGGER_ERROR(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::err, __VA_ARGS__)
#define SPDLOG_ERROR(...) SPDLOG_LOGGER_ERROR(spdlog::default_logger_raw(), __VA_ARGS__)
#define SPDLOG_LOGGER_ERROR(logger, tag, ...) SPDLOG_LOGGER_CALL(logger, tag, spdlog::level::err, __VA_ARGS__)
#define SPDLOG_TAG_ERROR(tag, ...) SPDLOG_LOGGER_ERROR(spdlog::default_logger_raw(), tag, __VA_ARGS__)
#define SPDLOG_ERROR(...) SPDLOG_LOGGER_ERROR(spdlog::default_logger_raw(), spdlog::default_tag(), __VA_ARGS__)
#else
#define SPDLOG_LOGGER_ERROR(logger, ...) (void)0
#define SPDLOG_ERROR(...) (void)0
#endif
#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_CRITICAL
#define SPDLOG_LOGGER_CRITICAL(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::critical, __VA_ARGS__)
#define SPDLOG_CRITICAL(...) SPDLOG_LOGGER_CRITICAL(spdlog::default_logger_raw(), __VA_ARGS__)
#define SPDLOG_LOGGER_CRITICAL(logger, tag, ...) SPDLOG_LOGGER_CALL(logger, tag, spdlog::level::critical, __VA_ARGS__)
#define SPDLOG_TAG_CRITICAL(tag, ...) SPDLOG_LOGGER_CRITICAL(spdlog::default_logger_raw(), tag, __VA_ARGS__)
#define SPDLOG_CRITICAL(...) SPDLOG_LOGGER_CRITICAL(spdlog::default_logger_raw(), spdlog::default_tag(), __VA_ARGS__)
#else
#define SPDLOG_LOGGER_CRITICAL(logger, ...) (void)0
#define SPDLOG_CRITICAL(...) (void)0

Write Preview
Loading…
Cancel
Save