EIC code displayed by LXR master/​include/​spdlog/​pattern_formatter-inl.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-18 10:12:44

 // Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
 
 #pragma once
 
 #ifndef SPDLOG_HEADER_ONLY
 #    include <spdlog/pattern_formatter.h>
 #endif
 
 #include <spdlog/details/fmt_helper.h>
 #include <spdlog/details/log_msg.h>
 #include <spdlog/details/os.h>
 #include <spdlog/fmt/fmt.h>
 #include <spdlog/formatter.h>
 
 #include <algorithm>
 #include <array>
 #include <chrono>
 #include <ctime>
 #include <cctype>
 #include <cstring>
 #include <iterator>
 #include <memory>
 #include <mutex>
 #include <string>
 #include <thread>
 #include <utility>
 #include <vector>
 
 namespace spdlog {
 namespace details {
 
 ///////////////////////////////////////////////////////////////////////
 // name & level pattern appender
 ///////////////////////////////////////////////////////////////////////
 
 class scoped_padder
 {
 public:
     scoped_padder(size_t wrapped_size, const padding_info &padinfo, memory_buf_t &dest)
         : padinfo_(padinfo)
         , dest_(dest)
     {
         remaining_pad_ = static_cast<long>(padinfo.width_) - static_cast<long>(wrapped_size);
         if (remaining_pad_ <= 0)
         {
             return;
         }
 
         if (padinfo_.side_ == padding_info::pad_side::left)
         {
             pad_it(remaining_pad_);
             remaining_pad_ = 0;
         }
         else if (padinfo_.side_ == padding_info::pad_side::center)
         {
             auto half_pad = remaining_pad_ / 2;
             auto reminder = remaining_pad_ & 1;
             pad_it(half_pad);
             remaining_pad_ = half_pad + reminder; // for the right side
         }
     }
 
     template<typename T>
     static unsigned int count_digits(T n)
     {
         return fmt_helper::count_digits(n);
     }
 
     ~scoped_padder()
     {
         if (remaining_pad_ >= 0)
         {
             pad_it(remaining_pad_);
         }
         else if (padinfo_.truncate_)
         {
             long new_size = static_cast<long>(dest_.size()) + remaining_pad_;
             dest_.resize(static_cast<size_t>(new_size));
         }
     }
 
 private:
     void pad_it(long count)
     {
         fmt_helper::append_string_view(string_view_t(spaces_.data(), static_cast<size_t>(count)), dest_);
     }
 
     const padding_info &padinfo_;
     memory_buf_t &dest_;
     long remaining_pad_;
     string_view_t spaces_{"                                                                ", 64};
 };
 
 struct null_scoped_padder
 {
     null_scoped_padder(size_t /*wrapped_size*/, const padding_info & /*padinfo*/, memory_buf_t & /*dest*/) {}
 
     template<typename T>
     static unsigned int count_digits(T /* number */)
     {
         return 0;
     }
 };
 
 template<typename ScopedPadder>
 class name_formatter final : public flag_formatter
 {
 public:
     explicit name_formatter(padding_info padinfo)
         : flag_formatter(padinfo)
     {}
 
     void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
     {
         ScopedPadder p(msg.logger_name.size(), padinfo_, dest);
         fmt_helper::append_string_view(msg.logger_name, dest);
     }
 };
 
 // log level appender
 template<typename ScopedPadder>
 class level_formatter final : public flag_formatter
 {
 public:
     explicit level_formatter(padding_info padinfo)
         : flag_formatter(padinfo)
     {}
 
     void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
     {
         const string_view_t &level_name = level::to_string_view(msg.level);
         ScopedPadder p(level_name.size(), padinfo_, dest);
         fmt_helper::append_string_view(level_name, dest);
     }
 };
 
 // short log level appender
 template<typename ScopedPadder>
 class short_level_formatter final : public flag_formatter
 {
 public:
     explicit short_level_formatter(padding_info padinfo)
         : flag_formatter(padinfo)
     {}
 
     void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
     {
         string_view_t level_name{level::to_short_c_str(msg.level)};
         ScopedPadder p(level_name.size(), padinfo_, dest);
         fmt_helper::append_string_view(level_name, dest);
     }
 };
 
 ///////////////////////////////////////////////////////////////////////
 // Date time pattern appenders
 ///////////////////////////////////////////////////////////////////////
 
 static const char *ampm(const tm &t)
 {
     return t.tm_hour >= 12 ? "PM" : "AM";
 }
 
 static int to12h(const tm &t)
 {
     return t.tm_hour > 12 ? t.tm_hour - 12 : t.tm_hour;
 }
 
 // Abbreviated weekday name
 static std::array<const char *, 7> days{{"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"}};
 
 template<typename ScopedPadder>
 class a_formatter final : public flag_formatter
 {
 public:
     explicit a_formatter(padding_info padinfo)
         : flag_formatter(padinfo)
     {}
 
     void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
     {
         string_view_t field_value{days[static_cast<size_t>(tm_time.tm_wday)]};
         ScopedPadder p(field_value.size(), padinfo_, dest);
         fmt_helper::append_string_view(field_value, dest);
     }
 };
 
 // Full weekday name
 static std::array<const char *, 7> full_days{{"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"}};
 
 template<typename ScopedPadder>
 class A_formatter : public flag_formatter
 {
 public:
     explicit A_formatter(padding_info padinfo)
         : flag_formatter(padinfo)
     {}
 
     void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
     {
         string_view_t field_value{full_days[static_cast<size_t>(tm_time.tm_wday)]};
         ScopedPadder p(field_value.size(), padinfo_, dest);
         fmt_helper::append_string_view(field_value, dest);
     }
 };
 
 // Abbreviated month
 static const std::array<const char *, 12> months{{"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sept", "Oct", "Nov", "Dec"}};
 
 template<typename ScopedPadder>
 class b_formatter final : public flag_formatter
 {
 public:
     explicit b_formatter(padding_info padinfo)
         : flag_formatter(padinfo)
     {}
 
     void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
     {
         string_view_t field_value{months[static_cast<size_t>(tm_time.tm_mon)]};
         ScopedPadder p(field_value.size(), padinfo_, dest);
         fmt_helper::append_string_view(field_value, dest);
     }
 };
 
 // Full month name
 static const std::array<const char *, 12> full_months{
     {"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"}};
 
 template<typename ScopedPadder>
 class B_formatter final : public flag_formatter
 {
 public:
     explicit B_formatter(padding_info padinfo)
         : flag_formatter(padinfo)
     {}
 
     void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
     {
         string_view_t field_value{full_months[static_cast<size_t>(tm_time.tm_mon)]};
         ScopedPadder p(field_value.size(), padinfo_, dest);
         fmt_helper::append_string_view(field_value, dest);
     }
 };
 
 // Date and time representation (Thu Aug 23 15:35:46 2014)
 template<typename ScopedPadder>
 class c_formatter final : public flag_formatter
 {
 public:
     explicit c_formatter(padding_info padinfo)
         : flag_formatter(padinfo)
     {}
 
     void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
     {
         const size_t field_size = 24;
         ScopedPadder p(field_size, padinfo_, dest);
 
         fmt_helper::append_string_view(days[static_cast<size_t>(tm_time.tm_wday)], dest);
         dest.push_back(' ');
         fmt_helper::append_string_view(months[static_cast<size_t>(tm_time.tm_mon)], dest);
         dest.push_back(' ');
         fmt_helper::append_int(tm_time.tm_mday, dest);
         dest.push_back(' ');
         // time
 
         fmt_helper::pad2(tm_time.tm_hour, dest);
         dest.push_back(':');
         fmt_helper::pad2(tm_time.tm_min, dest);
         dest.push_back(':');
         fmt_helper::pad2(tm_time.tm_sec, dest);
         dest.push_back(' ');
         fmt_helper::append_int(tm_time.tm_year + 1900, dest);
     }
 };
 
 // year - 2 digit
 template<typename ScopedPadder>
 class C_formatter final : public flag_formatter
 {
 public:
     explicit C_formatter(padding_info padinfo)
         : flag_formatter(padinfo)
     {}
 
     void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
     {
         const size_t field_size = 2;
         ScopedPadder p(field_size, padinfo_, dest);
         fmt_helper::pad2(tm_time.tm_year % 100, dest);
     }
 };
 
 // Short MM/DD/YY date, equivalent to %m/%d/%y 08/23/01
 template<typename ScopedPadder>
 class D_formatter final : public flag_formatter
 {
 public:
     explicit D_formatter(padding_info padinfo)
         : flag_formatter(padinfo)
     {}
 
     void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
     {
         const size_t field_size = 10;
         ScopedPadder p(field_size, padinfo_, dest);
 
         fmt_helper::pad2(tm_time.tm_mon + 1, dest);
         dest.push_back('/');
         fmt_helper::pad2(tm_time.tm_mday, dest);
         dest.push_back('/');
         fmt_helper::pad2(tm_time.tm_year % 100, dest);
     }
 };
 
 // year - 4 digit
 template<typename ScopedPadder>
 class Y_formatter final : public flag_formatter
 {
 public:
     explicit Y_formatter(padding_info padinfo)
         : flag_formatter(padinfo)
     {}
 
     void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
     {
         const size_t field_size = 4;
         ScopedPadder p(field_size, padinfo_, dest);
         fmt_helper::append_int(tm_time.tm_year + 1900, dest);
     }
 };
 
 // month 1-12
 template<typename ScopedPadder>
 class m_formatter final : public flag_formatter
 {
 public:
     explicit m_formatter(padding_info padinfo)
         : flag_formatter(padinfo)
     {}
 
     void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
     {
         const size_t field_size = 2;
         ScopedPadder p(field_size, padinfo_, dest);
         fmt_helper::pad2(tm_time.tm_mon + 1, dest);
     }
 };
 
 // day of month 1-31
 template<typename ScopedPadder>
 class d_formatter final : public flag_formatter
 {
 public:
     explicit d_formatter(padding_info padinfo)
         : flag_formatter(padinfo)
     {}
 
     void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
     {
         const size_t field_size = 2;
         ScopedPadder p(field_size, padinfo_, dest);
         fmt_helper::pad2(tm_time.tm_mday, dest);
     }
 };
 
 // hours in 24 format 0-23
 template<typename ScopedPadder>
 class H_formatter final : public flag_formatter
 {
 public:
     explicit H_formatter(padding_info padinfo)
         : flag_formatter(padinfo)
     {}
 
     void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
     {
         const size_t field_size = 2;
         ScopedPadder p(field_size, padinfo_, dest);
         fmt_helper::pad2(tm_time.tm_hour, dest);
     }
 };
 
 // hours in 12 format 1-12
 template<typename ScopedPadder>
 class I_formatter final : public flag_formatter
 {
 public:
     explicit I_formatter(padding_info padinfo)
         : flag_formatter(padinfo)
     {}
 
     void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
     {
         const size_t field_size = 2;
         ScopedPadder p(field_size, padinfo_, dest);
         fmt_helper::pad2(to12h(tm_time), dest);
     }
 };
 
 // minutes 0-59
 template<typename ScopedPadder>
 class M_formatter final : public flag_formatter
 {
 public:
     explicit M_formatter(padding_info padinfo)
         : flag_formatter(padinfo)
     {}
 
     void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
     {
         const size_t field_size = 2;
         ScopedPadder p(field_size, padinfo_, dest);
         fmt_helper::pad2(tm_time.tm_min, dest);
     }
 };
 
 // seconds 0-59
 template<typename ScopedPadder>
 class S_formatter final : public flag_formatter
 {
 public:
     explicit S_formatter(padding_info padinfo)
         : flag_formatter(padinfo)
     {}
 
     void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
     {
         const size_t field_size = 2;
         ScopedPadder p(field_size, padinfo_, dest);
         fmt_helper::pad2(tm_time.tm_sec, dest);
     }
 };
 
 // milliseconds
 template<typename ScopedPadder>
 class e_formatter final : public flag_formatter
 {
 public:
     explicit e_formatter(padding_info padinfo)
         : flag_formatter(padinfo)
     {}
 
     void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
     {
         auto millis = fmt_helper::time_fraction<std::chrono::milliseconds>(msg.time);
         const size_t field_size = 3;
         ScopedPadder p(field_size, padinfo_, dest);
         fmt_helper::pad3(static_cast<uint32_t>(millis.count()), dest);
     }
 };
 
 // microseconds
 template<typename ScopedPadder>
 class f_formatter final : public flag_formatter
 {
 public:
     explicit f_formatter(padding_info padinfo)
         : flag_formatter(padinfo)
     {}
 
     void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
     {
         auto micros = fmt_helper::time_fraction<std::chrono::microseconds>(msg.time);
 
         const size_t field_size = 6;
         ScopedPadder p(field_size, padinfo_, dest);
         fmt_helper::pad6(static_cast<size_t>(micros.count()), dest);
     }
 };
 
 // nanoseconds
 template<typename ScopedPadder>
 class F_formatter final : public flag_formatter
 {
 public:
     explicit F_formatter(padding_info padinfo)
         : flag_formatter(padinfo)
     {}
 
     void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
     {
         auto ns = fmt_helper::time_fraction<std::chrono::nanoseconds>(msg.time);
         const size_t field_size = 9;
         ScopedPadder p(field_size, padinfo_, dest);
         fmt_helper::pad9(static_cast<size_t>(ns.count()), dest);
     }
 };
 
 // seconds since epoch
 template<typename ScopedPadder>
 class E_formatter final : public flag_formatter
 {
 public:
     explicit E_formatter(padding_info padinfo)
         : flag_formatter(padinfo)
     {}
 
     void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
     {
         const size_t field_size = 10;
         ScopedPadder p(field_size, padinfo_, dest);
         auto duration = msg.time.time_since_epoch();
         auto seconds = std::chrono::duration_cast<std::chrono::seconds>(duration).count();
         fmt_helper::append_int(seconds, dest);
     }
 };
 
 // AM/PM
 template<typename ScopedPadder>
 class p_formatter final : public flag_formatter
 {
 public:
     explicit p_formatter(padding_info padinfo)
         : flag_formatter(padinfo)
     {}
 
     void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
     {
         const size_t field_size = 2;
         ScopedPadder p(field_size, padinfo_, dest);
         fmt_helper::append_string_view(ampm(tm_time), dest);
     }
 };
 
 // 12 hour clock 02:55:02 pm
 template<typename ScopedPadder>
 class r_formatter final : public flag_formatter
 {
 public:
     explicit r_formatter(padding_info padinfo)
         : flag_formatter(padinfo)
     {}
 
     void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
     {
         const size_t field_size = 11;
         ScopedPadder p(field_size, padinfo_, dest);
 
         fmt_helper::pad2(to12h(tm_time), dest);
         dest.push_back(':');
         fmt_helper::pad2(tm_time.tm_min, dest);
         dest.push_back(':');
         fmt_helper::pad2(tm_time.tm_sec, dest);
         dest.push_back(' ');
         fmt_helper::append_string_view(ampm(tm_time), dest);
     }
 };
 
 // 24-hour HH:MM time, equivalent to %H:%M
 template<typename ScopedPadder>
 class R_formatter final : public flag_formatter
 {
 public:
     explicit R_formatter(padding_info padinfo)
         : flag_formatter(padinfo)
     {}
 
     void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
     {
         const size_t field_size = 5;
         ScopedPadder p(field_size, padinfo_, dest);
 
         fmt_helper::pad2(tm_time.tm_hour, dest);
         dest.push_back(':');
         fmt_helper::pad2(tm_time.tm_min, dest);
     }
 };
 
 // ISO 8601 time format (HH:MM:SS), equivalent to %H:%M:%S
 template<typename ScopedPadder>
 class T_formatter final : public flag_formatter
 {
 public:
     explicit T_formatter(padding_info padinfo)
         : flag_formatter(padinfo)
     {}
 
     void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
     {
         const size_t field_size = 8;
         ScopedPadder p(field_size, padinfo_, dest);
 
         fmt_helper::pad2(tm_time.tm_hour, dest);
         dest.push_back(':');
         fmt_helper::pad2(tm_time.tm_min, dest);
         dest.push_back(':');
         fmt_helper::pad2(tm_time.tm_sec, dest);
     }
 };
 
 // ISO 8601 offset from UTC in timezone (+-HH:MM)
 template<typename ScopedPadder>
 class z_formatter final : public flag_formatter
 {
 public:
     explicit z_formatter(padding_info padinfo)
         : flag_formatter(padinfo)
     {}
 
     z_formatter() = default;
     z_formatter(const z_formatter &) = delete;
     z_formatter &operator=(const z_formatter &) = delete;
 
     void format(const details::log_msg &msg, const std::tm &tm_time, memory_buf_t &dest) override
     {
         const size_t field_size = 6;
         ScopedPadder p(field_size, padinfo_, dest);
 
         auto total_minutes = get_cached_offset(msg, tm_time);
         bool is_negative = total_minutes < 0;
         if (is_negative)
         {
             total_minutes = -total_minutes;
             dest.push_back('-');
         }
         else
         {
             dest.push_back('+');
         }
 
         fmt_helper::pad2(total_minutes / 60, dest); // hours
         dest.push_back(':');
         fmt_helper::pad2(total_minutes % 60, dest); // minutes
     }
 
 private:
     log_clock::time_point last_update_{std::chrono::seconds(0)};
     int offset_minutes_{0};
 
     int get_cached_offset(const log_msg &msg, const std::tm &tm_time)
     {
         // refresh every 10 seconds
         if (msg.time - last_update_ >= std::chrono::seconds(10))
         {
             offset_minutes_ = os::utc_minutes_offset(tm_time);
             last_update_ = msg.time;
         }
         return offset_minutes_;
     }
 };
 
 // Thread id
 template<typename ScopedPadder>
 class t_formatter final : public flag_formatter
 {
 public:
     explicit t_formatter(padding_info padinfo)
         : flag_formatter(padinfo)
     {}
 
     void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
     {
         const auto field_size = ScopedPadder::count_digits(msg.thread_id);
         ScopedPadder p(field_size, padinfo_, dest);
         fmt_helper::append_int(msg.thread_id, dest);
     }
 };
 
 // Current pid
 template<typename ScopedPadder>
 class pid_formatter final : public flag_formatter
 {
 public:
     explicit pid_formatter(padding_info padinfo)
         : flag_formatter(padinfo)
     {}
 
     void format(const details::log_msg &, const std::tm &, memory_buf_t &dest) override
     {
         const auto pid = static_cast<uint32_t>(details::os::pid());
         auto field_size = ScopedPadder::count_digits(pid);
         ScopedPadder p(field_size, padinfo_, dest);
         fmt_helper::append_int(pid, dest);
     }
 };
 
 template<typename ScopedPadder>
 class v_formatter final : public flag_formatter
 {
 public:
     explicit v_formatter(padding_info padinfo)
         : flag_formatter(padinfo)
     {}
 
     void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
     {
         ScopedPadder p(msg.payload.size(), padinfo_, dest);
         fmt_helper::append_string_view(msg.payload, dest);
     }
 };
 
 class ch_formatter final : public flag_formatter
 {
 public:
     explicit ch_formatter(char ch)
         : ch_(ch)
     {}
 
     void format(const details::log_msg &, const std::tm &, memory_buf_t &dest) override
     {
         dest.push_back(ch_);
     }
 
 private:
     char ch_;
 };
 
 // aggregate user chars to display as is
 class aggregate_formatter final : public flag_formatter
 {
 public:
     aggregate_formatter() = default;
 
     void add_ch(char ch)
     {
         str_ += ch;
     }
     void format(const details::log_msg &, const std::tm &, memory_buf_t &dest) override
     {
         fmt_helper::append_string_view(str_, dest);
     }
 
 private:
     std::string str_;
 };
 
 // mark the color range. expect it to be in the form of "%^colored text%$"
 class color_start_formatter final : public flag_formatter
 {
 public:
     explicit color_start_formatter(padding_info padinfo)
         : flag_formatter(padinfo)
     {}
 
     void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
     {
         msg.color_range_start = dest.size();
     }
 };
 
 class color_stop_formatter final : public flag_formatter
 {
 public:
     explicit color_stop_formatter(padding_info padinfo)
         : flag_formatter(padinfo)
     {}
 
     void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
     {
         msg.color_range_end = dest.size();
     }
 };
 
 // print source location
 template<typename ScopedPadder>
 class source_location_formatter final : public flag_formatter
 {
 public:
     explicit source_location_formatter(padding_info padinfo)
         : flag_formatter(padinfo)
     {}
 
     void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
     {
         if (msg.source.empty())
         {
             ScopedPadder p(0, padinfo_, dest);
             return;
         }
 
         size_t text_size;
         if (padinfo_.enabled())
         {
             // calc text size for padding based on "filename:line"
             text_size = std::char_traits<char>::length(msg.source.filename) + ScopedPadder::count_digits(msg.source.line) + 1;
         }
         else
         {
             text_size = 0;
         }
 
         ScopedPadder p(text_size, padinfo_, dest);
         fmt_helper::append_string_view(msg.source.filename, dest);
         dest.push_back(':');
         fmt_helper::append_int(msg.source.line, dest);
     }
 };
 
 // print source filename
 template<typename ScopedPadder>
 class source_filename_formatter final : public flag_formatter
 {
 public:
     explicit source_filename_formatter(padding_info padinfo)
         : flag_formatter(padinfo)
     {}
 
     void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
     {
         if (msg.source.empty())
         {
             ScopedPadder p(0, padinfo_, dest);
             return;
         }
         size_t text_size = padinfo_.enabled() ? std::char_traits<char>::length(msg.source.filename) : 0;
         ScopedPadder p(text_size, padinfo_, dest);
         fmt_helper::append_string_view(msg.source.filename, dest);
     }
 };
 
 template<typename ScopedPadder>
 class short_filename_formatter final : public flag_formatter
 {
 public:
     explicit short_filename_formatter(padding_info padinfo)
         : flag_formatter(padinfo)
     {}
 
 #ifdef _MSC_VER
 #    pragma warning(push)
 #    pragma warning(disable : 4127) // consider using 'if constexpr' instead
 #endif                              // _MSC_VER
     static const char *basename(const char *filename)
     {
         // if the size is 2 (1 character + null terminator) we can use the more efficient strrchr
         // the branch will be elided by optimizations
         if (sizeof(os::folder_seps) == 2)
         {
             const char *rv = std::strrchr(filename, os::folder_seps[0]);
             return rv != nullptr ? rv + 1 : filename;
         }
         else
         {
             const std::reverse_iterator<const char *> begin(filename + std::strlen(filename));
             const std::reverse_iterator<const char *> end(filename);
 
             const auto it = std::find_first_of(begin, end, std::begin(os::folder_seps), std::end(os::folder_seps) - 1);
             return it != end ? it.base() : filename;
         }
     }
 #ifdef _MSC_VER
 #    pragma warning(pop)
 #endif // _MSC_VER
 
     void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
     {
         if (msg.source.empty())
         {
             ScopedPadder p(0, padinfo_, dest);
             return;
         }
         auto filename = basename(msg.source.filename);
         size_t text_size = padinfo_.enabled() ? std::char_traits<char>::length(filename) : 0;
         ScopedPadder p(text_size, padinfo_, dest);
         fmt_helper::append_string_view(filename, dest);
     }
 };
 
 template<typename ScopedPadder>
 class source_linenum_formatter final : public flag_formatter
 {
 public:
     explicit source_linenum_formatter(padding_info padinfo)
         : flag_formatter(padinfo)
     {}
 
     void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
     {
         if (msg.source.empty())
         {
             ScopedPadder p(0, padinfo_, dest);
             return;
         }
 
         auto field_size = ScopedPadder::count_digits(msg.source.line);
         ScopedPadder p(field_size, padinfo_, dest);
         fmt_helper::append_int(msg.source.line, dest);
     }
 };
 
 // print source funcname
 template<typename ScopedPadder>
 class source_funcname_formatter final : public flag_formatter
 {
 public:
     explicit source_funcname_formatter(padding_info padinfo)
         : flag_formatter(padinfo)
     {}
 
     void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
     {
         if (msg.source.empty())
         {
             ScopedPadder p(0, padinfo_, dest);
             return;
         }
         size_t text_size = padinfo_.enabled() ? std::char_traits<char>::length(msg.source.funcname) : 0;
         ScopedPadder p(text_size, padinfo_, dest);
         fmt_helper::append_string_view(msg.source.funcname, dest);
     }
 };
 
 // print elapsed time since last message
 template<typename ScopedPadder, typename Units>
 class elapsed_formatter final : public flag_formatter
 {
 public:
     using DurationUnits = Units;
 
     explicit elapsed_formatter(padding_info padinfo)
         : flag_formatter(padinfo)
         , last_message_time_(log_clock::now())
     {}
 
     void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
     {
         auto delta = (std::max)(msg.time - last_message_time_, log_clock::duration::zero());
         auto delta_units = std::chrono::duration_cast<DurationUnits>(delta);
         last_message_time_ = msg.time;
         auto delta_count = static_cast<size_t>(delta_units.count());
         auto n_digits = static_cast<size_t>(ScopedPadder::count_digits(delta_count));
         ScopedPadder p(n_digits, padinfo_, dest);
         fmt_helper::append_int(delta_count, dest);
     }
 
 private:
     log_clock::time_point last_message_time_;
 };
 
 // Full info formatter
 // pattern: [%Y-%m-%d %H:%M:%S.%e] [%n] [%l] [%s:%#] %v
 class full_formatter final : public flag_formatter
 {
 public:
     explicit full_formatter(padding_info padinfo)
         : flag_formatter(padinfo)
     {}
 
     void format(const details::log_msg &msg, const std::tm &tm_time, memory_buf_t &dest) override
     {
         using std::chrono::duration_cast;
         using std::chrono::milliseconds;
         using std::chrono::seconds;
 
         // cache the date/time part for the next second.
         auto duration = msg.time.time_since_epoch();
         auto secs = duration_cast<seconds>(duration);
 
         if (cache_timestamp_ != secs || cached_datetime_.size() == 0)
         {
             cached_datetime_.clear();
             cached_datetime_.push_back('[');
             fmt_helper::append_int(tm_time.tm_year + 1900, cached_datetime_);
             cached_datetime_.push_back('-');
 
             fmt_helper::pad2(tm_time.tm_mon + 1, cached_datetime_);
             cached_datetime_.push_back('-');
 
             fmt_helper::pad2(tm_time.tm_mday, cached_datetime_);
             cached_datetime_.push_back(' ');
 
             fmt_helper::pad2(tm_time.tm_hour, cached_datetime_);
             cached_datetime_.push_back(':');
 
             fmt_helper::pad2(tm_time.tm_min, cached_datetime_);
             cached_datetime_.push_back(':');
 
             fmt_helper::pad2(tm_time.tm_sec, cached_datetime_);
             cached_datetime_.push_back('.');
 
             cache_timestamp_ = secs;
         }
         dest.append(cached_datetime_.begin(), cached_datetime_.end());
 
         auto millis = fmt_helper::time_fraction<milliseconds>(msg.time);
         fmt_helper::pad3(static_cast<uint32_t>(millis.count()), dest);
         dest.push_back(']');
         dest.push_back(' ');
 
         // append logger name if exists
         if (msg.logger_name.size() > 0)
         {
             dest.push_back('[');
             fmt_helper::append_string_view(msg.logger_name, dest);
             dest.push_back(']');
             dest.push_back(' ');
         }
 
         dest.push_back('[');
         // wrap the level name with color
         msg.color_range_start = dest.size();
         // fmt_helper::append_string_view(level::to_c_str(msg.level), dest);
         fmt_helper::append_string_view(level::to_string_view(msg.level), dest);
         msg.color_range_end = dest.size();
         dest.push_back(']');
         dest.push_back(' ');
 
         // add source location if present
         if (!msg.source.empty())
         {
             dest.push_back('[');
             const char *filename = details::short_filename_formatter<details::null_scoped_padder>::basename(msg.source.filename);
             fmt_helper::append_string_view(filename, dest);
             dest.push_back(':');
             fmt_helper::append_int(msg.source.line, dest);
             dest.push_back(']');
             dest.push_back(' ');
         }
         // fmt_helper::append_string_view(msg.msg(), dest);
         fmt_helper::append_string_view(msg.payload, dest);
     }
 
 private:
     std::chrono::seconds cache_timestamp_{0};
     memory_buf_t cached_datetime_;
 };
 
 } // namespace details
 
 SPDLOG_INLINE pattern_formatter::pattern_formatter(
     std::string pattern, pattern_time_type time_type, std::string eol, custom_flags custom_user_flags)
     : pattern_(std::move(pattern))
     , eol_(std::move(eol))
     , pattern_time_type_(time_type)
     , need_localtime_(false)
     , last_log_secs_(0)
     , custom_handlers_(std::move(custom_user_flags))
 {
     std::memset(&cached_tm_, 0, sizeof(cached_tm_));
     compile_pattern_(pattern_);
 }
 
 // use by default full formatter for if pattern is not given
 SPDLOG_INLINE pattern_formatter::pattern_formatter(pattern_time_type time_type, std::string eol)
     : pattern_("%+")
     , eol_(std::move(eol))
     , pattern_time_type_(time_type)
     , need_localtime_(true)
     , last_log_secs_(0)
 {
     std::memset(&cached_tm_, 0, sizeof(cached_tm_));
     formatters_.push_back(details::make_unique<details::full_formatter>(details::padding_info{}));
 }
 
 SPDLOG_INLINE std::unique_ptr<formatter> pattern_formatter::clone() const
 {
     custom_flags cloned_custom_formatters;
     for (auto &it : custom_handlers_)
     {
         cloned_custom_formatters[it.first] = it.second->clone();
     }
     auto cloned = details::make_unique<pattern_formatter>(pattern_, pattern_time_type_, eol_, std::move(cloned_custom_formatters));
     cloned->need_localtime(need_localtime_);
 #if defined(__GNUC__) && __GNUC__ < 5
     return std::move(cloned);
 #else
     return cloned;
 #endif
 }
 
 SPDLOG_INLINE void pattern_formatter::format(const details::log_msg &msg, memory_buf_t &dest)
 {
     if (need_localtime_)
     {
         const auto secs = std::chrono::duration_cast<std::chrono::seconds>(msg.time.time_since_epoch());
         if (secs != last_log_secs_)
         {
             cached_tm_ = get_time_(msg);
             last_log_secs_ = secs;
         }
     }
 
     for (auto &f : formatters_)
     {
         f->format(msg, cached_tm_, dest);
     }
     // write eol
     details::fmt_helper::append_string_view(eol_, dest);
 }
 
 SPDLOG_INLINE void pattern_formatter::set_pattern(std::string pattern)
 {
     pattern_ = std::move(pattern);
     need_localtime_ = false;
     compile_pattern_(pattern_);
 }
 
 SPDLOG_INLINE void pattern_formatter::need_localtime(bool need)
 {
     need_localtime_ = need;
 }
 
 SPDLOG_INLINE std::tm pattern_formatter::get_time_(const details::log_msg &msg)
 {
     if (pattern_time_type_ == pattern_time_type::local)
     {
         return details::os::localtime(log_clock::to_time_t(msg.time));
     }
     return details::os::gmtime(log_clock::to_time_t(msg.time));
 }
 
 template<typename Padder>
 SPDLOG_INLINE void pattern_formatter::handle_flag_(char flag, details::padding_info padding)
 {
     // process custom flags
     auto it = custom_handlers_.find(flag);
     if (it != custom_handlers_.end())
     {
         auto custom_handler = it->second->clone();
         custom_handler->set_padding_info(padding);
         formatters_.push_back(std::move(custom_handler));
         return;
     }
 
     // process built-in flags
     switch (flag)
     {
     case ('+'): // default formatter
         formatters_.push_back(details::make_unique<details::full_formatter>(padding));
         need_localtime_ = true;
         break;
 
     case 'n': // logger name
         formatters_.push_back(details::make_unique<details::name_formatter<Padder>>(padding));
         break;
 
     case 'l': // level
         formatters_.push_back(details::make_unique<details::level_formatter<Padder>>(padding));
         break;
 
     case 'L': // short level
         formatters_.push_back(details::make_unique<details::short_level_formatter<Padder>>(padding));
         break;
 
     case ('t'): // thread id
         formatters_.push_back(details::make_unique<details::t_formatter<Padder>>(padding));
         break;
 
     case ('v'): // the message text
         formatters_.push_back(details::make_unique<details::v_formatter<Padder>>(padding));
         break;
 
     case ('a'): // weekday
         formatters_.push_back(details::make_unique<details::a_formatter<Padder>>(padding));
         need_localtime_ = true;
         break;
 
     case ('A'): // short weekday
         formatters_.push_back(details::make_unique<details::A_formatter<Padder>>(padding));
         need_localtime_ = true;
         break;
 
     case ('b'):
     case ('h'): // month
         formatters_.push_back(details::make_unique<details::b_formatter<Padder>>(padding));
         need_localtime_ = true;
         break;
 
     case ('B'): // short month
         formatters_.push_back(details::make_unique<details::B_formatter<Padder>>(padding));
         need_localtime_ = true;
         break;
 
     case ('c'): // datetime
         formatters_.push_back(details::make_unique<details::c_formatter<Padder>>(padding));
         need_localtime_ = true;
         break;
 
     case ('C'): // year 2 digits
         formatters_.push_back(details::make_unique<details::C_formatter<Padder>>(padding));
         need_localtime_ = true;
         break;
 
     case ('Y'): // year 4 digits
         formatters_.push_back(details::make_unique<details::Y_formatter<Padder>>(padding));
         need_localtime_ = true;
         break;
 
     case ('D'):
     case ('x'): // datetime MM/DD/YY
         formatters_.push_back(details::make_unique<details::D_formatter<Padder>>(padding));
         need_localtime_ = true;
         break;
 
     case ('m'): // month 1-12
         formatters_.push_back(details::make_unique<details::m_formatter<Padder>>(padding));
         need_localtime_ = true;
         break;
 
     case ('d'): // day of month 1-31
         formatters_.push_back(details::make_unique<details::d_formatter<Padder>>(padding));
         need_localtime_ = true;
         break;
 
     case ('H'): // hours 24
         formatters_.push_back(details::make_unique<details::H_formatter<Padder>>(padding));
         need_localtime_ = true;
         break;
 
     case ('I'): // hours 12
         formatters_.push_back(details::make_unique<details::I_formatter<Padder>>(padding));
         need_localtime_ = true;
         break;
 
     case ('M'): // minutes
         formatters_.push_back(details::make_unique<details::M_formatter<Padder>>(padding));
         need_localtime_ = true;
         break;
 
     case ('S'): // seconds
         formatters_.push_back(details::make_unique<details::S_formatter<Padder>>(padding));
         need_localtime_ = true;
         break;
 
     case ('e'): // milliseconds
         formatters_.push_back(details::make_unique<details::e_formatter<Padder>>(padding));
         break;
 
     case ('f'): // microseconds
         formatters_.push_back(details::make_unique<details::f_formatter<Padder>>(padding));
         break;
 
     case ('F'): // nanoseconds
         formatters_.push_back(details::make_unique<details::F_formatter<Padder>>(padding));
         break;
 
     case ('E'): // seconds since epoch
         formatters_.push_back(details::make_unique<details::E_formatter<Padder>>(padding));
         break;
 
     case ('p'): // am/pm
         formatters_.push_back(details::make_unique<details::p_formatter<Padder>>(padding));
         need_localtime_ = true;
         break;
 
     case ('r'): // 12 hour clock 02:55:02 pm
         formatters_.push_back(details::make_unique<details::r_formatter<Padder>>(padding));
         need_localtime_ = true;
         break;
 
     case ('R'): // 24-hour HH:MM time
         formatters_.push_back(details::make_unique<details::R_formatter<Padder>>(padding));
         need_localtime_ = true;
         break;
 
     case ('T'):
     case ('X'): // ISO 8601 time format (HH:MM:SS)
         formatters_.push_back(details::make_unique<details::T_formatter<Padder>>(padding));
         need_localtime_ = true;
         break;
 
     case ('z'): // timezone
         formatters_.push_back(details::make_unique<details::z_formatter<Padder>>(padding));
         need_localtime_ = true;
         break;
 
     case ('P'): // pid
         formatters_.push_back(details::make_unique<details::pid_formatter<Padder>>(padding));
         break;
 
     case ('^'): // color range start
         formatters_.push_back(details::make_unique<details::color_start_formatter>(padding));
         break;
 
     case ('$'): // color range end
         formatters_.push_back(details::make_unique<details::color_stop_formatter>(padding));
         break;
 
     case ('@'): // source location (filename:filenumber)
         formatters_.push_back(details::make_unique<details::source_location_formatter<Padder>>(padding));
         break;
 
     case ('s'): // short source filename - without directory name
         formatters_.push_back(details::make_unique<details::short_filename_formatter<Padder>>(padding));
         break;
 
     case ('g'): // full source filename
         formatters_.push_back(details::make_unique<details::source_filename_formatter<Padder>>(padding));
         break;
 
     case ('#'): // source line number
         formatters_.push_back(details::make_unique<details::source_linenum_formatter<Padder>>(padding));
         break;
 
     case ('!'): // source funcname
         formatters_.push_back(details::make_unique<details::source_funcname_formatter<Padder>>(padding));
         break;
 
     case ('%'): // % char
         formatters_.push_back(details::make_unique<details::ch_formatter>('%'));
         break;
 
     case ('u'): // elapsed time since last log message in nanos
         formatters_.push_back(details::make_unique<details::elapsed_formatter<Padder, std::chrono::nanoseconds>>(padding));
         break;
 
     case ('i'): // elapsed time since last log message in micros
         formatters_.push_back(details::make_unique<details::elapsed_formatter<Padder, std::chrono::microseconds>>(padding));
         break;
 
     case ('o'): // elapsed time since last log message in millis
         formatters_.push_back(details::make_unique<details::elapsed_formatter<Padder, std::chrono::milliseconds>>(padding));
         break;
 
     case ('O'): // elapsed time since last log message in seconds
         formatters_.push_back(details::make_unique<details::elapsed_formatter<Padder, std::chrono::seconds>>(padding));
         break;
 
     default: // Unknown flag appears as is
         auto unknown_flag = details::make_unique<details::aggregate_formatter>();
 
         if (!padding.truncate_)
         {
             unknown_flag->add_ch('%');
             unknown_flag->add_ch(flag);
             formatters_.push_back((std::move(unknown_flag)));
         }
         // fix issue #1617 (prev char was '!' and should have been treated as funcname flag instead of truncating flag)
         // spdlog::set_pattern("[%10!] %v") => "[      main] some message"
         // spdlog::set_pattern("[%3!!] %v") => "[mai] some message"
         else
         {
             padding.truncate_ = false;
             formatters_.push_back(details::make_unique<details::source_funcname_formatter<Padder>>(padding));
             unknown_flag->add_ch(flag);
             formatters_.push_back((std::move(unknown_flag)));
         }
 
         break;
     }
 }
 
 // Extract given pad spec (e.g. %8X, %=8X, %-8!X, %8!X, %=8!X, %-8!X, %+8!X)
 // Advance the given it pass the end of the padding spec found (if any)
 // Return padding.
 SPDLOG_INLINE details::padding_info pattern_formatter::handle_padspec_(std::string::const_iterator &it, std::string::const_iterator end)
 {
     using details::padding_info;
     using details::scoped_padder;
     const size_t max_width = 64;
     if (it == end)
     {
         return padding_info{};
     }
 
     padding_info::pad_side side;
     switch (*it)
     {
     case '-':
         side = padding_info::pad_side::right;
         ++it;
         break;
     case '=':
         side = padding_info::pad_side::center;
         ++it;
         break;
     default:
         side = details::padding_info::pad_side::left;
         break;
     }
 
     if (it == end || !std::isdigit(static_cast<unsigned char>(*it)))
     {
         return padding_info{}; // no padding if no digit found here
     }
 
     auto width = static_cast<size_t>(*it) - '0';
     for (++it; it != end && std::isdigit(static_cast<unsigned char>(*it)); ++it)
     {
         auto digit = static_cast<size_t>(*it) - '0';
         width = width * 10 + digit;
     }
 
     // search for the optional truncate marker '!'
     bool truncate;
     if (it != end && *it == '!')
     {
         truncate = true;
         ++it;
     }
     else
     {
         truncate = false;
     }
     return details::padding_info{std::min<size_t>(width, max_width), side, truncate};
 }
 
 SPDLOG_INLINE void pattern_formatter::compile_pattern_(const std::string &pattern)
 {
     auto end = pattern.end();
     std::unique_ptr<details::aggregate_formatter> user_chars;
     formatters_.clear();
     for (auto it = pattern.begin(); it != end; ++it)
     {
         if (*it == '%')
         {
             if (user_chars) // append user chars found so far
             {
                 formatters_.push_back(std::move(user_chars));
             }
 
             auto padding = handle_padspec_(++it, end);
 
             if (it != end)
             {
                 if (padding.enabled())
                 {
                     handle_flag_<details::scoped_padder>(*it, padding);
                 }
                 else
                 {
                     handle_flag_<details::null_scoped_padder>(*it, padding);
                 }
             }
             else
             {
                 break;
             }
         }
         else // chars not following the % sign should be displayed as is
         {
             if (!user_chars)
             {
                 user_chars = details::make_unique<details::aggregate_formatter>();
             }
             user_chars->add_ch(*it);
         }
     }
     if (user_chars) // append raw chars found so far
     {
         formatters_.push_back(std::move(user_chars));
     }
 }
 } // namespace spdlog

This page was automatically generated by the 2.3.7 LXR engine. The LXR team