mirrors/spdlog
1
0
Fork 0
mirror of https://github.com/gabime/spdlog.git synced 2025-03-15 02:29:54 +08:00
Code

bugfix in color detection and astyle

Browse Source
This commit is contained in:
gabime 2017-05-17 00:06:11 +03:00
parent eb92cc35df
commit 1d6842f0f9
6 changed files with 156 additions and 145 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
include/spdlog/details/async_log_helper.h
View File

@ -56,13 +56,13 @@ class async_log_helper
~async_msg() = default; ~async_msg() = default;
async_msg(async_msg&& other) SPDLOG_NOEXCEPT: async_msg(async_msg&& other) SPDLOG_NOEXCEPT:
logger_name(std::move(other.logger_name)), logger_name(std::move(other.logger_name)),
level(std::move(other.level)), level(std::move(other.level)),
time(std::move(other.time)), time(std::move(other.time)),
thread_id(other.thread_id), thread_id(other.thread_id),
txt(std::move(other.txt)), txt(std::move(other.txt)),
msg_type(std::move(other.msg_type)) msg_type(std::move(other.msg_type))
{} {}
async_msg(async_msg_type m_type): async_msg(async_msg_type m_type):

28
include/spdlog/details/logger_impl.h
View File

@ -19,9 +19,9 @@ inline spdlog::logger::logger(const std::string& logger_name, const It& begin, c
_name(logger_name), _name(logger_name),
_sinks(begin, end), _sinks(begin, end),
_formatter(std::make_shared<pattern_formatter>("%+")), _formatter(std::make_shared<pattern_formatter>("%+")),
_level(level::info), _level(level::info),
_flush_level(level::off), _flush_level(level::off),
_last_err_time(0) _last_err_time(0)
{ {
_err_handler = [this](const std::string &msg) _err_handler = [this](const std::string &msg)
{ {
@ -201,55 +201,55 @@ inline void spdlog::logger::critical(const T& msg)
template <typename... Args> template <typename... Args>
inline void spdlog::logger::log(level::level_enum lvl, const wchar_t* msg) inline void spdlog::logger::log(level::level_enum lvl, const wchar_t* msg)
{ {
std::wstring_convert<std::codecvt_utf8<wchar_t> > conv; std::wstring_convert<std::codecvt_utf8<wchar_t> > conv;
log(lvl, conv.to_bytes(msg)); log(lvl, conv.to_bytes(msg));
} }
template <typename... Args> template <typename... Args>
inline void spdlog::logger::log(level::level_enum lvl, const wchar_t* fmt, const Args&... args) inline void spdlog::logger::log(level::level_enum lvl, const wchar_t* fmt, const Args&... args)
{ {
fmt::WMemoryWriter wWriter; fmt::WMemoryWriter wWriter;
wWriter.write(fmt, args...); wWriter.write(fmt, args...);
log(lvl, wWriter.c_str()); log(lvl, wWriter.c_str());
} }
template <typename... Args> template <typename... Args>
inline void spdlog::logger::trace(const wchar_t* fmt, const Args&... args) inline void spdlog::logger::trace(const wchar_t* fmt, const Args&... args)
{ {
log(level::trace, fmt, args...); log(level::trace, fmt, args...);
} }
template <typename... Args> template <typename... Args>
inline void spdlog::logger::debug(const wchar_t* fmt, const Args&... args) inline void spdlog::logger::debug(const wchar_t* fmt, const Args&... args)
{ {
log(level::debug, fmt, args...); log(level::debug, fmt, args...);
} }
template <typename... Args> template <typename... Args>
inline void spdlog::logger::info(const wchar_t* fmt, const Args&... args) inline void spdlog::logger::info(const wchar_t* fmt, const Args&... args)
{ {
log(level::info, fmt, args...); log(level::info, fmt, args...);
} }
template <typename... Args> template <typename... Args>
inline void spdlog::logger::warn(const wchar_t* fmt, const Args&... args) inline void spdlog::logger::warn(const wchar_t* fmt, const Args&... args)
{ {
log(level::warn, fmt, args...); log(level::warn, fmt, args...);
} }
template <typename... Args> template <typename... Args>
inline void spdlog::logger::error(const wchar_t* fmt, const Args&... args) inline void spdlog::logger::error(const wchar_t* fmt, const Args&... args)
{ {
log(level::err, fmt, args...); log(level::err, fmt, args...);
} }
template <typename... Args> template <typename... Args>
inline void spdlog::logger::critical(const wchar_t* fmt, const Args&... args) inline void spdlog::logger::critical(const wchar_t* fmt, const Args&... args)
{ {
log(level::critical, fmt, args...); log(level::critical, fmt, args...);
} }
#endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT #endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT

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

@ -365,14 +365,19 @@ inline std::string filename_to_str(const filename_t& filename)
} }
#endif #endif
inline std::string errno_to_string(char [256], char* res) { inline std::string errno_to_string(char [256], char* res)
{
return std::string(res); return std::string(res);
} }
inline std::string errno_to_string(char buf[256], int res) { inline std::string errno_to_string(char buf[256], int res)
if (res == 0) { {
if (res == 0)
{
return std::string(buf); return std::string(buf);
} else { }
else
{
return "Unknown error"; return "Unknown error";
} }
} }
@ -419,24 +424,28 @@ inline int pid()
// Source: https://github.com/agauniyal/rang/ // Source: https://github.com/agauniyal/rang/
bool is_color_terminal() bool is_color_terminal()
{ {
#ifdef _WIN32 #ifdef _WIN32
return true; return true;
#else #else
static constexpr const char* Terms[] = { static constexpr const char* Terms[] =
"ansi", "color", "console", "cygwin", "gnome", "konsole", "kterm", {
"linux", "msys", "putty", "rxvt", "screen", "vt100", "xterm" "ansi", "color", "console", "cygwin", "gnome", "konsole", "kterm",
}; "linux", "msys", "putty", "rxvt", "screen", "vt100", "xterm"
};
const char *env_p = std::getenv("TERM");
if (env_p == nullptr) { const char *env_p = std::getenv("TERM");
return false; if (env_p == nullptr)
} {
return false;
static const bool result = std::any_of( }
std::begin(Terms), std::end(Terms), [&](const char* term) {
return std::strstr(env_p, term) != nullptr; static const bool result = std::any_of(
}); std::begin(Terms), std::end(Terms), [&](const char* term)
#endif {
return std::strstr(env_p, term) != nullptr;
});
return result;
#endif
} }

16
include/spdlog/logger.h
View File

@ -44,14 +44,14 @@ public:
template <typename Arg1, typename... Args> void error(const char* fmt, const Arg1&, const Args&... args); template <typename Arg1, typename... Args> void error(const char* fmt, const Arg1&, const Args&... args);
template <typename Arg1, typename... Args> void critical(const char* fmt, const Arg1&, const Args&... args); template <typename Arg1, typename... Args> void critical(const char* fmt, const Arg1&, const Args&... args);
#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
template <typename... Args> void log(level::level_enum lvl, const wchar_t* msg); template <typename... Args> void log(level::level_enum lvl, const wchar_t* msg);
template <typename... Args> void log(level::level_enum lvl, const wchar_t* fmt, const Args&... args); template <typename... Args> void log(level::level_enum lvl, const wchar_t* fmt, const Args&... args);
template <typename... Args> void trace(const wchar_t* fmt, const Args&... args); template <typename... Args> void trace(const wchar_t* fmt, const Args&... args);
template <typename... Args> void debug(const wchar_t* fmt, const Args&... args); template <typename... Args> void debug(const wchar_t* fmt, const Args&... args);
template <typename... Args> void info(const wchar_t* fmt, const Args&... args); template <typename... Args> void info(const wchar_t* fmt, const Args&... args);
template <typename... Args> void warn(const wchar_t* fmt, const Args&... args); template <typename... Args> void warn(const wchar_t* fmt, const Args&... args);
template <typename... Args> void error(const wchar_t* fmt, const Args&... args); template <typename... Args> void error(const wchar_t* fmt, const Args&... args);
template <typename... Args> void critical(const wchar_t* fmt, const Args&... args); template <typename... Args> void critical(const wchar_t* fmt, const Args&... args);
#endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT #endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT
template <typename T> void log(level::level_enum lvl, const T&); template <typename T> void log(level::level_enum lvl, const T&);

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

@ -31,7 +31,7 @@ namespace sinks
class android_sink : public sink class android_sink : public sink
{ {
public: public:
explicit android_sink(const std::string& tag = "spdlog", bool use_raw_msg = false): _tag(tag), _use_raw_msg(use_raw_msg){} explicit android_sink(const std::string& tag = "spdlog", bool use_raw_msg = false): _tag(tag), _use_raw_msg(use_raw_msg) {}
void log(const details::log_msg& msg) override void log(const details::log_msg& msg) override
{ {

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

@ -14,112 +14,114 @@
namespace spdlog namespace spdlog
{ {
namespace sinks namespace sinks
{ {
/** /**
* @brief The ansi_color_sink is a decorator around another sink and prefixes * @brief The ansi_color_sink is a decorator around another sink and prefixes
* the output with an ANSI escape sequence color code depending on the severity * the output with an ANSI escape sequence color code depending on the severity
* of the message. * of the message.
*/ */
class ansicolor_sink SPDLOG_FINAL: public sink class ansicolor_sink SPDLOG_FINAL: public sink
{ {
public: public:
ansicolor_sink(sink_ptr wrapped_sink); ansicolor_sink(sink_ptr wrapped_sink);
virtual ~ansicolor_sink(); virtual ~ansicolor_sink();
ansicolor_sink(const ansicolor_sink& other) = delete; ansicolor_sink(const ansicolor_sink& other) = delete;
ansicolor_sink& operator=(const ansicolor_sink& other) = delete; ansicolor_sink& operator=(const ansicolor_sink& other) = delete;
virtual void log(const details::log_msg& msg) override; virtual void log(const details::log_msg& msg) override;
virtual void flush() override; virtual void flush() override;
void set_color(level::level_enum color_level, const std::string& color); void set_color(level::level_enum color_level, const std::string& color);
/// Formatting codes /// Formatting codes
const std::string reset = "\033[00m"; const std::string reset = "\033[00m";
const std::string bold = "\033[1m"; const std::string bold = "\033[1m";
const std::string dark = "\033[2m"; const std::string dark = "\033[2m";
const std::string underline = "\033[4m"; const std::string underline = "\033[4m";
const std::string blink = "\033[5m"; const std::string blink = "\033[5m";
const std::string reverse = "\033[7m"; const std::string reverse = "\033[7m";
const std::string concealed = "\033[8m"; const std::string concealed = "\033[8m";
// Foreground colors // Foreground colors
const std::string grey = "\033[30m"; const std::string grey = "\033[30m";
const std::string red = "\033[31m"; const std::string red = "\033[31m";
const std::string green = "\033[32m"; const std::string green = "\033[32m";
const std::string yellow = "\033[33m"; const std::string yellow = "\033[33m";
const std::string blue = "\033[34m"; const std::string blue = "\033[34m";
const std::string magenta = "\033[35m"; const std::string magenta = "\033[35m";
const std::string cyan = "\033[36m"; const std::string cyan = "\033[36m";
const std::string white = "\033[37m"; const std::string white = "\033[37m";
/// Background colors /// Background colors
const std::string on_grey = "\033[40m"; const std::string on_grey = "\033[40m";
const std::string on_red = "\033[41m"; const std::string on_red = "\033[41m";
const std::string on_green = "\033[42m"; const std::string on_green = "\033[42m";
const std::string on_yellow = "\033[43m"; const std::string on_yellow = "\033[43m";
const std::string on_blue = "\033[44m"; const std::string on_blue = "\033[44m";
const std::string on_magenta = "\033[45m"; const std::string on_magenta = "\033[45m";
const std::string on_cyan = "\033[46m"; const std::string on_cyan = "\033[46m";
const std::string on_white = "\033[47m"; const std::string on_white = "\033[47m";
protected: protected:
bool is_color_terminal_; bool is_color_terminal_;
sink_ptr sink_; sink_ptr sink_;
std::map<level::level_enum, std::string> colors_; std::map<level::level_enum, std::string> colors_;
}; };
inline ansicolor_sink::ansicolor_sink(sink_ptr wrapped_sink): sink_(wrapped_sink) inline ansicolor_sink::ansicolor_sink(sink_ptr wrapped_sink): sink_(wrapped_sink)
{ {
is_color_terminal_ = details::os::is_color_terminal(); is_color_terminal_ = details::os::is_color_terminal();
colors_[level::trace] = cyan; colors_[level::trace] = cyan;
colors_[level::debug] = cyan; colors_[level::debug] = cyan;
colors_[level::info] = bold; colors_[level::info] = bold;
colors_[level::warn] = yellow + bold; colors_[level::warn] = yellow + bold;
colors_[level::err] = red + bold; colors_[level::err] = red + bold;
colors_[level::critical] = bold + on_red; colors_[level::critical] = bold + on_red;
colors_[level::off] = reset; colors_[level::off] = reset;
} }
inline void ansicolor_sink::log(const details::log_msg& msg) inline void ansicolor_sink::log(const details::log_msg& msg)
{ {
// Wrap the originally formatted message in color codes. // Wrap the originally formatted message in color codes.
// If color is not supported in the terminal, log as is instead. // If color is not supported in the terminal, log as is instead.
if (is_color_terminal_) { if (is_color_terminal_)
const std::string& prefix = colors_[msg.level]; {
const std::string& s = msg.formatted.str(); const std::string& prefix = colors_[msg.level];
const std::string& suffix = reset; const std::string& s = msg.formatted.str();
details::log_msg m; const std::string& suffix = reset;
m.level = msg.level; details::log_msg m;
m.logger_name = msg.logger_name; m.level = msg.level;
m.time = msg.time; m.logger_name = msg.logger_name;
m.thread_id = msg.thread_id; m.time = msg.time;
m.formatted << prefix << s << suffix; m.thread_id = msg.thread_id;
sink_->log(m); m.formatted << prefix << s << suffix;
} sink_->log(m);
else { }
sink_->log(msg); else
} {
} sink_->log(msg);
}
}
inline void ansicolor_sink::flush() inline void ansicolor_sink::flush()
{ {
sink_->flush(); sink_->flush();
} }
inline void ansicolor_sink::set_color(level::level_enum color_level, const std::string& color) inline void ansicolor_sink::set_color(level::level_enum color_level, const std::string& color)
{ {
colors_[color_level] = color; colors_[color_level] = color;
} }
inline ansicolor_sink::~ansicolor_sink() inline ansicolor_sink::~ansicolor_sink()
{ {
flush(); flush();
} }
} // namespace sinks } // namespace sinks
} // namespace spdlog } // namespace spdlog