std::format_kind

 

C++

Compiler support

Freestanding and hosted

Language

Standard library

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Metaprogramming library (C++11)

Diagnostics library

General utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Localizations library

Input/output library

Filesystem library (C++17)

Regular expressions library (C++11)

Concurrency support library (C++11)

Technical specifications

Symbols index

External libraries

 

Utilities library

Language support Type support (basic types, RTTI) Library feature-test macros (C++20) Dynamic memory management Program utilities Coroutine support (C++20) Variadic functions is_constant_evaluated (C++20) is_within_lifetime (C++26) initializer_list (C++11) source_location (C++20) Three-way comparison (C++20) three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)    is_eqis_neqis_ltis_lteqis_gtis_gteq (C++20)(C++20)(C++20)(C++20)(C++20)(C++20)

General utilities Date and time Function objects Formatting library (C++20) bitset hash (C++11) Relational operators (deprecated in C++20) rel_ops::operator!=rel_ops::operator> rel_ops::operator<=rel_ops::operator>= Integer comparison functions cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)    cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Swap and type operations swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Common vocabulary types pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23) Elementary string conversions to_chars (C++17) from_chars (C++17) chars_format (C++17) to_chars_result (C++17) from_chars_result (C++17)

 

Formatting library

Formatting functions

format (C++20)

format_to (C++20)

format_to_n (C++20)

formatted_size (C++20)

vformat (C++20)

vformat_to (C++20)

Formatting concepts

formattable (C++23)

Formatter

formatter (C++20)

range_formatter (C++23)

basic_format_parse_contextformat_parse_contextwformat_parse_context (C++20)(C++20)(C++20)

basic_format_contextformat_contextwformat_context (C++20)(C++20)(C++20)

range_format (C++23)

format_kind (C++23)

Formatting arguments

basic_format_arg (C++20)

basic_format_arg::handle (C++20)

basic_format_argsformat_argswformat_args (C++20)(C++20)(C++20)

basic_format_stringformat_stringwformat_string (C++20)(C++20)(C++20)

visit_format_arg (C++20) (deprecated in C++26)

make_format_argsmake_wformat_args (C++20)(C++20)

Format error

format_error (C++20)

 

Defined in header <format>
template< class R > inline constexpr /* unspecified */ format_kind = /* unspecified */;	(1)	(since C++23)
template< ranges::input_range R >     requires std::same_as<R, std::remove_cvref_t<R>> inline constexpr range_format format_kind<R> = /* see description */;	(2)	(since C++23)

The variable template format_kind selects an appropriate std::range_format for a range R.

format_kind<R> is defined as follows:

• If std::same_as<std::remove_cvref_t<ranges::range_reference_t<R>>, R> is true, format_kind<R> is range_format::disabled.
• Otherwise, if R::key_type is valid and denotes a type:
  • If R::mapped_type is valid and denotes a type, let U be std::remove_cvref_t<ranges::range_reference_t<R>>. If either U is a specialization of std::pair or U is a specialization of std::tuple and std::tuple_size_v<U> == 2, format_kind<R> is range_format::map.
  • Otherwise, format_kind<R> is range_format::set.
• Otherwise, format_kind<R> is range_format::sequence.

A program that instantiates a primary template of the format_kind variable template is ill-formed.

User-provided specialization of format_kind is allowed as long as:

• R is cv-unqualified program-defined type,
• R satisfies input_range,
• its specialization shall be usable in constant expressions, and
• format_kind<R> has type const range_format.

Possible implementation

namespace detail { template< typename > inline constexpr bool is_pair_or_tuple_2 = false;   template< typename T, typename U > inline constexpr bool is_pair_or_tuple_2<std::pair<T, U>> = true;   template< typename... Ts > inline constexpr bool is_pair_or_tuple_2<std::tuple<Ts...>> = true;   template < typename T > requires std::is_reference_v<T> || std::is_const_v<T> inline constexpr bool is_pair_or_tuple_2<T> = is_pair_or_tuple_2<std::remove_cvref_t<T>>; }   template< class R > inline constexpr range_format format_kind = [] { static_assert(false, "instantiating a primary template is not allowed"); return range_format::disabled; }();   template< ranges::input_range R > requires std::same_as<R, std::remove_cvref_t<R>> inline constexpr range_format format_kind<R> = [] { if constexpr (std::same_as<std::remove_cvref_t<std::ranges::range_reference_t<R>>, R>) return range_format::disabled; else if constexpr (requires { typename R::key_type; }) { if constexpr (requires { typename R::mapped_type; } && detail::is_pair_or_tuple_2<std::ranges::range_reference_t<R>>) return range_format::map; else return range_format::set; } else return range_format::sequence; }();

Example

Run this code

#include <filesystem>
#include <format>
#include <map>
#include <set>
#include <vector>
 
struct A {};
 
static_assert(std::format_kind<std::vector<int>> == std::range_format::sequence);
static_assert(std::format_kind<std::map<int>> == std::range_format::map);
static_assert(std::format_kind<std::set<int>> == std::range_format::set);
static_assert(std::format_kind<std::filesystem::path> == std::range_format::disabled);
// ill-formed:
// static_assert(std::format_kind<A> == std::range_format::disabled);
 
int main() {}

See also

range_format (C++23)

specifies how a range should be formatted (enum)