tuple.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 Jarosław Pelczar <jarek@jpelczar.com>
//
// SPDX-License-Identifier: BSD-2-Clause
 
#pragma once
 
#include "../microfmt.hpp"
#include <array>
#include <cstddef>
#include <string_view>
#include <tuple>
#include <type_traits>
#include <utility>
 
namespace microfmt {
 
namespace detail {
 
template <typename T> using remove_cvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
 
template <typename T, typename = void> struct has_data : std::false_type {};
 
template <typename T> struct has_data<T, std::void_t<decltype(std::declval<T &>().data())>> : std::true_type {};
 
template <typename T, typename = void> struct is_tuple_like : std::false_type {};
 
template <typename T>
struct is_tuple_like<T, std::void_t<decltype(std::tuple_size<remove_cvref_t<T>>::value)>>
    : std::integral_constant<bool, !has_data<remove_cvref_t<T>>::value> {};
 
template <typename Tuple, size_t... Is>
void format_tuple_impl(const Tuple &t, const sink &out, microfmt::string_view sep, microfmt::string_view spec,
                       std::index_sequence<Is...>) noexcept {
  size_t idx = 0;
  auto format_elem = [&idx, &out, &sep, &spec](const auto &elem) noexcept {
    if (idx++ > 0) {
      out.write(sep);
    }
    using ElemType = remove_cvref_t<decltype(elem)>;
    element_formatter<ElemType> f;
    format_parse_context ctx(spec);
    f.parse(ctx);
    f.format(elem, out);
  };
 
  (format_elem(std::get<Is>(t)), ...);
}
 
} // namespace detail
 
template <typename T> struct formatter<T, std::enable_if_t<detail::is_tuple_like<T>::value>> {
  char open_delim{'('};
  char close_delim{')'};
  microfmt::string_view separator{", "};
  microfmt::string_view forwarded_spec{""};
 
  constexpr void parse(format_parse_context &ctx) noexcept {
    auto spec = ctx.spec();
    if (spec.empty())
      return;
 
    size_t i = 0;
    // Check custom delimiter style
    if (spec[0] == 'b' || spec[0] == 'B') { // Bracket style: [a, b, c]
      open_delim = '[';
      close_delim = ']';
      i = 1;
    } else if (spec[0] == 'c' || spec[0] == 'C') { // Curly/Brace style: {a, b, c}
      open_delim = '{';
      close_delim = '}';
      i = 1;
    } else if (spec[0] == 'n' || spec[0] == 'N') { // Naked/Bare: a, b, c (no delimiters)
      open_delim = '\0';
      close_delim = '\0';
      i = 1;
    } else if (spec[0] == 'p' || spec[0] == 'P') { // Standard parens: (a, b, c)
      open_delim = '(';
      close_delim = ')';
      i = 1;
    }
 
    forwarded_spec = spec.substr(i);
  }
 
  void format(const T &t, const sink &out) const noexcept {
    if (open_delim != '\0') {
      out.put(open_delim);
    }
 
    constexpr size_t N = std::tuple_size<detail::remove_cvref_t<T>>::value;
    if constexpr (N > 0) {
      detail::format_tuple_impl(t, out, separator, forwarded_spec, std::make_index_sequence<N>{});
    }
 
    if (close_delim != '\0') {
      out.put(close_delim);
    }
  }
};
 
} // namespace microfmt