print.hpp

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <array>
#include <cstdint>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
 
#include "cpp-toolbox/base/env.hpp"
#include "cpp-toolbox/cpp-toolbox_export.hpp"
#include "cpp-toolbox/macro.hpp"
#include "cpp-toolbox/type_traits.hpp"
#ifdef CPP_TOOLBOX_PLATFORM_WINDOWS
#  define NOMINMAX
#  define WIN32_LEAN_AND_MEAN
#  include <windows.h>
#endif
 
namespace toolbox::utils
{
enum class CPP_TOOLBOX_EXPORT align_t : std::uint8_t
{
  LEFT,  
  RIGHT,  
  CENTER  
};
 
enum class CPP_TOOLBOX_EXPORT color_t : std::uint8_t
{
  DEFAULT,  
  BLACK,  
  RED,  
  GREEN,  
  YELLOW,  
  BLUE,  
  MAGENTA,  
  CYAN,  
  WHITE  
};
 
struct CPP_TOOLBOX_EXPORT print_style_t
{
  struct box_chars_t
  {
    std::string top_left = "+";
    std::string top_right = "+";
    std::string bottom_left = "+";
    std::string bottom_right = "+";
    std::string left_joint = "+";
    std::string right_joint = "+";
    std::string top_joint = "+";
    std::string bottom_joint = "+";
    std::string center = "+";
  } box;
 
  std::string border_h = "-";  
  std::string border_v = "|";  
  std::string padding = " ";  
  bool show_header = true;  
  bool show_border = true;  
  size_t min_width = 0;  
  align_t alignment = align_t::LEFT;  
  color_t header_fg = color_t::DEFAULT;  
  color_t header_bg = color_t::DEFAULT;  
  color_t data_fg = color_t::DEFAULT;  
  color_t data_bg = color_t::DEFAULT;  
  color_t border_color = color_t::DEFAULT;  
  bool use_colors = true;  
};
 
inline auto get_default_style() -> const print_style_t&
{
  static const print_style_t style = print_style_t();
  return style;
}
 
inline auto get_ascii_style() -> const print_style_t&
{
  static const print_style_t style = [] {
    print_style_t s;
    s.border_h = "-";
    s.border_v = "|";
    s.box.top_left = "+";
    s.box.top_right = "+";
    s.box.bottom_left = "+";
    s.box.bottom_right = "+";
    s.box.left_joint = "+";
    s.box.right_joint = "+";
    s.box.top_joint = "+";
    s.box.bottom_joint = "+";
    s.box.center = "+";
    return s;
  }();
  return style;
}
 
inline auto get_rounded_style() -> const print_style_t&
{
  static const print_style_t style = [] {
    print_style_t s;
#ifdef CPP_TOOLBOX_PLATFORM_WINDOWS
    // 在 Windows 上使用 ASCII 字符
    s.border_h = "-";
    s.border_v = "|";
    s.box.top_left = "+";
    s.box.top_right = "+";
    s.box.bottom_left = "+";
    s.box.bottom_right = "+";
    s.box.left_joint = "+";
    s.box.right_joint = "+";
    s.box.top_joint = "+";
    s.box.bottom_joint = "+";
    s.box.center = "+";
#else
    // 在其他平台上使用 Unicode 字符
    s.border_h = "\xE2\x94\x80";      // "─"
    s.border_v = "\xE2\x94\x82";      // "│"
    s.box.top_left = "\xE2\x94\x8C";      // "┌"
    s.box.top_right = "\xE2\x94\x90";     // "┐"
    s.box.bottom_left = "\xE2\x94\x94";   // "└"
    s.box.bottom_right = "\xE2\x94\x98";  // "┘"
    s.box.left_joint = "\xE2\x94\x9C";    // "├"
    s.box.right_joint = "\xE2\x94\xA4";   // "┤"
    s.box.top_joint = "\xE2\x94\xAC";     // "┬"
    s.box.bottom_joint = "\xE2\x94\xB4";  // "┴"
    s.box.center = "\xE2\x94\xBC";       // "┼"
#endif
    return s;
  }();
  return style;
}
 
class CPP_TOOLBOX_EXPORT color_handler_t
{
  inline static bool is_windows =
      false;  
  inline static bool has_color_support =
      false;  
 
