diff options
Diffstat (limited to 'deps/include/spdlog/fmt/bin_to_hex.h')
| -rw-r--r-- | deps/include/spdlog/fmt/bin_to_hex.h | 224 |
1 files changed, 224 insertions, 0 deletions
diff --git a/deps/include/spdlog/fmt/bin_to_hex.h b/deps/include/spdlog/fmt/bin_to_hex.h new file mode 100644 index 0000000..e6b9712 --- /dev/null +++ b/deps/include/spdlog/fmt/bin_to_hex.h @@ -0,0 +1,224 @@ +//
+// 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) const
+ -> 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 && i != the_range.get_begin()) {
+ *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) const {
+#ifdef _WIN32
+ *inserter++ = '\r';
+#endif
+ *inserter++ = '\n';
+
+ if (put_positions) {
+ spdlog::fmt_lib::format_to(inserter, SPDLOG_FMT_STRING("{:04X}: "), pos);
+ }
+ }
+};
+} // namespace std
|