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

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

 //
 // Copyright(c) 2015 Gabi Melman.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
 //
 
 #pragma once
 
 #include <cctype>
 #include <spdlog/common.h>
 
 #if defined(__has_include)
 #    if __has_include(<version>)
 #        include <version>
 #    endif
 #endif
 
 #if __cpp_lib_span >= 202002L
 #    include <span>
 #endif
 
 //
 // Support for logging binary data as hex
 // format flags, any combination of the following:
 // {:X} - print in uppercase.
 // {:s} - don't separate each byte with space.
 // {:p} - don't print the position on each line start.
 // {:n} - don't split the output to lines.
 // {:a} - show ASCII if :n is not set
 
 //
 // Examples:
 //
 // std::vector<char> v(200, 0x0b);
 // logger->info("Some buffer {}", spdlog::to_hex(v));
 // char buf[128];
 // logger->info("Some buffer {:X}", spdlog::to_hex(std::begin(buf), std::end(buf)));
 // logger->info("Some buffer {:X}", spdlog::to_hex(std::begin(buf), std::end(buf), 16));
 
 namespace spdlog {
 namespace details {
 
 template<typename It>
 class dump_info
 {
 public:
     dump_info(It range_begin, It range_end, size_t size_per_line)
         : begin_(range_begin)
         , end_(range_end)
         , size_per_line_(size_per_line)
     {}
 
     // do not use begin() and end() to avoid collision with fmt/ranges
     It get_begin() const
     {
         return begin_;
     }
     It get_end() const
     {
         return end_;
     }
     size_t size_per_line() const
     {
         return size_per_line_;
     }
 
 private:
     It begin_, end_;
     size_t size_per_line_;
 };
 } // namespace details
 
 // create a dump_info that wraps the given container
 template<typename Container>
 inline details::dump_info<typename Container::const_iterator> to_hex(const Container &container, size_t size_per_line = 32)
 {
     static_assert(sizeof(typename Container::value_type) == 1, "sizeof(Container::value_type) != 1");
     using Iter = typename Container::const_iterator;
     return details::dump_info<Iter>(std::begin(container), std::end(container), size_per_line);
 }
 
 #if __cpp_lib_span >= 202002L
 
 template<typename Value, size_t Extent>
 inline details::dump_info<typename std::span<Value, Extent>::iterator> to_hex(
     const std::span<Value, Extent> &container, size_t size_per_line = 32)
 {
     using Container = std::span<Value, Extent>;
     static_assert(sizeof(typename Container::value_type) == 1, "sizeof(Container::value_type) != 1");
     using Iter = typename Container::iterator;
     return details::dump_info<Iter>(std::begin(container), std::end(container), size_per_line);
 }
 
 #endif
 
 // create dump_info from ranges
 template<typename It>
 inline details::dump_info<It> to_hex(const It range_begin, const It range_end, size_t size_per_line = 32)
 {
     return details::dump_info<It>(range_begin, range_end, size_per_line);
 }
 
 } // namespace spdlog
 
 namespace
 #ifdef SPDLOG_USE_STD_FORMAT
     std
 #else
     fmt
 #endif
 {
 
 template<typename T>
 struct formatter<spdlog::details::dump_info<T>, char>
 {
     const char delimiter = ' ';
     bool put_newlines = true;
     bool put_delimiters = true;
     bool use_uppercase = false;
     bool put_positions = true; // position on start of each line
     bool show_ascii = false;
 
     // parse the format string flags
     template<typename ParseContext>
     SPDLOG_CONSTEXPR_FUNC auto parse(ParseContext &ctx) -> decltype(ctx.begin())
     {
         auto it = ctx.begin();
         while (it != ctx.end() && *it != '}')
         {
             switch (*it)
             {
             case 'X':
                 use_uppercase = true;
                 break;
             case 's':
                 put_delimiters = false;
                 break;
             case 'p':
                 put_positions = false;
                 break;
             case 'n':
                 put_newlines = false;
                 show_ascii = false;
                 break;
             case 'a':
                 if (put_newlines)
                 {
                     show_ascii = true;
                 }
                 break;
             }
 
             ++it;
         }
         return it;
     }
 
     // format the given bytes range as hex
     template<typename FormatContext, typename Container>
     auto format(const spdlog::details::dump_info<Container> &the_range, FormatContext &ctx) -> decltype(ctx.out())
     {
         SPDLOG_CONSTEXPR const char *hex_upper = "0123456789ABCDEF";
         SPDLOG_CONSTEXPR const char *hex_lower = "0123456789abcdef";
         const char *hex_chars = use_uppercase ? hex_upper : hex_lower;
 
 #if !defined(SPDLOG_USE_STD_FORMAT) && FMT_VERSION < 60000
         auto inserter = ctx.begin();
 #else
         auto inserter = ctx.out();
 #endif
 
         int size_per_line = static_cast<int>(the_range.size_per_line());
         auto start_of_line = the_range.get_begin();
         for (auto i = the_range.get_begin(); i != the_range.get_end(); i++)
         {
             auto ch = static_cast<unsigned char>(*i);
 
             if (put_newlines && (i == the_range.get_begin() || i - start_of_line >= size_per_line))
             {
                 if (show_ascii && i != the_range.get_begin())
                 {
                     *inserter++ = delimiter;
                     *inserter++ = delimiter;
                     for (auto j = start_of_line; j < i; j++)
                     {
                         auto pc = static_cast<unsigned char>(*j);
                         *inserter++ = std::isprint(pc) ? static_cast<char>(*j) : '.';
                     }
                 }
 
                 put_newline(inserter, static_cast<size_t>(i - the_range.get_begin()));
 
                 // put first byte without delimiter in front of it
                 *inserter++ = hex_chars[(ch >> 4) & 0x0f];
                 *inserter++ = hex_chars[ch & 0x0f];
                 start_of_line = i;
                 continue;
             }
 
             if (put_delimiters)
             {
                 *inserter++ = delimiter;
             }
 
             *inserter++ = hex_chars[(ch >> 4) & 0x0f];
             *inserter++ = hex_chars[ch & 0x0f];
         }
         if (show_ascii) // add ascii to last line
         {
             if (the_range.get_end() - the_range.get_begin() > size_per_line)
             {
                 auto blank_num = size_per_line - (the_range.get_end() - start_of_line);
                 while (blank_num-- > 0)
                 {
                     *inserter++ = delimiter;
                     *inserter++ = delimiter;
                     if (put_delimiters)
                     {
                         *inserter++ = delimiter;
                     }
                 }
             }
             *inserter++ = delimiter;
             *inserter++ = delimiter;
             for (auto j = start_of_line; j != the_range.get_end(); j++)
             {
                 auto pc = static_cast<unsigned char>(*j);
                 *inserter++ = std::isprint(pc) ? static_cast<char>(*j) : '.';
             }
         }
         return inserter;
     }
 
     // put newline(and position header)
     template<typename It>
     void put_newline(It inserter, std::size_t pos)
     {
 #ifdef _WIN32
         *inserter++ = '\r';
 #endif
         *inserter++ = '\n';
 
         if (put_positions)
         {
             spdlog::fmt_lib::format_to(inserter, SPDLOG_FMT_STRING("{:04X}: "), pos);
         }
     }
 };
 } // namespace std

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