  static void initialize()
  {
    static bool initialized = false;
    if (!initialized) {
#ifdef _WIN32
      is_windows = true;
      // 在Windows上检查并启用ANSI支持/Check and enable ANSI support on Windows
      HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
      DWORD dwMode = 0;
      has_color_support = GetConsoleMode(hOut, &dwMode)
          && SetConsoleMode(hOut, dwMode | ENABLE_VIRTUAL_TERMINAL_PROCESSING);
#else
      is_windows = false;
      // 使用 toolbox::base::get_environment_variable 替换 std::getenv/Use
      // toolbox::base::get_environment_variable instead of std::getenv
      const std::string term_str =
          toolbox::base::get_environment_variable("TERM");
      has_color_support =
          !term_str.empty()  // 显式检查非空/Explicitly check non-empty
          && (term_str == "xterm" || term_str == "xterm-color"
              || term_str == "xterm-256color" || term_str == "screen"
              || term_str == "screen-256color" || term_str == "tmux"
              || term_str == "tmux-256color" || term_str == "rxvt"
              || term_str == "rxvt-unicode" || term_str == "linux"
              || term_str == "cygwin");
#endif
      initialized = true;
    }
  }
 
public:
  static auto get_fg_code(color_t color) -> std::string
  {
    initialize();
    if (!has_color_support || color == color_t::DEFAULT) {
      return "";
    }
 
    switch (color) {
      case color_t::BLACK:
        return "\033[30m";
      case color_t::RED:
        return "\033[31m";
      case color_t::GREEN:
        return "\033[32m";
      case color_t::YELLOW:
        return "\033[33m";
      case color_t::BLUE:
        return "\033[34m";
      case color_t::MAGENTA:
        return "\033[35m";
      case color_t::CYAN:
        return "\033[36m";
      case color_t::WHITE:
        return "\033[37m";
      default:
        return "";
    }
  }
 
  static auto get_bg_code(color_t color) -> std::string
  {
    initialize();
    if (!has_color_support || color == color_t::DEFAULT) {
      return "";
    }
 
    switch (color) {
      case color_t::BLACK:
        return "\033[40m";
      case color_t::RED:
        return "\033[41m";
      case color_t::GREEN:
        return "\033[42m";
      case color_t::YELLOW:
        return "\033[43m";
      case color_t::BLUE:
        return "\033[44m";
      case color_t::MAGENTA:
        return "\033[45m";
      case color_t::CYAN:
        return "\033[46m";
      case color_t::WHITE:
        return "\033[47m";
      default:
        return "";
    }
  }
 
  static auto reset() -> std::string
  {
    initialize();
    return has_color_support ? "\033[0m" : "";
  }
 
  static auto colorize(const std::string& text, color_t fg, color_t bg)
      -> std::string
  {
    initialize();
    if (!has_color_support
        || (fg == color_t::DEFAULT && bg == color_t::DEFAULT))
    {
      return text;
    }
 
    std::string result;
    result.reserve(text.size()
                   + 20);  // 预留ANSI代码空间/Reserve space for ANSI codes
 
    result += get_fg_code(fg);
    result += get_bg_code(bg);
    result += text;
    result += reset();
 
    return result;
  }
 
  static auto supports_color() -> bool
  {
    initialize();
    return has_color_support;
  }
};
 
template<typename T>
auto to_string_value(const T& value) -> std::string
{
  // 专门处理 std::string 本身
  if constexpr (std::is_same_v<T, std::string>) {
    return value;
  }
  // 如果是可迭代容器（且不是 string），就把它当作列表打印
  else if constexpr (toolbox::traits::is_iterable_v<T>)
  {
    std::ostringstream oss;
    oss << "[";
    bool first = true;
    for (auto const& elem : value) {
      if (!first) {
        oss << ", ";
      }
      oss << to_string_value(elem);  // 递归；如果 elem 也是容器会继续走这里
      first = false;
    }
    oss << "]";
    return oss.str();
  }
  // 否则尝试用 operator<< 打印
  else {
    std::ostringstream oss;
    oss << value;  // 只有当 stream << T 可用才会编译
    return oss.str();
  }
}
 
inline auto align_text(const std::string& text,
                       size_t width,
                       align_t align,
                       [[maybe_unused]] const std::string& padding = " ")
    -> std::string
{
  if (text.length() >= width) {
    return text;
  }
 
  const size_t padding_length = width - text.length();
 
  switch (align) {
    case align_t::RIGHT: {
      return std::string(padding_length, ' ') + text;
    }
    case align_t::CENTER: {
      const size_t left_padding = padding_length / 2;
      const size_t right_padding = padding_length - left_padding;
      return std::string(left_padding, ' ') + text
          + std::string(right_padding, ' ');
    }
    case align_t::LEFT:
    default: {
      return text + std::string(padding_length, ' ');
    }
  }
}
 
class CPP_TOOLBOX_EXPORT table_t;
 
CPP_TOOLBOX_EXPORT std::ostream& operator<<(std::ostream& os,
                                            const table_t& tbl);
 
class CPP_TOOLBOX_EXPORT table_t
{
public:
  explicit table_t(const print_style_t& style = get_default_style());
 
  table_t& set_headers(const std::vector<std::string>& hdrs);
 
  table_t& add_row(const std::vector<std::string>& row);
 
  template<typename... Args,
           // SFINAE: Disable this template if called with a single
           // std::vector<std::string> to ensure the non-template overload
           // add_row(const std::vector<std::string>&) is chosen instead.
           std::enable_if_t<
               !(sizeof...(Args) == 1
                 && std::is_same_v<
                     std::decay_t<std::tuple_element_t<0, std::tuple<Args...>>>,
                     std::vector<std::string>>),
               int> = 0>
  auto add_row(Args&&... args) -> table_t&
  {
    // No need for static_assert check anymore due to SFINAE constraint above.
 
    std::vector<std::string> row_data;
    row_data.reserve(sizeof...(args));
    // Convert all arguments to string and collect them
    (row_data.push_back(to_string_value(std::forward<Args>(args))), ...);
 
    // Call the non-template add_row(const std::vector<std::string>&) overload.
    // Passing 'row_data' as an lvalue ensures the correct overload is selected.
    return this->add_row(row_data);
  }
 
  table_t& set_title(const std::string& title);
 
  table_t& set_footer(const std::string& footer);
 
  table_t& set_column_align(size_t column_index, align_t align);
 
  table_t& set_all_columns_align(align_t align);
 
  table_t& set_column_width(size_t col, size_t width);
 
  table_t& set_column_min_max(size_t col, size_t min_width, size_t max_width);
 
  table_t& set_row_height(size_t row, size_t height);
 
  table_t& enable_wrap(bool enable);
 
  table_t& set_wrap_ellipsis(const std::string& ellipsis);
 
  table_t& span_cells(size_t start_row,
                      size_t start_col,
                      size_t row_span,
                      size_t col_span);
 
  table_t& enable_zebra(bool enable);
 
  table_t& set_zebra_colors(color_t odd_bg, color_t even_bg);
 
  table_t& set_highlight_callback(
      std::function<print_style_t(size_t, size_t, const std::string&)> cb);
 
  table_t& set_output_color(bool enable);
 
  table_t& set_file_output_color(bool enable);
 
  [[nodiscard]] auto to_string(bool with_color = true) const -> std::string;
 
  friend CPP_TOOLBOX_EXPORT std::ostream& operator<<(std::ostream& os,
                                                     const table_t& tbl);
 
private:
  std::vector<std::string> m_headers;
 
  std::vector<std::vector<std::string>> m_data;
 
  print_style_t m_style;
 
  std::string m_title;
 
  std::string m_footer;
 
  std::unordered_map<size_t, size_t> m_col_fixed_width;
 
  std::unordered_map<size_t, std::pair<size_t, size_t>> m_col_min_max;
 
  std::unordered_map<size_t, size_t> m_row_fixed_height;
 
  std::vector<align_t> m_col_aligns;
 
  bool m_wrap_enabled;
 
  std::string m_wrap_ellipsis;
 
  struct Span
  {
    size_t row, col, row_span, col_span;
  };
  std::vector<Span> m_spans;
 
  bool m_zebra_enabled;
 
  color_t m_zebra_odd_bg;
  color_t m_zebra_even_bg;
 
  std::function<print_style_t(size_t, size_t, const std::string&)>
      m_highlight_cb;
 
  bool m_out_color;
 
  bool m_file_color;
 
  void calculate_col_widths() const;
 
  enum class border_pos_t
  {
    TOP,
    MIDDLE,
    BOTTOM
  };
 
  void print_horizontal_border(std::ostream& os, border_pos_t pos) const;
 
  void print_wrapped_row(std::ostream& os,
                         const std::vector<std::string>& row_data,
                         bool is_header,
                         size_t row_index) const;
 
  bool is_spanned_cell(size_t row, size_t col) const;
 
  mutable std::vector<size_t> m_col_widths;
};
 
template<typename Container>
class CPP_TOOLBOX_EXPORT container_printer_t
{
private:
  const Container& m_container;  
  std::string m_name;  
  print_style_t m_style;  
  bool m_partial{false};           
  size_t m_head_count{3};          
  size_t m_tail_count{3};          
  std::string m_partial_ellipsis{"..."};  
 
protected:
  auto get_container() const -> const Container& { return m_container; }
  [[nodiscard]] auto get_name() const -> const std::string& { return m_name; }
  [[nodiscard]] auto get_style() const -> const print_style_t&
  {
    return m_style;
  }
 
  [[nodiscard]] virtual auto get_size() const -> size_t = 0;
 
  virtual void print_content(std::ostream& os) const = 0;
 
public:
  container_printer_t(const Container& c, std::string name, print_style_t style)
      : m_container(c)
      , m_name(std::move(name))
      , m_style(std::move(style))
  {
  }
 
  container_printer_t& enable_partial(bool enable)
  {
    m_partial = enable;
    return *this;
  }
 
  container_printer_t& set_head_tail_count(size_t head, size_t tail)
  {
    m_head_count = head;
    m_tail_count = tail;
    return *this;
  }
 
  container_printer_t& set_partial_ellipsis(const std::string& ellipsis)
  {
    m_partial_ellipsis = ellipsis;
    return *this;
  }
 
protected:
  [[nodiscard]] auto partial_enabled() const -> bool { return m_partial; }
  [[nodiscard]] auto head_count() const -> size_t { return m_head_count; }
  [[nodiscard]] auto tail_count() const -> size_t { return m_tail_count; }
  [[nodiscard]] auto ellipsis() const -> const std::string&
  {
    return m_partial_ellipsis;
  }
 
  virtual ~container_printer_t() = default;
 
  container_printer_t(const container_printer_t&) = delete;
  container_printer_t& operator=(const container_printer_t&) = delete;
  container_printer_t(container_printer_t&&) = delete;
  container_printer_t& operator=(container_printer_t&&) = delete;
 
  // 声明外部模板函数为友元 (注意 <>) / Declare external template function as
  // friend (note < >)
  template<typename C>  // C 代表容器类型 / C represents the container type
  friend auto operator<<(std::ostream& os,
                         const container_printer_t<C>& printer)
      -> std::ostream&;
};
 
// 在类外部定义 operator<< 模板函数 / Define the operator<< template function
// outside the class
template<typename Container>
auto operator<<(std::ostream& os, const container_printer_t<Container>& printer)
    -> std::ostream&
{
  std::string name_colored = printer.get_style().use_colors
      ? color_handler_t::colorize(printer.get_name(),
                                  printer.get_style().header_fg,
                                  printer.get_style().header_bg)
      : printer.get_name();
 
  os << name_colored << " [" << printer.get_size() << "] = {"
     << "\n";
  printer.print_content(os);  // 调用虚函数 / Call virtual function
  os << "}"
     << "\n";
  return os;
}
 
template<typename T>
class CPP_TOOLBOX_EXPORT vector_printer_t
    : public container_printer_t<std::vector<T>>
{
protected:
  [[nodiscard]] auto get_size() const -> size_t override
  {
    return this->get_container().size();
  }
 
  void print_content(std::ostream& os) const override
  {
    size_t total = this->get_container().size();
    bool partial = this->partial_enabled() &&
                   total > (this->head_count() + this->tail_count());
    size_t head = partial ? this->head_count() : total;
    size_t tail_start = partial ? total - this->tail_count() : total;
 
    for (size_t i = 0; i < head; ++i) {
      const std::string index = "[" + std::to_string(i) + "]: ";
      const std::string value = to_string_value(this->get_container()[i]);
 
      const std::string colored_index = this->get_style().use_colors
          ? color_handler_t::colorize(
                index, this->get_style().header_fg, color_t::DEFAULT)
          : index;
      const std::string colored_value = this->get_style().use_colors
          ? color_handler_t::colorize(
                value, this->get_style().data_fg, color_t::DEFAULT)
          : value;
 
      os << "  " << colored_index << colored_value;
      if (partial || i < total - 1) {
        os << ",";
      }
      os << "\n";
    }
 
    if (partial) {
      os << "  " << this->ellipsis();
      if (tail_start < total) {
        os << ",";
      }
      os << "\n";
    }
 
    for (size_t i = std::max(head, tail_start); i < total; ++i) {
      const std::string index = "[" + std::to_string(i) + "]: ";
      const std::string value = to_string_value(this->get_container()[i]);
 
      const std::string colored_index = this->get_style().use_colors
          ? color_handler_t::colorize(
                index, this->get_style().header_fg, color_t::DEFAULT)
          : index;
      const std::string colored_value = this->get_style().use_colors
          ? color_handler_t::colorize(
                value, this->get_style().data_fg, color_t::DEFAULT)
          : value;
 
      os << "  " << colored_index << colored_value;
      if (i < total - 1) {
        os << ",";
      }
      os << "\n";
    }
  }
 
public:
  using container_printer_t<std::vector<T>>::container_printer_t;
};
 
template<typename K, typename V>
class CPP_TOOLBOX_EXPORT map_printer_t
    : public container_printer_t<std::map<K, V>>
{
protected:
  [[nodiscard]] auto get_size() const -> size_t override
  {
    return this->get_container().size();
  }
 
  void print_content(std::ostream& os) const override
  {
    size_t total = this->get_container().size();
    bool partial = this->partial_enabled() &&
                   total > (this->head_count() + this->tail_count());
    size_t head = partial ? this->head_count() : total;
    size_t tail_start = partial ? total - this->tail_count() : total;
 
    size_t idx = 0;
    for (auto it = this->get_container().begin();
         it != this->get_container().end() && idx < head; ++it, ++idx)
    {
      const auto& [key, value] = *it;
      const std::string key_str = to_string_value(key);
      const std::string value_str = to_string_value(value);
      const std::string arrow = " => ";
 
      const std::string colored_key = this->get_style().use_colors
          ? color_handler_t::colorize(
                key_str, this->get_style().header_fg, color_t::DEFAULT)
          : key_str;
      const std::string colored_value = this->get_style().use_colors
          ? color_handler_t::colorize(
                value_str, this->get_style().data_fg, color_t::DEFAULT)
          : value_str;
 
      os << "  " << colored_key << arrow << colored_value;
      if (partial || idx < total - 1) {
        os << ",";
      }
      os << "\n";
    }
 
    if (partial) {
      os << "  " << this->ellipsis();
      if (tail_start < total) {
        os << ",";
      }
      os << "\n";
 
      auto it = this->get_container().begin();
      std::advance(it, tail_start);
      for (; it != this->get_container().end(); ++it) {
        const auto& [key, value] = *it;
        const std::string key_str = to_string_value(key);
        const std::string value_str = to_string_value(value);
        const std::string arrow = " => ";
 
        const std::string colored_key = this->get_style().use_colors
            ? color_handler_t::colorize(
                  key_str, this->get_style().header_fg, color_t::DEFAULT)
            : key_str;
        const std::string colored_value = this->get_style().use_colors
            ? color_handler_t::colorize(
                  value_str, this->get_style().data_fg, color_t::DEFAULT)
            : value_str;
 
        os << "  " << colored_key << arrow << colored_value;
        if (std::next(it) != this->get_container().end()) {
          os << ",";
        }
        os << "\n";
      }
    }
  }
 
public:
  using container_printer_t<std::map<K, V>>::container_printer_t;
};
 
template<typename K, typename V>
class CPP_TOOLBOX_EXPORT unorderedmap_printer_t
    : public container_printer_t<std::unordered_map<K, V>>
{
protected:
  [[nodiscard]] auto get_size() const -> size_t override
  {
    return this->get_container().size();
  }
 
  void print_content(std::ostream& os) const override
  {
    size_t i = 0;
    for (const auto& [key, value] : this->get_container()) {
      const std::string key_str = to_string_value(key);
      const std::string value_str = to_string_value(value);
      const std::string arrow = " => ";
 
      const std::string colored_key = this->get_style().use_colors
          ? color_handler_t::colorize(
                key_str, this->get_style().header_fg, color_t::DEFAULT)
          : key_str;
      const std::string colored_value = this->get_style().use_colors
          ? color_handler_t::colorize(
                value_str, this->get_style().data_fg, color_t::DEFAULT)
          : value_str;
 
      os << "  " << colored_key << arrow << colored_value;
      if (i < this->get_container().size() - 1) {
        os << ",";
      }
      os << "\n";
      i++;
    }
  }
 
public:
  using container_printer_t<std::unordered_map<K, V>>::container_printer_t;
};
 
template<typename T>
class CPP_TOOLBOX_EXPORT set_printer_t : public container_printer_t<std::set<T>>
{
protected:
  [[nodiscard]] auto get_size() const -> size_t override
  {
    return this->get_container().size();
  }
 
  void print_content(std::ostream& os) const override
  {
    size_t i = 0;
    for (const auto& item : this->get_container()) {
      const std::string value = to_string_value(item);
 
      const std::string colored_value = this->get_style().use_colors
          ? color_handler_t::colorize(
                value, this->get_style().data_fg, color_t::DEFAULT)
          : value;
 
      os << "  " << colored_value;
      if (i < this->get_container().size() - 1) {
        os << ",";
      }
      os << "\n";
      i++;
    }
  }
 
public:
  using container_printer_t<std::set<T>>::container_printer_t;
};
 
template<typename T>
class CPP_TOOLBOX_EXPORT unorderedset_printer_t
    : public container_printer_t<std::unordered_set<T>>
{
protected:
  [[nodiscard]] auto get_size() const -> size_t override
  {
    return this->get_container().size();
  }
 
  void print_content(std::ostream& os) const override
  {
    size_t i = 0;
    for (const auto& item : this->get_container()) {
      const std::string value = to_string_value(item);
 
      const std::string colored_value = this->get_style().use_colors
          ? color_handler_t::colorize(
                value, this->get_style().data_fg, color_t::DEFAULT)
          : value;
 
      os << "  " << colored_value;
      if (i < this->get_container().size() - 1) {
        os << ",";
      }
      os << "\n";
      i++;
    }
  }
 
public:
  using container_printer_t<std::unordered_set<T>>::container_printer_t;
};
 
template<typename T>
class CPP_TOOLBOX_EXPORT deque_printer_t
    : public container_printer_t<std::deque<T>>
{
protected:
  [[nodiscard]] auto get_size() const -> size_t override
  {
    return this->get_container().size();
  }
 
  void print_content(std::ostream& os) const override
  {
    for (size_t i = 0; i < this->get_container().size(); ++i) {
      const std::string index = "[" + std::to_string(i) + "]: ";
      const std::string value = to_string_value(this->get_container()[i]);
 
      const std::string colored_index = this->get_style().use_colors
          ? color_handler_t::colorize(
                index, this->get_style().header_fg, color_t::DEFAULT)
          : index;
      const std::string colored_value = this->get_style().use_colors
          ? color_handler_t::colorize(
                value, this->get_style().data_fg, color_t::DEFAULT)
          : value;
 
      os << "  " << colored_index << colored_value;
      if (i < this->get_container().size() - 1) {
        os << ",";
      }
      os << "\n";
    }
  }
 
public:
  using container_printer_t<std::deque<T>>::container_printer_t;
};
 
template<typename T>
class CPP_TOOLBOX_EXPORT list_printer_t
    : public container_printer_t<std::list<T>>
{
protected:
  [[nodiscard]] auto get_size() const -> size_t override
  {
    return this->get_container().size();
  }
 
  void print_content(std::ostream& os) const override
  {
    size_t i = 0;
    const auto& container = this->get_container();  // Cache container reference
    for (const auto& item : container) {  // 使用 getter
      const std::string index = "[" + std::to_string(i) + "]: ";  // const
      const std::string value = to_string_value(item);  // const
 
      const std::string colored_index = this->get_style().use_colors
          ? color_handler_t::colorize(
                index, this->get_style().header_fg, color_t::DEFAULT)
          : index;
      const std::string colored_value = this->get_style().use_colors
          ? color_handler_t::colorize(
                value, this->get_style().data_fg, color_t::DEFAULT)
          : value;
 
      os << "  " << colored_index << colored_value;
      // 使用 std::next 获取下一个迭代器来检查是否是最后一个元素
      // Cast i + 1 to difference_type to avoid sign conversion warning
      using diff_t = typename std::list<T>::difference_type;
      if (std::next(container.begin(), static_cast<diff_t>(i + 1))
          != container.end())
      {
        os << ",";
      }
      os << "\n";
      i++;
    }
  }
 
public:
  using container_printer_t<std::list<T>>::container_printer_t;
};
 
template<typename T, size_t N>
class CPP_TOOLBOX_EXPORT array_printer_t
    : public container_printer_t<std::array<T, N>>
{
protected:
  [[nodiscard]] auto get_size() const -> size_t override { return N; }
 
  void print_content(std::ostream& os) const override
  {
    for (size_t i = 0; i < N; ++i) {
      const std::string index = "[" + std::to_string(i) + "]: ";
      const std::string value = to_string_value(this->get_container()[i]);
 
      const std::string colored_index = this->get_style().use_colors
          ? color_handler_t::colorize(
                index, this->get_style().header_fg, color_t::DEFAULT)
          : index;
      const std::string colored_value = this->get_style().use_colors
          ? color_handler_t::colorize(
                value, this->get_style().data_fg, color_t::DEFAULT)
          : value;
 
      os << "  " << colored_index << colored_value;
      if (i < N - 1) {
        os << ",";
      }
      os << "\n";
    }
  }
 
public:
  using container_printer_t<std::array<T, N>>::container_printer_t;
};
 
template<typename T>
class CPP_TOOLBOX_EXPORT queue_printer_t
    : public container_printer_t<std::queue<T>>
{
protected:
  [[nodiscard]] auto get_size() const -> size_t override
  {
    return this->get_container().size();
  }
 
  void print_content(std::ostream& os) const override
  {
    // 由于 std::queue 不支持随机访问，这里需要复制一份队列进行遍历
    // Since std::queue does not support random access, we need to copy the
    // queue for traversal.
    std::queue<T> q_copy = this->get_container();
    size_t i = 0;
    const size_t total_size = q_copy.size();  // 先获取总大小
    while (!q_copy.empty()) {
      const std::string index = "[" + std::to_string(i) + "]: ";
      const std::string value =
          to_string_value(q_copy.front());  // 获取队首元素
 
      const std::string colored_index = this->get_style().use_colors
          ? color_handler_t::colorize(
                index, this->get_style().header_fg, color_t::DEFAULT)
          : index;
      const std::string colored_value = this->get_style().use_colors
          ? color_handler_t::colorize(
                value, this->get_style().data_fg, color_t::DEFAULT)
          : value;
 
      os << "  " << colored_index << colored_value;
      if (i < total_size - 1) {  // 使用总大小判断是否需要逗号
        os << ",";
      }
      os << "\n";
      q_copy.pop();  // 弹出队首元素
      ++i;
    }
  }
 
public:
  // 继承基类构造函数/Inherit base class constructors
  using container_printer_t<std::queue<T>>::container_printer_t;
};
 
template<typename T>
auto print_vector(const std::vector<T>& vec,
                  const std::string& name = "Vector",
                  const print_style_t& style = get_default_style())
    -> vector_printer_t<T>
{
  return vector_printer_t<T>(vec, name, style);
}
 
template<typename K, typename V>
auto print_map(const std::map<K, V>& m,
               const std::string& name = "Map",
               const print_style_t& style = get_default_style())
    -> map_printer_t<K, V>
{
  return map_printer_t<K, V>(m, name, style);
}
 
template<typename K, typename V>
auto print_unordered_map(const std::unordered_map<K, V>& m,
                         const std::string& name = "Unordered Map",
                         const print_style_t& style = get_default_style())
    -> unorderedmap_printer_t<K, V>
{
  return unorderedmap_printer_t<K, V>(m, name, style);
}
 
template<typename T>
auto print_set(const std::set<T>& s,
               const std::string& name = "Set",
               const print_style_t& style = get_default_style())
    -> set_printer_t<T>
{
  return set_printer_t<T>(s, name, style);
}
 
template<typename T>
auto print_unordered_set(const std::unordered_set<T>& s,
                         const std::string& name = "Unordered Set",
                         const print_style_t& style = get_default_style())
    -> unorderedset_printer_t<T>
{
  return unorderedset_printer_t<T>(s, name, style);
}
 
template<typename T>
auto print_deque(const std::deque<T>& d,
                 const std::string& name = "Deque",
                 const print_style_t& style = get_default_style())
    -> deque_printer_t<T>
{
  return deque_printer_t<T>(d, name, style);
}
 
template<typename T>
auto print_list(const std::list<T>& l,
                const std::string& name = "List",
                const print_style_t& style = get_default_style())
    -> list_printer_t<T>
{
  return list_printer_t<T>(l, name, style);
}
 
template<typename T, size_t N>
auto print_array(const std::array<T, N>& arr,
                 const std::string& name = "Array",
                 const print_style_t& style = get_default_style())
    -> array_printer_t<T, N>
{
  return array_printer_t<T, N>(arr, name, style);
}
 
template<typename T>
auto print_queue(const std::queue<T>& q,
                 const std::string& name = "Queue",
                 const print_style_t& style = get_default_style())
    -> queue_printer_t<T>
{
  return queue_printer_t<T>(q, name, style);
}
 
}  // namespace toolbox::utils