detail Namespace Reference

Converts a string literal into a format string that will be parsed at compile time and converted into efficient formatting code. More...

Namespaces
namespace	adl
namespace	dragonbox
namespace	tuple

Classes
struct	all
struct	ansi_color_escape
class	apple_file
class	arg_converter
struct	arg_formatter
struct	arg_pack
union	arg_ref
struct	basic_fp
struct	big_decimal_fp
class	bigint
struct	bitint
class	buffer
	A contiguous memory buffer with an optional growing ability. More...
struct	buffer_traits
class	char_converter
struct	chrono_format_checker
struct	codecvt_result
struct	color_type
class	compile_parse_context
struct	compile_string
class	container_buffer
struct	count_fractional_digits
struct	count_fractional_digits< Num, Den, N, false >
class	counting_buffer
struct	custom_tag
struct	custom_value
struct	default_arg_formatter
class	digit_grouping
struct	duration_formatter
class	dynamic_arg_list
struct	dynamic_format_specs
struct	dynamic_spec_getter
struct	dynamic_spec_handler
class	fallback_digit_grouping
class	fallback_file
class	file_access
class	file_base
class	file_print_buffer
class	file_print_buffer< F, enable_if_t< has_flockfile< F >::value > >
struct	find_escape_result
class	fixed_buffer_traits
struct	fixed_string
struct	float128
struct	format_arg_store
struct	format_handler
struct	format_string_char
struct	format_string_char< S, enable_if_t< std::is_base_of< detail::compile_string, S >::value > >
struct	format_string_char< S, void_t< decltype(sizeof(detail::to_string_view(std::declval< S >())))> >
class	format_string_checker
struct	format_tuple_element
class	formatbuf
struct	get_cstring
class	get_locale
class	glibc_file
struct	has_back_insert_iterator_container_append
struct	has_back_insert_iterator_container_append< OutputIt, InputIt, void_t< decltype(get_container(std::declval< OutputIt >()) .append(std::declval< InputIt >(), std::declval< InputIt >()))> >
struct	has_back_insert_iterator_container_insert_at_end
struct	has_back_insert_iterator_container_insert_at_end< OutputIt, InputIt, void_t< decltype(get_container(std::declval< OutputIt >()) .insert(get_container(std::declval< OutputIt >()).end(), std::declval< InputIt >(), std::declval< InputIt >()))> >
struct	has_const_begin_end
struct	has_const_begin_end< T, void_t< decltype(*detail::range_begin(std::declval< const remove_cvref_t< T > & >())), decltype(detail::range_end(std::declval< const remove_cvref_t< T > & >()))> >
struct	has_flip
struct	has_flip< T, void_t< decltype(std::declval< T >().flip())> >
struct	has_flockfile
struct	has_flockfile< F, void_t< decltype(flockfile(&std::declval< F & >()))> >
struct	has_format_as
struct	has_format_as< T, void_t< decltype(format_as(std::declval< const T & >()))> >
struct	has_format_as_member
struct	has_format_as_member< T, void_t< decltype(formatter< T >::format_as(std::declval< const T & >()))> >
struct	has_isfinite
struct	has_isfinite< T, enable_if_t< sizeof(std::isfinite(T())) !=0 > >
struct	has_member_fn_begin_end_t
struct	has_member_fn_begin_end_t< T, void_t< decltype(*std::declval< T >().begin()), decltype(std::declval< T >().end())> >
struct	has_mutable_begin_end
struct	has_mutable_begin_end< T, void_t< decltype(*detail::range_begin(std::declval< T & >())), decltype(detail::range_end(std::declval< T & >())), int > >
struct	has_tm_gmtoff
struct	has_tm_gmtoff< T, void_t< decltype(T::tm_gmtoff)> >
struct	has_tm_zone
struct	has_tm_zone< T, void_t< decltype(T::tm_zone)> >
struct	has_to_string_view
struct	has_to_string_view< T, void_t< decltype(detail::to_string_view(std::declval< T >()))> >
struct	int_checker
struct	int_checker< true >
struct	integer_sequence
struct	is_back_insert_iterator
struct	is_back_insert_iterator< basic_appender< T > >
struct	is_back_insert_iterator< It, bool_constant< std::is_same< decltype(adl::invoke_back_inserter< typename It::container_type >()), It >::value > >
struct	is_bit_reference_like
struct	is_buffer_appender
struct	is_buffer_appender< It, bool_constant< is_back_insert_iterator< It >::value &&std::is_base_of< buffer< typename It::container_type::value_type >, typename It::container_type >::value > >
struct	is_code_unit
struct	is_code_unit< char >
struct	is_code_unit< char16_t >
struct	is_code_unit< char32_t >
struct	is_code_unit< wchar_t >
class	is_container_adaptor_like
struct	is_fast_float
struct	is_floating_point
struct	is_floating_point< float128 >
struct	is_formattable_delayed
struct	is_integral
struct	is_integral< int128_opt >
struct	is_integral< uint128_t >
class	is_map
struct	is_named_arg
struct	is_named_arg< named_arg< Char, T > >
struct	is_output_iterator
struct	is_output_iterator< appender, char >
struct	is_output_iterator< It, T, enable_if_t< std::is_assignable< decltype(*std::declval< decay_t< It > & >()++), T >::value > >
struct	is_range_
struct	is_range_< T, void >
struct	is_reference_wrapper
struct	is_reference_wrapper< std::reference_wrapper< T > >
class	is_set
struct	is_static_named_arg
struct	is_std_string_like
struct	is_std_string_like< T, void_t< decltype(std::declval< T >().find_first_of(typename T::value_type(), 0))> >
class	is_tuple_formattable_
class	is_tuple_formattable_< T, C, true >
class	is_tuple_like_
struct	is_view
struct	is_view< T, bool_constant< sizeof(T) !=0 > >
struct	is_zero_int
class	iterator_buffer
class	iterator_buffer< OutputIt, enable_if_t< is_back_insert_iterator< OutputIt >::value &&is_contiguous< typename OutputIt::container_type >::value, typename OutputIt::container_type::value_type > >
class	iterator_buffer< T *, T >
class	iterator_buffer< T *, T, fixed_buffer_traits >
struct	loc_writer
struct	local_t
struct	locale
struct	locking
struct	locking< T, void_t< typename formatter< remove_cvref_t< T > >::nonlocking > >
struct	make_integer_sequence
struct	make_integer_sequence< T, 0, Ns... >
struct	make_unsigned_or_bool
struct	make_unsigned_or_bool< bool >
struct	make_unsigned_or_unchanged
struct	make_unsigned_or_unchanged< T, true >
struct	named_arg
struct	named_arg_info
struct	named_arg_store
struct	named_arg_value
struct	native_formatter
struct	node
struct	null
struct	null_chrono_spec_handler
struct	numpunct
struct	parse_dynamic_spec_result
struct	parse_empty_specs
class	printf_arg_formatter
struct	printf_precision_handler
class	printf_width_handler
struct	range_format_kind_
struct	singleton
struct	size_padding
struct	span
struct	std_string_view
struct	streamed_view
struct	string_literal
struct	string_value
struct	styled_arg
struct	thousands_sep_result
class	tm_format_checker
class	tm_writer
class	to_utf8
struct	type_constant
struct	type_is_unformattable_for
struct	type_mapper
struct	ubitint
struct	udl_arg
class	uint128_fallback
struct	use_format_as
struct	use_format_as< T, bool_constant< std::is_arithmetic< format_as_result< T > >::value > >
struct	use_format_as_member
struct	use_format_as_member< T, bool_constant< std::is_arithmetic< format_as_member_result< T > >::value > >
struct	utc_clock
class	utf8_to_utf16
class	value
struct	view
struct	write_int_arg

Typedefs
using	uint128_t = conditional_t<FMT_USE_INT128, uint128_opt, uint128_fallback>
using	uintptr_t = uint128_t
template<typename OutputIt >
using	reserve_iterator
template<typename T >
using	is_signed
template<typename T >
using	is_integer
template<typename T >
using	is_float128 = std::is_same<T, float128>
template<typename T >
using	uint32_or_64_or_128_t
template<typename T >
using	uint64_or_128_t = conditional_t<num_bits<T>() <= 64, uint64_t, uint128_t>
using	fp = basic_fp<unsigned long long>
template<typename T , bool doublish = num_bits<T>() == num_bits<double>()>
using	convert_float_result
template<typename T >
using	is_builtin
using	format_func = void (*)(detail::buffer<char>&, int, const char*)
template<size_t... N>
using	index_sequence = integer_sequence<size_t, N...>
template<size_t N>
using	make_index_sequence = make_integer_sequence<size_t, N>
template<typename T >
using	tuple_index_sequence = make_index_sequence<std::tuple_size<T>::value>
template<typename Range >
using	range_reference_type
template<typename Range >
using	uncvref_type = remove_cvref_t<range_reference_type<Range>>
template<range_format K>
using	range_format_constant = std::integral_constant<range_format, K>
template<typename Char , typename Element >
using	range_formatter_type = formatter<remove_cvref_t<Element>, Char>
template<typename R >
using	maybe_const_range
using	file_ref = decltype(get_file(static_cast<FILE*>(nullptr), 0))
template<typename T , typename U >
using	is_similar_arithmetic_type
template<typename Char >
using	unsigned_char = conditional_t<sizeof(Char) == 1, unsigned char, unsigned>
template<typename S , typename V = decltype(detail::to_string_view(std::declval<S>()))>
using	char_t = typename V::value_type
	String's character (code unit) type. detail:: is intentional to prevent ADL.
using	long_type = conditional_t<long_short, int, long long>
using	ulong_type = conditional_t<long_short, unsigned, unsigned long long>
template<typename T >
using	format_as_result
template<typename T >
using	format_as_member_result
template<typename T , typename U = remove_const_t<T>>
using	use_formatter
template<typename T , typename Char >
using	mapped_t = decltype(detail::type_mapper<Char>::map(std::declval<T&>()))
template<typename T , typename Char = char>
using	mapped_type_constant = type_constant<mapped_t<T, Char>, Char>
template<typename T , typename Context , type TYPE = mapped_type_constant<T, typename Context::char_type>::value>
using	stored_type_constant
template<typename Context , int NUM_ARGS>
using	arg_t
template<typename T >
using	is_exotic_char = bool_constant<!std::is_same<T, char>::value>
template<typename S >
using	format_string_char_t = typename format_string_char<S>::type

Enumerations
enum class	to_utf8_error_policy { abort , replace }
enum	dragon { predecessor_closer = 1 , fixup = 2 , fixed = 4 }
enum class	numeric_system { standard , alternative }
enum class	pad_type { zero , none , space }
enum class	int128_opt
enum class	uint128_opt
enum	{ is_utf8_enabled = "\u00A7"[1] == '\xA7' }
enum	{ use_utf8 = !FMT_WIN32 || is_utf8_enabled }
enum class	type {   none_type , int_type , uint_type , long_long_type ,   ulong_long_type , int128_type , uint128_type , bool_type ,   char_type , last_integer_type = char_type , float_type , double_type ,   long_double_type , last_numeric_type = long_double_type , cstring_type , string_type ,   pointer_type , custom_type }
enum	{   sint_set , uint_set , bool_set = set(type::bool_type) , char_set = set(type::char_type) ,   float_set , string_set = set(type::string_type) , cstring_set = set(type::cstring_type) , pointer_set = set(type::pointer_type) }
enum	{ long_short = sizeof(long) == sizeof(int) && FMT_BUILTIN_TYPES }
enum class	state {   start , align , sign , hash ,   zero , width , precision , locale }
enum	{ packed_arg_bits = 4 }
enum	{ max_packed_args = 62 / packed_arg_bits }
enum	: unsigned long long { is_unpacked_bit = 1ULL << 63 }
enum	: unsigned long long { has_named_args_bit = 1ULL << 62 }

Functions
template<bool IS_CONSTEXPR, typename T , typename Ptr = const T*>
FMT_CONSTEXPR auto	find (Ptr first, Ptr last, T value, Ptr &out) -> bool
template<>
auto	find< false, char > (const char *first, const char *last, char value, const char *&out) -> bool
template<typename T , typename Context , typename Char >
void	convert_arg (basic_format_arg< Context > &arg, Char type)
template<typename Char >
auto	make_arg_formatter (basic_appender< Char > iter, format_specs &s) -> arg_formatter< Char >
template<typename Char >
void	parse_flags (format_specs &specs, const Char *&it, const Char *end)
template<typename Char , typename GetArg >
auto	parse_header (const Char *&it, const Char *end, format_specs &specs, GetArg get_arg) -> int
auto	parse_printf_presentation_type (char c, type t, bool &upper) -> presentation_type
template<typename Char , typename Context >
void	vprintf (buffer< Char > &buf, basic_string_view< Char > format, basic_format_args< Context > args)
FMT_CONSTEXPR void	abort_fuzzing_if (bool condition)
template<typename To , typename From , FMT_ENABLE_IF(sizeof(To)==sizeof(From)) >
FMT_CONSTEXPR20 auto	bit_cast (const From &from) -> To
auto	is_big_endian () -> bool
template<typename T >
constexpr auto	max_value () -> T
template<typename T >
constexpr auto	num_bits () -> int
template<>
constexpr auto	num_bits< int128_opt > () -> int
template<>
constexpr auto	num_bits< uint128_opt > () -> int
template<>
constexpr auto	num_bits< uint128_fallback > () -> int
template<typename To , typename From , FMT_ENABLE_IF(sizeof(To) > sizeof(From)) >
auto	bit_cast (const From &from) -> To
template<typename UInt >
FMT_CONSTEXPR20 auto	countl_zero_fallback (UInt n) -> int
FMT_CONSTEXPR20 auto	countl_zero (uint32_t n) -> int
FMT_CONSTEXPR20 auto	countl_zero (uint64_t n) -> int
FMT_INLINE void	assume (bool condition)
template<typename OutputIt , FMT_ENABLE_IF(is_back_insert_iterator< OutputIt >::value && is_contiguous< typename OutputIt::container >::value) >
FMT_CONSTEXPR20 auto	reserve (OutputIt it, size_t n) -> typename OutputIt::value_type *
template<typename T >
FMT_CONSTEXPR20 auto	reserve (basic_appender< T > it, size_t n) -> basic_appender< T >
template<typename Iterator >
constexpr auto	reserve (Iterator &it, size_t) -> Iterator &
template<typename T , typename OutputIt >
constexpr auto	to_pointer (OutputIt, size_t) -> T *
template<typename T >
FMT_CONSTEXPR auto	to_pointer (T *&ptr, size_t n) -> T *
template<typename T >
FMT_CONSTEXPR20 auto	to_pointer (basic_appender< T > it, size_t n) -> T *
template<typename OutputIt , FMT_ENABLE_IF(is_back_insert_iterator< OutputIt >::value && is_contiguous< typename OutputIt::container >::value) >
auto	base_iterator (OutputIt it, typename OutputIt::container_type::value_type *) -> OutputIt
template<typename Iterator >
constexpr auto	base_iterator (Iterator, Iterator it) -> Iterator
template<typename OutputIt , typename Size , typename T >
FMT_CONSTEXPR auto	fill_n (OutputIt out, Size count, const T &value) -> OutputIt
template<typename T , typename Size >
FMT_CONSTEXPR20 auto	fill_n (T *out, Size count, char value) -> T *
template<typename OutChar , typename InputIt , typename OutputIt >
FMT_CONSTEXPR FMT_NOINLINE auto	copy_noinline (InputIt begin, InputIt end, OutputIt out) -> OutputIt
FMT_CONSTEXPR auto	utf8_decode (const char *s, uint32_t *c, int *e) -> const char *
template<typename F >
FMT_CONSTEXPR void	for_each_codepoint (string_view s, F f)
FMT_CONSTEXPR auto	display_width_of (uint32_t cp) noexcept -> size_t
template<typename T , bool = is_floating_point<T>::value>
detail::is_fast_float bool_constant T	deallocate (T *p, size_t)
constexpr friend auto	operator== (allocator, allocator) noexcept -> bool
constexpr friend auto	operator!= (allocator, allocator) noexcept -> bool
FMT_API auto	write_console (int fd, string_view text) -> bool
FMT_API void	print (FILE *, string_view)
template<typename Char , size_t N>
FMT_EXPORT constexpr auto	compile_string_to_view (const Char(&s)[N]) -> basic_string_view< Char >
template<typename Char >
FMT_EXPORT constexpr auto	compile_string_to_view (basic_string_view< Char > s) -> basic_string_view< Char >
template<typename T , FMT_ENABLE_IF(is_signed< T >::value) >
constexpr auto	is_negative (T value) -> bool
auto	digits2 (size_t value) -> const char *
template<typename Char >
constexpr auto	getsign (sign s) -> Char
template<typename T >
FMT_CONSTEXPR auto	count_digits_fallback (T n) -> int
FMT_CONSTEXPR20 auto	count_digits (uint64_t n) -> int
template<int BITS, typename UInt >
FMT_CONSTEXPR auto	count_digits (UInt n) -> int
FMT_CONSTEXPR20 auto	count_digits (uint32_t n) -> int
template<typename Int >
constexpr auto	digits10 () noexcept -> int
template<>
constexpr auto	digits10< int128_opt > () noexcept -> int
template<>
constexpr auto	digits10< uint128_t > () noexcept -> int
template<typename Char >
FMT_API auto	thousands_sep_impl (locale_ref loc) -> thousands_sep_result< Char >
template<typename Char >
auto	thousands_sep (locale_ref loc) -> thousands_sep_result< Char >
template<>
auto	thousands_sep (locale_ref loc) -> thousands_sep_result< wchar_t >
template<typename Char >
FMT_API auto	decimal_point_impl (locale_ref loc) -> Char
template<typename Char >
auto	decimal_point (locale_ref loc) -> Char
template<>
auto	decimal_point (locale_ref loc) -> wchar_t
FMT_BEGIN_EXPORT template FMT_API auto	thousands_sep_impl< char > (locale_ref) -> thousands_sep_result< char >
template FMT_API auto	thousands_sep_impl< wchar_t > (locale_ref) -> thousands_sep_result< wchar_t >
template FMT_API auto	decimal_point_impl (locale_ref) -> char
template<typename Char >
FMT_END_EXPORT auto	equal2 (const Char *lhs, const char *rhs) -> bool
auto	equal2 (const char *lhs, const char *rhs) -> bool
template<typename Char >
FMT_CONSTEXPR20 FMT_INLINE void	write2digits (Char *out, size_t value)
template<typename Char , typename UInt >
FMT_CONSTEXPR20 auto	do_format_decimal (Char *out, UInt value, int size) -> Char *
template<typename Char , typename UInt >
FMT_CONSTEXPR FMT_INLINE auto	format_decimal (Char *out, UInt value, int num_digits) -> Char *
template<typename Char , typename UInt , typename OutputIt , FMT_ENABLE_IF(!std::is_pointer< remove_cvref_t< OutputIt > >::value) >
FMT_CONSTEXPR auto	format_decimal (OutputIt out, UInt value, int num_digits) -> OutputIt
template<typename Char , typename UInt >
FMT_CONSTEXPR auto	do_format_base2e (int base_bits, Char *out, UInt value, int size, bool upper=false) -> Char *
template<typename Char , typename UInt >
FMT_CONSTEXPR auto	format_base2e (int base_bits, Char *out, UInt value, int num_digits, bool upper=false) -> Char *
template<typename Char , typename OutputIt , typename UInt , FMT_ENABLE_IF(is_back_insert_iterator< OutputIt >::value) >
FMT_CONSTEXPR auto	format_base2e (int base_bits, OutputIt out, UInt value, int num_digits, bool upper=false) -> OutputIt
FMT_INLINE auto	umul128 (uint64_t x, uint64_t y) noexcept -> uint128_fallback
template<typename Float >
constexpr auto	has_implicit_bit () -> bool
template<typename Float >
constexpr auto	num_significand_bits () -> int
template<typename Float >
constexpr auto	exponent_mask () -> typename dragonbox::float_info< Float >::carrier_uint
template<typename Float >
constexpr auto	exponent_bias () -> int
FMT_CONSTEXPR auto	compute_exp_size (int exp) -> int
template<typename Char , typename OutputIt >
FMT_CONSTEXPR auto	write_exponent (int exp, OutputIt out) -> OutputIt
template<int SHIFT = 0, typename F >
FMT_CONSTEXPR auto	normalize (basic_fp< F > value) -> basic_fp< F >
FMT_CONSTEXPR auto	multiply (uint64_t lhs, uint64_t rhs) -> uint64_t
FMT_CONSTEXPR auto	operator* (fp x, fp y) -> fp
template<typename T >
constexpr auto	convert_float (T value) -> convert_float_result< T >
template<bool C, typename T , typename F , FMT_ENABLE_IF(C) >
auto	select (T true_value, F) -> T
template<typename Char , typename OutputIt >
FMT_CONSTEXPR FMT_NOINLINE auto	fill (OutputIt it, size_t n, const basic_specs &specs) -> OutputIt
template<typename Char , align default_align = align::left, typename OutputIt , typename F >
FMT_CONSTEXPR auto	write_padded (OutputIt out, const format_specs &specs, size_t size, size_t width, F &&f) -> OutputIt
template<typename Char , align default_align = align::left, typename OutputIt , typename F >
constexpr auto	write_padded (OutputIt out, const format_specs &specs, size_t size, F &&f) -> OutputIt
template<typename Char , align default_align = align::left, typename OutputIt >
FMT_CONSTEXPR auto	write_bytes (OutputIt out, string_view bytes, const format_specs &specs={}) -> OutputIt
template<typename Char , typename OutputIt , typename UIntPtr >
auto	write_ptr (OutputIt out, UIntPtr value, const format_specs *specs) -> OutputIt
FMT_API auto	is_printable (uint32_t cp) -> bool
auto	needs_escape (uint32_t cp) -> bool
template<typename Char >
auto	find_escape (const Char *begin, const Char *end) -> find_escape_result< Char >
auto	find_escape (const char *begin, const char *end) -> find_escape_result< char >
template<size_t width, typename Char , typename OutputIt >
auto	write_codepoint (OutputIt out, char prefix, uint32_t cp) -> OutputIt
template<typename OutputIt , typename Char >
auto	write_escaped_cp (OutputIt out, const find_escape_result< Char > &escape) -> OutputIt
template<typename Char , typename OutputIt >
auto	write_escaped_string (OutputIt out, basic_string_view< Char > str) -> OutputIt
template<typename Char , typename OutputIt >
auto	write_escaped_char (OutputIt out, Char v) -> OutputIt
template<typename Char , typename OutputIt >
FMT_CONSTEXPR auto	write_char (OutputIt out, Char value, const format_specs &specs) -> OutputIt
FMT_CONSTEXPR void	prefix_append (unsigned &prefix, unsigned value)
template<typename OutputIt , typename UInt , typename Char >
auto	write_int (OutputIt out, UInt value, unsigned prefix, const format_specs &specs, const digit_grouping< Char > &grouping) -> OutputIt
template<typename OutputIt >
auto	write_loc (OutputIt, const loc_value &, const format_specs &, locale_ref) -> bool
template<typename T >
FMT_CONSTEXPR auto	make_write_int_arg (T value, sign s) -> write_int_arg< uint32_or_64_or_128_t< T > >
template<typename Char , typename OutputIt , typename T >
FMT_CONSTEXPR FMT_INLINE auto	write_int (OutputIt out, write_int_arg< T > arg, const format_specs &specs) -> OutputIt
template<typename Char , typename OutputIt , typename T >
FMT_CONSTEXPR FMT_NOINLINE auto	write_int_noinline (OutputIt out, write_int_arg< T > arg, const format_specs &specs) -> OutputIt
template<typename Char , typename T , FMT_ENABLE_IF(is_integral< T >::value && !std::is_same< T, bool >::value && !std::is_same< T, Char >::value) >
FMT_CONSTEXPR FMT_INLINE auto	write (basic_appender< Char > out, T value, const format_specs &specs, locale_ref loc) -> basic_appender< Char >
template<typename Char , typename OutputIt , typename T , FMT_ENABLE_IF(is_integral< T >::value && !std::is_same< T, bool >::value && !std::is_same< T, Char >::value && !std::is_same< OutputIt, basic_appender< Char > >::value) >
FMT_CONSTEXPR FMT_INLINE auto	write (OutputIt out, T value, const format_specs &specs, locale_ref loc) -> OutputIt
template<typename Char , typename OutputIt >
FMT_CONSTEXPR auto	write (OutputIt out, Char value, const format_specs &specs, locale_ref loc={}) -> OutputIt
template<typename Char , typename OutputIt , FMT_ENABLE_IF(std::is_same< Char, char >::value) >
FMT_CONSTEXPR auto	write (OutputIt out, basic_string_view< Char > s, const format_specs &specs) -> OutputIt
template<typename Char , typename OutputIt >
FMT_CONSTEXPR auto	write (OutputIt out, basic_string_view< Char > s, const format_specs &specs, locale_ref) -> OutputIt
template<typename Char , typename OutputIt >
FMT_CONSTEXPR auto	write (OutputIt out, const Char *s, const format_specs &specs, locale_ref) -> OutputIt
template<typename Char , typename OutputIt , typename T , FMT_ENABLE_IF(is_integral< T >::value && !std::is_same< T, bool >::value && !std::is_same< T, Char >::value) >
FMT_CONSTEXPR auto	write (OutputIt out, T value) -> OutputIt
template<typename Char >
FMT_CONSTEXPR auto	parse_align (const Char *begin, const Char *end, format_specs &specs) -> const Char *
template<typename Char , typename OutputIt >
FMT_CONSTEXPR20 auto	write_nonfinite (OutputIt out, bool isnan, format_specs specs, sign s) -> OutputIt
constexpr auto	get_significand_size (const big_decimal_fp &f) -> int
template<typename T >
auto	get_significand_size (const dragonbox::decimal_fp< T > &f) -> int
template<typename Char , typename OutputIt >
constexpr auto	write_significand (OutputIt out, const char *significand, int significand_size) -> OutputIt
template<typename Char , typename OutputIt , typename UInt >
auto	write_significand (OutputIt out, UInt significand, int significand_size) -> OutputIt
template<typename Char , typename OutputIt , typename T , typename Grouping >
FMT_CONSTEXPR20 auto	write_significand (OutputIt out, T significand, int significand_size, int exponent, const Grouping &grouping) -> OutputIt
template<typename Char , typename UInt , FMT_ENABLE_IF(std::is_integral< UInt >::value) >
auto	write_significand (Char *out, UInt significand, int significand_size, int integral_size, Char decimal_point) -> Char *
template<typename OutputIt , typename UInt , typename Char , FMT_ENABLE_IF(!std::is_pointer< remove_cvref_t< OutputIt > >::value) >
auto	write_significand (OutputIt out, UInt significand, int significand_size, int integral_size, Char decimal_point) -> OutputIt
template<typename OutputIt , typename Char >
FMT_CONSTEXPR auto	write_significand (OutputIt out, const char *significand, int significand_size, int integral_size, Char decimal_point) -> OutputIt
template<typename OutputIt , typename Char , typename T , typename Grouping >
FMT_CONSTEXPR20 auto	write_significand (OutputIt out, T significand, int significand_size, int integral_size, Char decimal_point, const Grouping &grouping) -> OutputIt
template<typename T >
FMT_CONSTEVAL auto	exp_upper () -> int
constexpr auto	use_fixed (int exp, int exp_upper) -> bool
template<typename Char , typename Grouping , typename OutputIt , typename DecimalFP >
FMT_CONSTEXPR20 auto	write_fixed (OutputIt out, const DecimalFP &f, int significand_size, Char decimal_point, const format_specs &specs, sign s, locale_ref loc={}) -> OutputIt
template<typename Char , typename Grouping , typename OutputIt , typename DecimalFP >
FMT_CONSTEXPR20 auto	do_write_float (OutputIt out, const DecimalFP &f, const format_specs &specs, sign s, int exp_upper, locale_ref loc) -> OutputIt
template<typename Char , typename OutputIt , typename DecimalFP >
FMT_CONSTEXPR20 auto	write_float (OutputIt out, const DecimalFP &f, const format_specs &specs, sign s, int exp_upper, locale_ref loc) -> OutputIt
template<typename T >
constexpr auto	isnan (T value) -> bool
template<typename T , FMT_ENABLE_IF(is_floating_point< T >::value &&has_isfinite< T >::value) >
FMT_CONSTEXPR20 auto	isfinite (T value) -> bool
template<typename T , FMT_ENABLE_IF(!has_isfinite< T >::value) >
FMT_CONSTEXPR auto	isfinite (T value) -> bool
template<typename T , FMT_ENABLE_IF(is_floating_point< T >::value) >
FMT_INLINE FMT_CONSTEXPR auto	signbit (T value) -> bool
FMT_CONSTEXPR20 void	adjust_precision (int &precision, int exp10)
FMT_CONSTEXPR20 void	format_dragon (basic_fp< uint128_t > value, unsigned flags, int num_digits, buffer< char > &buf, int &exp10)
template<typename Float , FMT_ENABLE_IF(!is_double_double< Float >::value) >
FMT_CONSTEXPR20 void	format_hexfloat (Float value, format_specs specs, buffer< char > &buf)
constexpr auto	fractional_part_rounding_thresholds (int index) -> uint32_t
template<typename Float >
FMT_CONSTEXPR20 auto	format_float (Float value, int precision, const format_specs &specs, bool binary32, buffer< char > &buf) -> int
template<typename Char , typename OutputIt , typename T , FMT_ENABLE_IF(is_floating_point< T >::value) >
FMT_CONSTEXPR20 auto	write (OutputIt out, T value, format_specs specs, locale_ref loc={}) -> OutputIt
template<typename Char , typename OutputIt , typename T , FMT_ENABLE_IF(is_fast_float< T >::value) >
FMT_CONSTEXPR20 auto	write (OutputIt out, T value) -> OutputIt
template<typename Char , typename OutputIt , typename T , FMT_ENABLE_IF(is_floating_point< T >::value && !is_fast_float< T >::value) >
auto	write (OutputIt out, T value) -> OutputIt
template<typename Char , typename OutputIt >
auto	write (OutputIt out, monostate, format_specs={}, locale_ref={}) -> OutputIt
template<typename Char , typename OutputIt >
FMT_CONSTEXPR auto	write (OutputIt out, basic_string_view< Char > value) -> OutputIt
template<typename Char , typename OutputIt , typename T , FMT_ENABLE_IF(has_to_string_view< T >::value) >
constexpr auto	write (OutputIt out, const T &value) -> OutputIt
template<typename Char , typename OutputIt , typename T , bool check = std::is_enum<T>::value && !std::is_same<T, Char>::value && mapped_type_constant<T, Char>::value != type::custom_type, FMT_ENABLE_IF(check) >
FMT_CONSTEXPR auto	write (OutputIt out, T value) -> OutputIt
template<typename Char , typename OutputIt , typename T , FMT_ENABLE_IF(std::is_same< T, bool >::value) >
FMT_CONSTEXPR auto	write (OutputIt out, T value, const format_specs &specs={}, locale_ref={}) -> OutputIt
template<typename Char , typename OutputIt >
FMT_CONSTEXPR auto	write (OutputIt out, Char value) -> OutputIt
template<typename Char , typename OutputIt >
FMT_CONSTEXPR20 auto	write (OutputIt out, const Char *value) -> OutputIt
template<typename Char , typename OutputIt , typename T , FMT_ENABLE_IF(std::is_same< T, void >::value) >
auto	write (OutputIt out, const T *value, const format_specs &specs={}, locale_ref={}) -> OutputIt
template<typename Char , typename OutputIt , typename T , FMT_ENABLE_IF(mapped_type_constant< T, Char >::value== type::custom_type && !std::is_fundamental< T >::value) >
FMT_CONSTEXPR auto	write (OutputIt out, const T &value) -> OutputIt
template<typename Context >
FMT_CONSTEXPR void	handle_dynamic_spec (arg_id_kind kind, int &value, const arg_ref< typename Context::char_type > &ref, Context &ctx)
FMT_API void	do_report_error (format_func func, int error_code, const char *message) noexcept
FMT_API void	format_error_code (buffer< char > &out, int error_code, string_view message) noexcept
template<typename T , size_t N>
auto	range_begin (const T(&arr)[N]) -> const T *
template<typename T , size_t N>
auto	range_end (const T(&arr)[N]) -> const T *
template<typename T >
auto	range_begin (T &&rng) -> decltype(static_cast< T && >(rng).begin())
template<typename T >
auto	range_end (T &&rng) -> decltype(static_cast< T && >(rng).end())
template<typename Tuple , typename F , size_t... Is>
FMT_CONSTEXPR void	for_each (index_sequence< Is... >, Tuple &&t, F &&f)
template<typename Tuple , typename F >
FMT_CONSTEXPR void	for_each (Tuple &&t, F &&f)
template<typename Tuple1 , typename Tuple2 , typename F , size_t... Is>
void	for_each2 (index_sequence< Is... >, Tuple1 &&t1, Tuple2 &&t2, F &&f)
template<typename Tuple1 , typename Tuple2 , typename F >
void	for_each2 (Tuple1 &&t1, Tuple2 &&t2, F &&f)
template<typename Formatter >
FMT_CONSTEXPR auto	maybe_set_debug_format (Formatter &f, bool set) -> decltype(f.set_debug_format(set))
template<typename Formatter >
FMT_CONSTEXPR void	maybe_set_debug_format (Formatter &,...)
template<typename Facet >
Facet	use_facet (locale)
void	fwrite_all (const void *ptr, size_t count, FILE *stream)
template<typename Char >
FMT_FUNC auto	thousands_sep_impl (locale_ref loc) -> thousands_sep_result< Char >
template<typename Char >
FMT_FUNC auto	decimal_point_impl (locale_ref loc) -> Char
template<typename F >
auto	operator== (basic_fp< F > x, basic_fp< F > y) -> bool
FMT_INLINE auto	rotr (uint32_t n, uint32_t r) noexcept -> uint32_t
FMT_INLINE auto	rotr (uint64_t n, uint32_t r) noexcept -> uint64_t
FMT_FUNC void	vformat_to (buffer< char > &buf, string_view fmt, format_args args, locale_ref loc)
template<typename F >
auto	flockfile (F *f) -> decltype(_lock_file(f))
template<typename F >
auto	funlockfile (F *f) -> decltype(_unlock_file(f))
template<typename F >
auto	getc_unlocked (F *f) -> decltype(_fgetc_nolock(f))
template<typename F , FMT_ENABLE_IF(sizeof(F::_p) !=0 &&!FMT_USE_FALLBACK_FILE) >
auto	get_file (F *f, int) -> apple_file< F >
auto	get_file (FILE *f,...) -> fallback_file< FILE >
FMT_FUNC void	print (std::FILE *f, string_view text)
auto	is_printable (uint16_t x, const singleton *singletons, size_t singletons_size, const unsigned char *singleton_lowers, const unsigned char *normal, size_t normal_size) -> bool
template<typename Char >
FMT_CONSTEXPR auto	make_foreground_color (color_type foreground) noexcept -> ansi_color_escape< Char >
template<typename Char >
FMT_CONSTEXPR auto	make_background_color (color_type background) noexcept -> ansi_color_escape< Char >
template<typename Char >
FMT_CONSTEXPR auto	make_emphasis (emphasis em) noexcept -> ansi_color_escape< Char >
template<typename Char >
void	reset_color (buffer< Char > &buffer)
template<typename Char >
void	vformat_to (buffer< Char > &buf, text_style ts, basic_string_view< Char > fmt, basic_format_args< buffered_context< Char > > args)
template<typename T , typename... Tail>
constexpr auto	first (const T &value, const Tail &...) -> const T &
template<typename T >
auto	unwrap (const T &v) -> const T &
template<typename T >
auto	unwrap (const std::reference_wrapper< T > &v) -> const T &
auto	gmtime_r (...) -> null<>
auto	gmtime_s (...) -> null<>
auto	get_classic_locale () -> const std::locale &
template<typename CodeUnit >
void	write_codecvt (codecvt_result< CodeUnit > &out, string_view in, const std::locale &loc)
template<typename OutputIt >
auto	write_encoded_tm_str (OutputIt out, string_view in, const std::locale &loc) -> OutputIt
template<typename Char , typename OutputIt , FMT_ENABLE_IF(!std::is_same< Char, char >::value) >
auto	write_tm_str (OutputIt out, string_view sv, const std::locale &loc) -> OutputIt
template<typename Char >
void	do_write (buffer< Char > &buf, const std::tm &time, const std::locale &loc, char format, char modifier)
template<typename Char , typename OutputIt , FMT_ENABLE_IF(!std::is_same< Char, char >::value) >
auto	write (OutputIt out, const std::tm &time, const std::locale &loc, char format, char modifier=0) -> OutputIt
FMT_NORETURN void	throw_duration_error ()
template<typename To , typename FromRep , typename FromPeriod , FMT_ENABLE_IF(std::is_integral< FromRep >::value && std::is_integral< typename To::rep >::value) >
auto	duration_cast (std::chrono::duration< FromRep, FromPeriod > from) -> To
template<typename Duration >
auto	to_time_t (sys_time< Duration > time_point) -> std::time_t
void	write_digit2_separated (char *buf, unsigned a, unsigned b, unsigned c, char sep)
template<typename Period >
FMT_CONSTEXPR auto	get_units () -> const char *
template<typename OutputIt >
auto	write_padding (OutputIt out, pad_type pad, int width) -> OutputIt
template<typename OutputIt >
auto	write_padding (OutputIt out, pad_type pad) -> OutputIt
template<typename Char , typename Handler >
FMT_CONSTEXPR auto	parse_chrono_format (const Char *begin, const Char *end, Handler &&handler) -> const Char *
auto	tm_wday_full_name (int wday) -> const char *
auto	tm_wday_short_name (int wday) -> const char *
auto	tm_mon_full_name (int mon) -> const char *
auto	tm_mon_short_name (int mon) -> const char *
template<typename T , FMT_ENABLE_IF(has_tm_zone< T >::value) >
auto	set_tm_zone (T &time, char *tz) -> bool
auto	utc () -> char *
template<typename T , typename Int , FMT_ENABLE_IF(std::is_integral< T >::value) >
auto	to_nonnegative_int (T value, Int upper) -> Int
constexpr auto	pow10 (std::uint32_t n) -> long long
template<typename Char , typename OutputIt , typename Duration >
void	write_fractional_seconds (OutputIt &out, Duration d, int precision=-1)
template<typename Duration >
void	write_floating_seconds (memory_buffer &buf, Duration duration, int num_fractional_digits=-1)
template<typename T , FMT_ENABLE_IF(std::is_integral< T >::value &&has_isfinite< T >::value) >
auto	isfinite (T) -> bool
template<typename T , FMT_ENABLE_IF(std::is_integral< T >::value) >
auto	mod (T x, int y) -> T
template<typename Rep , typename Period , FMT_ENABLE_IF(std::is_integral< Rep >::value) >
auto	get_milliseconds (std::chrono::duration< Rep, Period > d) -> std::chrono::duration< Rep, std::milli >
template<typename Char , typename Rep , typename OutputIt , FMT_ENABLE_IF(std::is_integral< Rep >::value) >
auto	format_duration_value (OutputIt out, Rep val, int) -> OutputIt
template<typename Char , typename OutputIt >
auto	copy_unit (string_view unit, OutputIt out, Char) -> OutputIt
template<typename OutputIt >
auto	copy_unit (string_view unit, OutputIt out, wchar_t) -> OutputIt
template<typename Char , typename Period , typename OutputIt >
auto	format_duration_unit (OutputIt out) -> OutputIt
template<typename... T>
FMT_CONSTEXPR void	ignore_unused (const T &...)
constexpr auto	is_constant_evaluated (bool default_value=false) noexcept -> bool
template<typename T >
FMT_ALWAYS_INLINE constexpr auto	const_check (T val) -> T
FMT_NORETURN FMT_API void	assert_fail (const char *file, int line, const char *message)
auto	map (int128_opt) -> monostate
auto	map (uint128_opt) -> monostate
template<typename Int >
FMT_CONSTEXPR auto	to_unsigned (Int value) -> make_unsigned_t< Int >
template<typename T >
constexpr auto	narrow (T *) -> char *
constexpr FMT_ALWAYS_INLINE auto	narrow (const char *s) -> const char *
template<typename Char >
FMT_CONSTEXPR auto	compare (const Char *s1, const Char *s2, size_t n) -> int
template<typename OutputIt >
FMT_CONSTEXPR20 auto	get_container (OutputIt it) -> typename OutputIt::container_type &
template<typename Char , FMT_ENABLE_IF(is_code_unit< Char >::value) >
constexpr auto	to_string_view (const Char *s) -> basic_string_view< Char >
template<typename T , FMT_ENABLE_IF(is_std_string_like< T >::value) >
constexpr auto	to_string_view (const T &s) -> basic_string_view< typename T::value_type >
template<typename Char >
constexpr auto	to_string_view (basic_string_view< Char > s) -> basic_string_view< Char >
	FMT_TYPE_CONSTANT (int, int_type)
	FMT_TYPE_CONSTANT (unsigned, uint_type)
	FMT_TYPE_CONSTANT (long long, long_long_type)
	FMT_TYPE_CONSTANT (unsigned long long, ulong_long_type)
	FMT_TYPE_CONSTANT (int128_opt, int128_type)
	FMT_TYPE_CONSTANT (uint128_opt, uint128_type)
	FMT_TYPE_CONSTANT (bool, bool_type)
	FMT_TYPE_CONSTANT (Char, char_type)
	FMT_TYPE_CONSTANT (float, float_type)
	FMT_TYPE_CONSTANT (double, double_type)
	FMT_TYPE_CONSTANT (long double, long_double_type)
	FMT_TYPE_CONSTANT (const Char *, cstring_type)
	FMT_TYPE_CONSTANT (basic_string_view< Char >, string_type)
	FMT_TYPE_CONSTANT (const void *, pointer_type)
constexpr auto	is_integral_type (type t) -> bool
constexpr auto	is_arithmetic_type (type t) -> bool
constexpr auto	set (type rhs) -> int
constexpr auto	in (type t, int set) -> bool
template<bool B = false>
constexpr auto	count () -> int
template<bool B1, bool B2, bool... Tail>
constexpr auto	count () -> int
template<typename... T>
constexpr auto	count_named_args () -> int
template<typename... T>
constexpr auto	count_static_named_args () -> int
template<typename Char >
FMT_CONSTEXPR void	check_for_duplicate (named_arg_info< Char > *named_args, int named_arg_index, basic_string_view< Char > arg_name)
template<typename Char , typename T , FMT_ENABLE_IF(!is_named_arg< T >::value) >
void	init_named_arg (named_arg_info< Char > *, int &arg_index, int &, const T &)
template<typename T , typename Char , FMT_ENABLE_IF(!is_static_named_arg< T >::value) >
FMT_CONSTEXPR void	init_static_named_arg (named_arg_info< Char > *, int &arg_index, int &)
template<typename Char , typename T , typename U = remove_const_t<T>>
auto	has_formatter_impl (T *p, buffered_context< Char > *ctx=nullptr) -> decltype(formatter< U, Char >().format(*p, *ctx), std::true_type())
template<typename Char >
auto	has_formatter_impl (...) -> std::false_type
template<typename T , typename Char >
constexpr auto	has_formatter () -> bool
template<typename Char , FMT_ENABLE_IF(std::is_integral< Char >::value) >
constexpr auto	to_ascii (Char c) -> char
template<typename Char >
FMT_CONSTEXPR auto	code_point_length (const Char *begin) -> int
template<typename Char >
FMT_CONSTEXPR auto	parse_nonnegative_int (const Char *&begin, const Char *end, int error_value) noexcept -> int
FMT_CONSTEXPR auto	parse_align (char c) -> align
template<typename Char >
constexpr auto	is_name_start (Char c) -> bool
template<typename Char , typename Handler >
FMT_CONSTEXPR auto	parse_arg_id (const Char *begin, const Char *end, Handler &&handler) -> const Char *
template<typename Char >
FMT_CONSTEXPR auto	parse_dynamic_spec (const Char *begin, const Char *end, int &value, arg_ref< Char > &ref, parse_context< Char > &ctx) -> parse_dynamic_spec_result< Char >
template<typename Char >
FMT_CONSTEXPR auto	parse_width (const Char *begin, const Char *end, format_specs &specs, arg_ref< Char > &width_ref, parse_context< Char > &ctx) -> const Char *
template<typename Char >
FMT_CONSTEXPR auto	parse_precision (const Char *begin, const Char *end, format_specs &specs, arg_ref< Char > &precision_ref, parse_context< Char > &ctx) -> const Char *
template<typename Char >
FMT_CONSTEXPR auto	parse_format_specs (const Char *begin, const Char *end, dynamic_format_specs< Char > &specs, parse_context< Char > &ctx, type arg_type) -> const Char *
template<typename Char , typename Handler >
FMT_CONSTEXPR FMT_INLINE auto	parse_replacement_field (const Char *begin, const Char *end, Handler &&handler) -> const Char *
template<typename Char , typename Handler >
FMT_CONSTEXPR void	parse_format_string (basic_string_view< Char > fmt, Handler &&handler)
FMT_CONSTEXPR auto	check_char_specs (const format_specs &specs) -> bool
template<typename T , typename Char >
FMT_CONSTEXPR auto	invoke_parse (parse_context< Char > &ctx) -> const Char *
template<typename T , typename InputIt , typename OutputIt , FMT_ENABLE_IF(is_back_insert_iterator< OutputIt >::value && has_back_insert_iterator_container_append< OutputIt, InputIt >::value) >
FMT_CONSTEXPR20 auto	copy (InputIt begin, InputIt end, OutputIt out) -> OutputIt
template<typename T , typename InputIt , typename OutputIt , FMT_ENABLE_IF(!(is_back_insert_iterator< OutputIt >::value &&(has_back_insert_iterator_container_append< OutputIt, InputIt >::value|| has_back_insert_iterator_container_insert_at_end< OutputIt, InputIt >::value))) >
FMT_CONSTEXPR auto	copy (InputIt begin, InputIt end, OutputIt out) -> OutputIt
template<typename T , typename V , typename OutputIt >
FMT_CONSTEXPR auto	copy (basic_string_view< V > s, OutputIt out) -> OutputIt
template<typename T , typename OutputIt , FMT_ENABLE_IF(!is_buffer_appender< OutputIt >::value) >
auto	get_buffer (OutputIt out) -> iterator_buffer< OutputIt, T >
template<typename Buf , typename OutputIt >
auto	get_iterator (Buf &buf, OutputIt) -> decltype(buf.out())
template<typename T , typename OutputIt >
auto	get_iterator (buffer< T > &, OutputIt out) -> OutputIt
template<typename >
constexpr auto	encode_types () -> unsigned long long
template<typename Context , typename First , typename... T>
constexpr auto	encode_types () -> unsigned long long
template<typename Context , typename... T, size_t NUM_ARGS = sizeof...(T)>
constexpr auto	make_descriptor () -> unsigned long long
template<typename T = int>
FMT_CONSTEXPR auto	is_locking () -> bool
template<typename T1 , typename T2 , typename... Tail>
FMT_CONSTEXPR auto	is_locking () -> bool
void	vprint_mojibake (FILE *, string_view, const format_args &, bool)
template<typename Char >
void	write_buffer (std::basic_ostream< Char > &os, buffer< Char > &buf)
auto	write_loc (basic_appender< wchar_t > out, loc_value value, const format_specs &specs, locale_ref loc) -> bool
template<typename Char >
void	vformat_to (buffer< Char > &buf, basic_string_view< Char > fmt, basic_format_args< buffered_context< Char > > args, locale_ref loc={})

Variables
constexpr FMT_INLINE_VARIABLE uint32_t	invalid_code_point = ~uint32_t()
struct detail::fixed_string	deallocate

Detailed Description

Converts a string literal into a format string that will be parsed at compile time and converted into efficient formatting code.

Requires support for class types in constant template parameters (a C++20 feature).

Example:

// Converts 42 into std::string using the most efficient method and no // runtime format string processing. using namespace fmt::literals; std::string s = fmt::format("{}"_cf, 42);

Typedef Documentation

arg_t

template<typename Context , int NUM_ARGS>

using detail::arg_t

Initial value:

 conditional_t<NUM_ARGS <= max_packed_args, value<Context>,
                            basic_format_arg<Context>>

char_t

template<typename S , typename V = decltype(detail::to_string_view(std::declval<S>()))>

using detail::char_t = typename V::value_type

String's character (code unit) type. detail:: is intentional to prevent ADL.

convert_float_result

template<typename T , bool doublish = num_bits<T>() == num_bits<double>()>

using detail::convert_float_result

Initial value:

 
    conditional_t<std::is_same<T, float>::value || doublish, double, T>

file_ref

using detail::file_ref = decltype(get_file(static_cast<FILE*>(nullptr), 0))

format_as_member_result

template<typename T >

using detail::format_as_member_result

Initial value:

 
    remove_cvref_t<decltype(formatter<T>::format_as(std::declval<const T&>()))>

format_as_result

template<typename T >

using detail::format_as_result

Initial value:

 
    remove_cvref_t<decltype(format_as(std::declval<const T&>()))>

format_func

using detail::format_func = void (*)(detail::buffer<char>&, int, const char*)

format_string_char_t

template<typename S >

using detail::format_string_char_t = typename format_string_char<S>::type

fp

using detail::fp = basic_fp<unsigned long long>

index_sequence

template<size_t... N>

using detail::index_sequence = integer_sequence<size_t, N...>

is_builtin

template<typename T >

using detail::is_builtin

Initial value:

 
    bool_constant<std::is_same<T, int>::value || FMT_BUILTIN_TYPES>

is_exotic_char

template<typename T >

using detail::is_exotic_char = bool_constant<!std::is_same<T, char>::value>

is_float128

template<typename T >

using detail::is_float128 = std::is_same<T, float128>

is_integer

template<typename T >

using detail::is_integer

Initial value:

 
    bool_constant<is_integral<T>::value && !std::is_same<T, bool>::value &&
                  !std::is_same<T, char>::value &&
                  !std::is_same<T, wchar_t>::value>

is_signed

template<typename T >

using detail::is_signed

Initial value:

 
    std::integral_constant<bool, std::numeric_limits<T>::is_signed ||
                                     std::is_same<T, int128_opt>::value>

is_similar_arithmetic_type

template<typename T , typename U >

using detail::is_similar_arithmetic_type

Initial value:

 
    bool_constant<(std::is_integral<T>::value && std::is_integral<U>::value) ||
                  (std::is_floating_point<T>::value &&
                   std::is_floating_point<U>::value)>

long_type

using detail::long_type = conditional_t<long_short, int, long long>

make_index_sequence

template<size_t N>

using detail::make_index_sequence = make_integer_sequence<size_t, N>

mapped_t

template<typename T , typename Char >

using detail::mapped_t = decltype(detail::type_mapper<Char>::map(std::declval<T&>()))

mapped_type_constant

template<typename T , typename Char = char>

using detail::mapped_type_constant = type_constant<mapped_t<T, Char>, Char>

maybe_const_range

template<typename R >

using detail::maybe_const_range

Initial value:

 
    conditional_t<has_const_begin_end<R>::value, const R, R>

range_format_constant

template<range_format K>

using detail::range_format_constant = std::integral_constant<range_format, K>

range_formatter_type

template<typename Char , typename Element >

using detail::range_formatter_type = formatter<remove_cvref_t<Element>, Char>

range_reference_type

template<typename Range >

using detail::range_reference_type

Initial value:

 
    decltype(*detail::range_begin(std::declval<Range&>()))

reserve_iterator

template<typename OutputIt >

using detail::reserve_iterator

Initial value:

 
    remove_reference_t<decltype(reserve(std::declval<OutputIt&>(), 0))>

stored_type_constant

template<typename T , typename Context , type TYPE = mapped_type_constant<T, typename Context::char_type>::value>

using detail::stored_type_constant

Initial value:

 std::integral_constant<
    type, Context::builtin_types || TYPE == type::int_type ? TYPE
                                                           : type::custom_type>

tuple_index_sequence

template<typename T >

using detail::tuple_index_sequence = make_index_sequence<std::tuple_size<T>::value>

uint128_t

using detail::uint128_t = conditional_t<FMT_USE_INT128, uint128_opt, uint128_fallback>

uint32_or_64_or_128_t

template<typename T >

using detail::uint32_or_64_or_128_t

Initial value:

 
    conditional_t<num_bits<T>() <= 32 && !FMT_REDUCE_INT_INSTANTIATIONS,
                  uint32_t,
                  conditional_t<num_bits<T>() <= 64, uint64_t, uint128_t>>

uint64_or_128_t

template<typename T >

using detail::uint64_or_128_t = conditional_t<num_bits<T>() <= 64, uint64_t, uint128_t>

uintptr_t

using detail::uintptr_t = uint128_t

ulong_type

using detail::ulong_type = conditional_t<long_short, unsigned, unsigned long long>

uncvref_type

template<typename Range >

using detail::uncvref_type = remove_cvref_t<range_reference_type<Range>>

unsigned_char

template<typename Char >

using detail::unsigned_char = conditional_t<sizeof(Char) == 1, unsigned char, unsigned>

use_formatter

template<typename T , typename U = remove_const_t<T>>

using detail::use_formatter

Initial value:

 
    bool_constant<(std::is_class<T>::value || std::is_enum<T>::value ||
                   std::is_union<T>::value || std::is_array<T>::value) &&
                  !has_to_string_view<T>::value && !is_named_arg<T>::value &&
                  !use_format_as<T>::value && !use_format_as_member<U>::value>

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
is_utf8_enabled

anonymous enum

anonymous enum

Enumerator
use_utf8

anonymous enum

anonymous enum

Enumerator
sint_set
uint_set
bool_set
char_set
float_set
string_set
cstring_set
pointer_set

anonymous enum

anonymous enum

Enumerator
long_short

anonymous enum

anonymous enum

Enumerator
packed_arg_bits

anonymous enum

anonymous enum

Enumerator
max_packed_args

anonymous enum

anonymous enum : unsigned long long

Enumerator
is_unpacked_bit

anonymous enum

anonymous enum : unsigned long long

Enumerator
has_named_args_bit

dragon

enum detail::dragon

Enumerator
predecessor_closer
fixup
fixed

int128_opt

enum class detail::int128_opt

strong

numeric_system

enum class detail::numeric_system

strong

Enumerator
standard
alternative

pad_type

enum class detail::pad_type

strong

Enumerator
zero
none
space

state

enum class detail::state

strong

Enumerator
start
align
sign
hash
zero
width
precision
locale

to_utf8_error_policy

enum class detail::to_utf8_error_policy

strong

Enumerator
abort
replace

type

enum class detail::type

strong

Enumerator
none_type
int_type
uint_type
long_long_type
ulong_long_type
int128_type
uint128_type
bool_type
char_type
last_integer_type
float_type
double_type
long_double_type
last_numeric_type
cstring_type
string_type
pointer_type
custom_type

uint128_opt

enum class detail::uint128_opt

strong

Function Documentation

abort_fuzzing_if()

FMT_CONSTEXPR void detail::abort_fuzzing_if ( bool condition )

inline

adjust_precision()

FMT_CONSTEXPR20 void detail::adjust_precision ( int & precision, int exp10 )

inline

assert_fail()

FMT_NORETURN FMT_API void detail::assert_fail	(	const char *	file,
		int	line,
		const char *	message )

assume()

FMT_INLINE void detail::assume

(

bool

condition

)

base_iterator() [1/2]

template<typename Iterator >

auto detail::base_iterator ( Iterator , Iterator it ) -> Iterator

constexpr

base_iterator() [2/2]

template<typename OutputIt , FMT_ENABLE_IF(is_back_insert_iterator< OutputIt >::value && is_contiguous< typename OutputIt::container >::value) >

auto detail::base_iterator ( OutputIt it, typename OutputIt::container_type::value_type *  ) -> OutputIt

inline

bit_cast() [1/2]

template<typename To , typename From , FMT_ENABLE_IF(sizeof(To)==sizeof(From)) >

FMT_CONSTEXPR20 auto detail::bit_cast

(

const From &

from

)

-> To

bit_cast() [2/2]

template<typename To , typename From , FMT_ENABLE_IF(sizeof(To) > sizeof(From)) >

auto detail::bit_cast ( const From & from ) -> To

inline

check_char_specs()

FMT_CONSTEXPR auto detail::check_char_specs ( const format_specs & specs ) -> bool

inline

check_for_duplicate()

template<typename Char >

FMT_CONSTEXPR void detail::check_for_duplicate	(	named_arg_info< Char > *	named_args,
		int	named_arg_index,
		basic_string_view< Char >	arg_name )

code_point_length()

template<typename Char >

FMT_CONSTEXPR auto detail::code_point_length

(

const Char *

begin

)

-> int

compare()

template<typename Char >

FMT_CONSTEXPR auto detail::compare	(	const Char *	s1,
		const Char *	s2,
		size_t	n ) -> int

compile_string_to_view() [1/2]

template<typename Char >

FMT_EXPORT constexpr auto detail::compile_string_to_view ( basic_string_view< Char > s ) -> basic_string_view<Char>

constexpr

compile_string_to_view() [2/2]

template<typename Char , size_t N>

FMT_EXPORT constexpr auto detail::compile_string_to_view ( const Char(&) s[N] ) -> basic_string_view<Char>

constexpr

compute_exp_size()

FMT_CONSTEXPR auto detail::compute_exp_size ( int exp ) -> int

inline

const_check()

template<typename T >

FMT_ALWAYS_INLINE constexpr auto detail::const_check ( T val ) -> T

constexpr

convert_arg()

template<typename T , typename Context , typename Char >

void detail::convert_arg	(	basic_format_arg< Context > &	arg,
		Char	type )

convert_float()

template<typename T >

auto detail::convert_float ( T value ) -> convert_float_result<T>

constexpr

copy() [1/3]

template<typename T , typename V , typename OutputIt >

FMT_CONSTEXPR auto detail::copy	(	basic_string_view< V >	s,
		OutputIt	out ) -> OutputIt

copy() [2/3]

template<typename T , typename InputIt , typename OutputIt , FMT_ENABLE_IF(is_back_insert_iterator< OutputIt >::value && has_back_insert_iterator_container_append< OutputIt, InputIt >::value) >

FMT_CONSTEXPR20 auto detail::copy	(	InputIt	begin,
		InputIt	end,
		OutputIt	out ) -> OutputIt

copy() [3/3]

template<typename T , typename InputIt , typename OutputIt , FMT_ENABLE_IF(!(is_back_insert_iterator< OutputIt >::value &&(has_back_insert_iterator_container_append< OutputIt, InputIt >::value|| has_back_insert_iterator_container_insert_at_end< OutputIt, InputIt >::value))) >

FMT_CONSTEXPR auto detail::copy	(	InputIt	begin,
		InputIt	end,
		OutputIt	out ) -> OutputIt

copy_noinline()

template<typename OutChar , typename InputIt , typename OutputIt >

FMT_CONSTEXPR FMT_NOINLINE auto detail::copy_noinline	(	InputIt	begin,
		InputIt	end,
		OutputIt	out ) -> OutputIt

copy_unit() [1/2]

template<typename Char , typename OutputIt >

auto detail::copy_unit	(	string_view	unit,
		OutputIt	out,
		Char	) -> OutputIt

copy_unit() [2/2]

template<typename OutputIt >

auto detail::copy_unit	(	string_view	unit,
		OutputIt	out,
		wchar_t	) -> OutputIt

count() [1/2]

template<bool B = false>

auto detail::count ( ) -> int

constexpr

count() [2/2]

template<bool B1, bool B2, bool... Tail>

auto detail::count ( ) -> int

constexpr

count_digits() [1/3]

template<int BITS, typename UInt >

FMT_CONSTEXPR auto detail::count_digits

(

UInt

n

)

-> int

count_digits() [2/3]

FMT_CONSTEXPR20 auto detail::count_digits ( uint32_t n ) -> int

inline

count_digits() [3/3]

FMT_CONSTEXPR20 auto detail::count_digits ( uint64_t n ) -> int

inline

count_digits_fallback()

template<typename T >

FMT_CONSTEXPR auto detail::count_digits_fallback

(

T

n

)

-> int

count_named_args()

template<typename... T>

auto detail::count_named_args ( ) -> int

constexpr

count_static_named_args()

template<typename... T>

auto detail::count_static_named_args ( ) -> int

constexpr

countl_zero() [1/2]

FMT_CONSTEXPR20 auto detail::countl_zero ( uint32_t n ) -> int

inline

countl_zero() [2/2]

FMT_CONSTEXPR20 auto detail::countl_zero ( uint64_t n ) -> int

inline

countl_zero_fallback()

template<typename UInt >

FMT_CONSTEXPR20 auto detail::countl_zero_fallback ( UInt n ) -> int

inline

deallocate()

template<typename T , bool = is_floating_point<T>::value>

detail::is_fast_float bool_constant T detail::deallocate	(	T *	p,
		size_t	)

decimal_point() [1/2]

template<typename Char >

auto detail::decimal_point ( locale_ref loc ) -> Char

inline

decimal_point() [2/2]

template<>

auto detail::decimal_point ( locale_ref loc ) -> wchar_t

inline

decimal_point_impl() [1/3]

template<typename Char >

FMT_FUNC auto detail::decimal_point_impl

(

locale_ref

loc

)

-> Char

decimal_point_impl() [2/3]

template<typename Char >

template FMT_API auto detail::decimal_point_impl

(

locale_ref

loc

)

-> Char

decimal_point_impl() [3/3]

template FMT_API auto detail::decimal_point_impl ( locale_ref ) -> char

extern

digits10()

template<typename Int >

auto detail::digits10 ( ) -> int

constexprnoexcept

digits10< int128_opt >()

template<>

auto detail::digits10< int128_opt > ( ) -> int

constexprnoexcept

digits10< uint128_t >()

template<>

auto detail::digits10< uint128_t > ( ) -> int

constexprnoexcept

digits2()

auto detail::digits2 ( size_t value ) -> const char*

inline

display_width_of()

FMT_CONSTEXPR auto detail::display_width_of ( uint32_t cp ) -> size_t

inlinenoexcept

do_format_base2e()

template<typename Char , typename UInt >

FMT_CONSTEXPR auto detail::do_format_base2e	(	int	base_bits,
		Char *	out,
		UInt	value,
		int	size,
		bool	upper = false ) -> Char*

do_format_decimal()

template<typename Char , typename UInt >

FMT_CONSTEXPR20 auto detail::do_format_decimal	(	Char *	out,
		UInt	value,
		int	size ) -> Char*

do_report_error()

FMT_FUNC void detail::do_report_error ( format_func func, int error_code, const char * message )

noexcept

do_write()

template<typename Char >

void detail::do_write ( buffer< Char > & buf, const std::tm & time, const std::locale & loc, char format, char modifier )

inline

do_write_float()

template<typename Char , typename Grouping , typename OutputIt , typename DecimalFP >

FMT_CONSTEXPR20 auto detail::do_write_float	(	OutputIt	out,
		const DecimalFP &	f,
		const format_specs &	specs,
		sign	s,
		int	exp_upper,
		locale_ref	loc ) -> OutputIt

duration_cast()

template<typename To , typename FromRep , typename FromPeriod , FMT_ENABLE_IF(std::is_integral< FromRep >::value && std::is_integral< typename To::rep >::value) >

auto detail::duration_cast

(

std::chrono::duration< FromRep, FromPeriod >

from

)

-> To

encode_types() [1/2]

template<typename >

auto detail::encode_types ( ) -> unsigned long long

constexpr

encode_types() [2/2]

template<typename Context , typename First , typename... T>

auto detail::encode_types ( ) -> unsigned long long

constexpr

equal2() [1/2]

template<typename Char >

FMT_END_EXPORT auto detail::equal2	(	const Char *	lhs,
		const char *	rhs ) -> bool

equal2() [2/2]

auto detail::equal2 ( const char * lhs, const char * rhs ) -> bool

inline

exp_upper()

template<typename T >

FMT_CONSTEVAL auto detail::exp_upper

(

)

-> int

exponent_bias()

template<typename Float >

auto detail::exponent_bias ( ) -> int

constexpr

exponent_mask()

template<typename Float >

auto detail::exponent_mask ( ) -> typename dragonbox::float_info<Float>::carrier_uint

constexpr

fill()

template<typename Char , typename OutputIt >

FMT_CONSTEXPR FMT_NOINLINE auto detail::fill	(	OutputIt	it,
		size_t	n,
		const basic_specs &	specs ) -> OutputIt

fill_n() [1/2]

template<typename OutputIt , typename Size , typename T >

FMT_CONSTEXPR auto detail::fill_n	(	OutputIt	out,
		Size	count,
		const T &	value ) -> OutputIt

fill_n() [2/2]

template<typename T , typename Size >

FMT_CONSTEXPR20 auto detail::fill_n	(	T *	out,
		Size	count,
		char	value ) -> T*

find()

template<bool IS_CONSTEXPR, typename T , typename Ptr = const T*>

FMT_CONSTEXPR auto detail::find	(	Ptr	first,
		Ptr	last,
		T	value,
		Ptr &	out ) -> bool

find< false, char >()

template<>

auto detail::find< false, char > ( const char * first, const char * last, char value, const char *& out ) -> bool

inline

find_escape() [1/2]

template<typename Char >

auto detail::find_escape	(	const Char *	begin,
		const Char *	end ) -> find_escape_result<Char>

find_escape() [2/2]

auto detail::find_escape ( const char * begin, const char * end ) -> find_escape_result<char>

inline

first()

template<typename T , typename... Tail>

auto detail::first ( const T & value, const Tail & ... ) -> const T&

constexpr

flockfile()

template<typename F >

auto detail::flockfile

(

F *

f

)

-> decltype(_lock_file(f))

FMT_TYPE_CONSTANT() [1/14]

detail::FMT_TYPE_CONSTANT	(	basic_string_view< Char >	,
		string_type	)

FMT_TYPE_CONSTANT() [2/14]

detail::FMT_TYPE_CONSTANT	(	bool	,
		bool_type	)

FMT_TYPE_CONSTANT() [3/14]

detail::FMT_TYPE_CONSTANT	(	Char	,
		char_type	)

FMT_TYPE_CONSTANT() [4/14]

detail::FMT_TYPE_CONSTANT	(	const Char *	,
		cstring_type	)

FMT_TYPE_CONSTANT() [5/14]

detail::FMT_TYPE_CONSTANT	(	const void *	,
		pointer_type	)

FMT_TYPE_CONSTANT() [6/14]

detail::FMT_TYPE_CONSTANT	(	double	,
		double_type	)

FMT_TYPE_CONSTANT() [7/14]

detail::FMT_TYPE_CONSTANT	(	float	,
		float_type	)

FMT_TYPE_CONSTANT() [8/14]

detail::FMT_TYPE_CONSTANT	(	int	,
		int_type	)

FMT_TYPE_CONSTANT() [9/14]

detail::FMT_TYPE_CONSTANT	(	int128_opt	,
		int128_type	)

FMT_TYPE_CONSTANT() [10/14]

detail::FMT_TYPE_CONSTANT	(	long double	,
		long_double_type	)

FMT_TYPE_CONSTANT() [11/14]

detail::FMT_TYPE_CONSTANT	(	long long	,
		long_long_type	)

FMT_TYPE_CONSTANT() [12/14]

detail::FMT_TYPE_CONSTANT	(	uint128_opt	,
		uint128_type	)

FMT_TYPE_CONSTANT() [13/14]

detail::FMT_TYPE_CONSTANT	(	unsigned long long	,
		ulong_long_type	)

FMT_TYPE_CONSTANT() [14/14]

detail::FMT_TYPE_CONSTANT	(	unsigned	,
		uint_type	)

for_each() [1/2]

template<typename Tuple , typename F , size_t... Is>

FMT_CONSTEXPR void detail::for_each	(	index_sequence< Is... >	,
		Tuple &&	t,
		F &&	f )

for_each() [2/2]

template<typename Tuple , typename F >

FMT_CONSTEXPR void detail::for_each	(	Tuple &&	t,
		F &&	f )

for_each2() [1/2]

template<typename Tuple1 , typename Tuple2 , typename F , size_t... Is>

void detail::for_each2	(	index_sequence< Is... >	,
		Tuple1 &&	t1,
		Tuple2 &&	t2,
		F &&	f )

for_each2() [2/2]

template<typename Tuple1 , typename Tuple2 , typename F >

void detail::for_each2	(	Tuple1 &&	t1,
		Tuple2 &&	t2,
		F &&	f )

for_each_codepoint()

template<typename F >

FMT_CONSTEXPR void detail::for_each_codepoint	(	string_view	s,
		F	f )

format_base2e() [1/2]

template<typename Char , typename UInt >

FMT_CONSTEXPR auto detail::format_base2e	(	int	base_bits,
		Char *	out,
		UInt	value,
		int	num_digits,
		bool	upper = false ) -> Char*

format_base2e() [2/2]

template<typename Char , typename OutputIt , typename UInt , FMT_ENABLE_IF(is_back_insert_iterator< OutputIt >::value) >

FMT_CONSTEXPR auto detail::format_base2e ( int base_bits, OutputIt out, UInt value, int num_digits, bool upper = false ) -> OutputIt

inline

format_decimal() [1/2]

template<typename Char , typename UInt >

FMT_CONSTEXPR FMT_INLINE auto detail::format_decimal	(	Char *	out,
		UInt	value,
		int	num_digits ) -> Char*

format_decimal() [2/2]

template<typename Char , typename UInt , typename OutputIt , FMT_ENABLE_IF(!std::is_pointer< remove_cvref_t< OutputIt > >::value) >

FMT_CONSTEXPR auto detail::format_decimal	(	OutputIt	out,
		UInt	value,
		int	num_digits ) -> OutputIt

format_dragon()

FMT_CONSTEXPR20 void detail::format_dragon ( basic_fp< uint128_t > value, unsigned flags, int num_digits, buffer< char > & buf, int & exp10 )

inline

format_duration_unit()

template<typename Char , typename Period , typename OutputIt >

auto detail::format_duration_unit

(

OutputIt

out

)

-> OutputIt

format_duration_value()

template<typename Char , typename Rep , typename OutputIt , FMT_ENABLE_IF(std::is_integral< Rep >::value) >

auto detail::format_duration_value	(	OutputIt	out,
		Rep	val,
		int	precision ) -> OutputIt

format_error_code()

FMT_FUNC void detail::format_error_code ( detail::buffer< char > & out, int error_code, string_view message )

noexcept

format_float()

template<typename Float >

FMT_CONSTEXPR20 auto detail::format_float	(	Float	value,
		int	precision,
		const format_specs &	specs,
		bool	binary32,
		buffer< char > &	buf ) -> int

format_hexfloat()

template<typename Float , FMT_ENABLE_IF(!is_double_double< Float >::value) >

FMT_CONSTEXPR20 void detail::format_hexfloat	(	Float	value,
		format_specs	specs,
		buffer< char > &	buf )

fractional_part_rounding_thresholds()

auto detail::fractional_part_rounding_thresholds ( int index ) -> uint32_t

constexpr

funlockfile()

template<typename F >

auto detail::funlockfile

(

F *

f

)

-> decltype(_unlock_file(f))

fwrite_all()

void detail::fwrite_all ( const void * ptr, size_t count, FILE * stream )

inline

get_buffer()

template<typename T , typename OutputIt , FMT_ENABLE_IF(!is_buffer_appender< OutputIt >::value) >

auto detail::get_buffer

(

OutputIt

out

)

-> iterator_buffer<OutputIt, T>

get_classic_locale()

auto detail::get_classic_locale ( ) -> const std::locale&

inline

get_container()

template<typename OutputIt >

FMT_CONSTEXPR20 auto detail::get_container ( OutputIt it ) -> typename OutputIt::container_type&

inline

get_file() [1/2]

template<typename F , FMT_ENABLE_IF(sizeof(F::_p) !=0 &&!FMT_USE_FALLBACK_FILE) >

auto detail::get_file ( F * f, int  ) -> apple_file<F>

inline

get_file() [2/2]

auto detail::get_file ( FILE * f, ... ) -> fallback_file<FILE>

inline

get_iterator() [1/2]

template<typename Buf , typename OutputIt >

auto detail::get_iterator	(	Buf &	buf,
		OutputIt	) -> decltype(buf.out())

get_iterator() [2/2]

template<typename T , typename OutputIt >

auto detail::get_iterator	(	buffer< T > &	,
		OutputIt	out ) -> OutputIt

get_milliseconds()

template<typename Rep , typename Period , FMT_ENABLE_IF(std::is_integral< Rep >::value) >

auto detail::get_milliseconds ( std::chrono::duration< Rep, Period > d ) -> std::chrono::duration<Rep, std::milli>

inline

get_significand_size() [1/2]

auto detail::get_significand_size ( const big_decimal_fp & f ) -> int

constexpr

get_significand_size() [2/2]

template<typename T >

auto detail::get_significand_size ( const dragonbox::decimal_fp< T > & f ) -> int

inline

get_units()

template<typename Period >

FMT_CONSTEXPR auto detail::get_units ( ) -> const char*

inline

getc_unlocked()

template<typename F >

auto detail::getc_unlocked

(

F *

f

)

-> decltype(_fgetc_nolock(f))

getsign()

template<typename Char >

auto detail::getsign ( sign s ) -> Char

constexpr

gmtime_r()

auto detail::gmtime_r ( ... ) -> null<>

inline

gmtime_s()

auto detail::gmtime_s ( ... ) -> null<>

inline

handle_dynamic_spec()

template<typename Context >

FMT_CONSTEXPR void detail::handle_dynamic_spec	(	arg_id_kind	kind,
		int &	value,
		const arg_ref< typename Context::char_type > &	ref,
		Context &	ctx )

has_formatter()

template<typename T , typename Char >

auto detail::has_formatter ( ) -> bool

constexpr

has_formatter_impl() [1/2]

template<typename Char >

auto detail::has_formatter_impl

(

...

)

-> std::false_type

has_formatter_impl() [2/2]

template<typename Char , typename T , typename U = remove_const_t<T>>

auto detail::has_formatter_impl	(	T *	p,
		buffered_context< Char > *	ctx = nullptr ) -> decltype(formatter< U, Char >().format(*p, *ctx), std::true_type())

has_implicit_bit()

template<typename Float >

auto detail::has_implicit_bit ( ) -> bool

constexpr

ignore_unused()

template<typename... T>

FMT_CONSTEXPR void detail::ignore_unused

(

const T &

...

)

in()

auto detail::in ( type t, int set ) -> bool

constexpr

init_named_arg()

template<typename Char , typename T , FMT_ENABLE_IF(!is_named_arg< T >::value) >

void detail::init_named_arg	(	named_arg_info< Char > *	named_args,
		int &	arg_index,
		int &	named_arg_index,
		const T &	arg )

init_static_named_arg()

template<typename T , typename Char , FMT_ENABLE_IF(!is_static_named_arg< T >::value) >

FMT_CONSTEXPR void detail::init_static_named_arg	(	named_arg_info< Char > *	named_args,
		int &	arg_index,
		int &	named_arg_index )

invoke_parse()

template<typename T , typename Char >

FMT_CONSTEXPR auto detail::invoke_parse

(

parse_context< Char > &

ctx

)

-> const Char*

is_arithmetic_type()

auto detail::is_arithmetic_type ( type t ) -> bool

constexpr

is_big_endian()

auto detail::is_big_endian ( ) -> bool

inline

is_constant_evaluated()

auto detail::is_constant_evaluated ( bool default_value = false ) -> bool

constexprnoexcept

is_integral_type()

auto detail::is_integral_type ( type t ) -> bool

constexpr

is_locking() [1/2]

template<typename T = int>

FMT_CONSTEXPR auto detail::is_locking ( ) -> bool

inline

is_locking() [2/2]

template<typename T1 , typename T2 , typename... Tail>

FMT_CONSTEXPR auto detail::is_locking ( ) -> bool

inline

is_name_start()

template<typename Char >

auto detail::is_name_start ( Char c ) -> bool

constexpr

is_negative()

template<typename T , FMT_ENABLE_IF(is_signed< T >::value) >

auto detail::is_negative ( T value ) -> bool

constexpr

is_printable() [1/2]

auto detail::is_printable ( uint16_t x, const singleton * singletons, size_t singletons_size, const unsigned char * singleton_lowers, const unsigned char * normal, size_t normal_size ) -> bool

inline

is_printable() [2/2]

FMT_FUNC auto detail::is_printable

(

uint32_t

cp

)

-> bool

isfinite() [1/3]

template<typename T , FMT_ENABLE_IF(is_floating_point< T >::value &&has_isfinite< T >::value) >

FMT_CONSTEXPR20 auto detail::isfinite

(

T

value

)

-> bool

isfinite() [2/3]

template<typename T , FMT_ENABLE_IF(!has_isfinite< T >::value) >

FMT_CONSTEXPR auto detail::isfinite

(

T

value

)

-> bool

isfinite() [3/3]

template<typename T , FMT_ENABLE_IF(std::is_integral< T >::value &&has_isfinite< T >::value) >

auto detail::isfinite ( T ) -> bool

inline

isnan()

template<typename T >

auto detail::isnan ( T value ) -> bool

constexpr

make_arg_formatter()

template<typename Char >

auto detail::make_arg_formatter	(	basic_appender< Char >	iter,
		format_specs &	s ) -> arg_formatter<Char>

make_background_color()

template<typename Char >

FMT_CONSTEXPR auto detail::make_background_color ( color_type background ) -> ansi_color_escape<Char>

noexcept

make_descriptor()

template<typename Context , typename... T, size_t NUM_ARGS = sizeof...(T)>

auto detail::make_descriptor ( ) -> unsigned long long

constexpr

make_emphasis()

template<typename Char >

FMT_CONSTEXPR auto detail::make_emphasis ( emphasis em ) -> ansi_color_escape<Char>

noexcept

make_foreground_color()

template<typename Char >

FMT_CONSTEXPR auto detail::make_foreground_color ( color_type foreground ) -> ansi_color_escape<Char>

noexcept

make_write_int_arg()

template<typename T >

FMT_CONSTEXPR auto detail::make_write_int_arg	(	T	value,
		sign	s ) -> write_int_arg<uint32_or_64_or_128_t<T>>

map() [1/2]

auto detail::map ( int128_opt ) -> monostate

inline

map() [2/2]

auto detail::map ( uint128_opt ) -> monostate

inline

max_value()

template<typename T >

auto detail::max_value ( ) -> T

constexpr

maybe_set_debug_format() [1/2]

template<typename Formatter >

FMT_CONSTEXPR void detail::maybe_set_debug_format	(	Formatter &	,
			... )

maybe_set_debug_format() [2/2]

template<typename Formatter >

FMT_CONSTEXPR auto detail::maybe_set_debug_format	(	Formatter &	f,
		bool	set ) -> decltype(f.set_debug_format(set))

mod()

template<typename T , FMT_ENABLE_IF(std::is_integral< T >::value) >

auto detail::mod ( T x, int y ) -> T

inline

multiply()

FMT_CONSTEXPR auto detail::multiply ( uint64_t lhs, uint64_t rhs ) -> uint64_t

inline

narrow() [1/2]

FMT_ALWAYS_INLINE auto detail::narrow ( const char * s ) -> const char*

constexpr

narrow() [2/2]

template<typename T >

auto detail::narrow ( T * ) -> char*

constexpr

needs_escape()

auto detail::needs_escape ( uint32_t cp ) -> bool

inline

normalize()

template<int SHIFT = 0, typename F >

FMT_CONSTEXPR auto detail::normalize

(

basic_fp< F >

value

)

-> basic_fp<F>

num_bits()

template<typename T >

auto detail::num_bits ( ) -> int

constexpr

num_bits< int128_opt >()

template<>

auto detail::num_bits< int128_opt > ( ) -> int

constexpr

num_bits< uint128_fallback >()

template<>

auto detail::num_bits< uint128_fallback > ( ) -> int

constexpr

num_bits< uint128_opt >()

template<>

auto detail::num_bits< uint128_opt > ( ) -> int

constexpr

num_significand_bits()

template<typename Float >

auto detail::num_significand_bits ( ) -> int

constexpr

operator!=()

friend auto detail::operator!= ( allocator , allocator  ) -> bool

constexprnoexcept

operator*()

FMT_CONSTEXPR auto detail::operator* ( fp x, fp y ) -> fp

inline

operator==() [1/2]

friend auto detail::operator== ( allocator , allocator  ) -> bool

constexprnoexcept

operator==() [2/2]

template<typename F >

auto detail::operator== ( basic_fp< F > x, basic_fp< F > y ) -> bool

inline

parse_align() [1/2]

FMT_CONSTEXPR auto detail::parse_align ( char c ) -> align

inline

parse_align() [2/2]

template<typename Char >

FMT_CONSTEXPR auto detail::parse_align	(	const Char *	begin,
		const Char *	end,
		format_specs &	specs ) -> const Char*

parse_arg_id()

template<typename Char , typename Handler >

FMT_CONSTEXPR auto detail::parse_arg_id	(	const Char *	begin,
		const Char *	end,
		Handler &&	handler ) -> const Char*

parse_chrono_format()

template<typename Char , typename Handler >

FMT_CONSTEXPR auto detail::parse_chrono_format	(	const Char *	begin,
		const Char *	end,
		Handler &&	handler ) -> const Char*

parse_dynamic_spec()

template<typename Char >

FMT_CONSTEXPR auto detail::parse_dynamic_spec	(	const Char *	begin,
		const Char *	end,
		int &	value,
		arg_ref< Char > &	ref,
		parse_context< Char > &	ctx ) -> parse_dynamic_spec_result<Char>

parse_flags()

template<typename Char >

void detail::parse_flags	(	format_specs &	specs,
		const Char *&	it,
		const Char *	end )

parse_format_specs()

template<typename Char >

FMT_CONSTEXPR auto detail::parse_format_specs	(	const Char *	begin,
		const Char *	end,
		dynamic_format_specs< Char > &	specs,
		parse_context< Char > &	ctx,
		type	arg_type ) -> const Char*

parse_format_string()

template<typename Char , typename Handler >

FMT_CONSTEXPR void detail::parse_format_string	(	basic_string_view< Char >	fmt,
		Handler &&	handler )

parse_header()

template<typename Char , typename GetArg >

auto detail::parse_header	(	const Char *&	it,
		const Char *	end,
		format_specs &	specs,
		GetArg	get_arg ) -> int

parse_nonnegative_int()

template<typename Char >

FMT_CONSTEXPR auto detail::parse_nonnegative_int ( const Char *& begin, const Char * end, int error_value ) -> int

noexcept

parse_precision()

template<typename Char >

FMT_CONSTEXPR auto detail::parse_precision	(	const Char *	begin,
		const Char *	end,
		format_specs &	specs,
		arg_ref< Char > &	precision_ref,
		parse_context< Char > &	ctx ) -> const Char*

parse_printf_presentation_type()

auto detail::parse_printf_presentation_type ( char c, type t, bool & upper ) -> presentation_type

inline

parse_replacement_field()

template<typename Char , typename Handler >

FMT_CONSTEXPR FMT_INLINE auto detail::parse_replacement_field	(	const Char *	begin,
		const Char *	end,
		Handler &&	handler ) -> const Char*

parse_width()

template<typename Char >

FMT_CONSTEXPR auto detail::parse_width	(	const Char *	begin,
		const Char *	end,
		format_specs &	specs,
		arg_ref< Char > &	width_ref,
		parse_context< Char > &	ctx ) -> const Char*

pow10()

auto detail::pow10 ( std::uint32_t n ) -> long long

constexpr

prefix_append()

FMT_CONSTEXPR void detail::prefix_append ( unsigned & prefix, unsigned value )

inline

print() [1/2]

FMT_API void detail::print	(	FILE *	,
		string_view	)

print() [2/2]

FMT_FUNC void detail::print	(	std::FILE *	f,
		string_view	text )

range_begin() [1/2]

template<typename T , size_t N>

auto detail::range_begin

(

const T(&)

arr[N]

)

-> const T*

range_begin() [2/2]

template<typename T >

auto detail::range_begin

(

T &&

rng

)

-> decltype(static_cast<T&&>(rng).begin())

range_end() [1/2]

template<typename T , size_t N>

auto detail::range_end

(

const T(&)

arr[N]

)

-> const T*

range_end() [2/2]

template<typename T >

auto detail::range_end

(

T &&

rng

)

-> decltype(static_cast<T&&>(rng).end())

reserve() [1/3]

template<typename T >

FMT_CONSTEXPR20 auto detail::reserve ( basic_appender< T > it, size_t n ) -> basic_appender<T>

inline

reserve() [2/3]

template<typename Iterator >

auto detail::reserve ( Iterator & it, size_t  ) -> Iterator&

constexpr

reserve() [3/3]

template<typename OutputIt , FMT_ENABLE_IF(is_back_insert_iterator< OutputIt >::value && is_contiguous< typename OutputIt::container >::value) >

FMT_CONSTEXPR20 auto detail::reserve ( OutputIt it, size_t n ) -> typename OutputIt::value_type*

inline

reset_color()

template<typename Char >

void detail::reset_color ( buffer< Char > & buffer )

inline

rotr() [1/2]

FMT_INLINE auto detail::rotr ( uint32_t n, uint32_t r ) -> uint32_t

noexcept

rotr() [2/2]

FMT_INLINE auto detail::rotr ( uint64_t n, uint32_t r ) -> uint64_t

noexcept

select()

template<bool C, typename T , typename F , FMT_ENABLE_IF(C) >

auto detail::select	(	T	true_value,
		F	false_value ) -> T

set()

auto detail::set ( type rhs ) -> int

constexpr

set_tm_zone()

template<typename T , FMT_ENABLE_IF(has_tm_zone< T >::value) >

auto detail::set_tm_zone	(	T &	time,
		char *	tz ) -> bool

signbit()

template<typename T , FMT_ENABLE_IF(is_floating_point< T >::value) >

FMT_INLINE FMT_CONSTEXPR auto detail::signbit

(

T

value

)

-> bool

thousands_sep() [1/2]

template<typename Char >

auto detail::thousands_sep ( locale_ref loc ) -> thousands_sep_result<Char>

inline

thousands_sep() [2/2]

template<>

auto detail::thousands_sep ( locale_ref loc ) -> thousands_sep_result<wchar_t>

inline

thousands_sep_impl() [1/2]

template<typename Char >

FMT_FUNC auto detail::thousands_sep_impl

(

locale_ref

loc

)

-> thousands_sep_result<Char>

thousands_sep_impl() [2/2]

template<typename Char >

FMT_API auto detail::thousands_sep_impl

(

locale_ref

loc

)

-> thousands_sep_result< Char >

thousands_sep_impl< char >()

FMT_BEGIN_EXPORT template FMT_API auto detail::thousands_sep_impl< char > ( locale_ref ) -> thousands_sep_result< char >

extern

thousands_sep_impl< wchar_t >()

template FMT_API auto detail::thousands_sep_impl< wchar_t > ( locale_ref ) -> thousands_sep_result< wchar_t >

extern

throw_duration_error()

FMT_NORETURN void detail::throw_duration_error ( )

inline

tm_mon_full_name()

auto detail::tm_mon_full_name ( int mon ) -> const char*

inline

tm_mon_short_name()

auto detail::tm_mon_short_name ( int mon ) -> const char*

inline

tm_wday_full_name()

auto detail::tm_wday_full_name ( int wday ) -> const char*

inline

tm_wday_short_name()

auto detail::tm_wday_short_name ( int wday ) -> const char*

inline

to_ascii()

template<typename Char , FMT_ENABLE_IF(std::is_integral< Char >::value) >

auto detail::to_ascii ( Char c ) -> char

constexpr

to_nonnegative_int()

template<typename T , typename Int , FMT_ENABLE_IF(std::is_integral< T >::value) >

auto detail::to_nonnegative_int ( T value, Int upper ) -> Int

inline

to_pointer() [1/3]

template<typename T >

FMT_CONSTEXPR20 auto detail::to_pointer	(	basic_appender< T >	it,
		size_t	n ) -> T*

to_pointer() [2/3]

template<typename T , typename OutputIt >

auto detail::to_pointer ( OutputIt , size_t  ) -> T*

constexpr

to_pointer() [3/3]

template<typename T >

FMT_CONSTEXPR auto detail::to_pointer	(	T *&	ptr,
		size_t	n ) -> T*

to_string_view() [1/3]

template<typename Char >

auto detail::to_string_view ( basic_string_view< Char > s ) -> basic_string_view<Char>

constexpr

to_string_view() [2/3]

template<typename Char , FMT_ENABLE_IF(is_code_unit< Char >::value) >

auto detail::to_string_view ( const Char * s ) -> basic_string_view<Char>

constexpr

to_string_view() [3/3]

template<typename T , FMT_ENABLE_IF(is_std_string_like< T >::value) >

auto detail::to_string_view ( const T & s ) -> basic_string_view<typename T::value_type>

constexpr

to_time_t()

template<typename Duration >

auto detail::to_time_t

(

sys_time< Duration >

time_point

)

-> std::time_t

to_unsigned()

template<typename Int >

FMT_CONSTEXPR auto detail::to_unsigned

(

Int

value

)

-> make_unsigned_t<Int>

umul128()

FMT_INLINE auto detail::umul128 ( uint64_t x, uint64_t y ) -> uint128_fallback

noexcept

unwrap() [1/2]

template<typename T >

auto detail::unwrap

(

const std::reference_wrapper< T > &

v

)

-> const T&

unwrap() [2/2]

template<typename T >

auto detail::unwrap

(

const T &

v

)

-> const T&

use_facet()

template<typename Facet >

Facet detail::use_facet

(

locale

)

use_fixed()

auto detail::use_fixed ( int exp, int exp_upper ) -> bool

constexpr

utc()

auto detail::utc ( ) -> char*

inline

utf8_decode()

FMT_CONSTEXPR auto detail::utf8_decode ( const char * s, uint32_t * c, int * e ) -> const char*

inline

vformat_to() [1/3]

template<typename Char >

void detail::vformat_to	(	buffer< Char > &	buf,
		basic_string_view< Char >	fmt,
		basic_format_args< buffered_context< Char > >	args,
		locale_ref	loc = {} )

vformat_to() [2/3]

FMT_API void detail::vformat_to	(	buffer< char > &	buf,
		string_view	fmt,
		format_args	args,
		locale_ref	loc )

vformat_to() [3/3]

template<typename Char >

void detail::vformat_to	(	buffer< Char > &	buf,
		text_style	ts,
		basic_string_view< Char >	fmt,
		basic_format_args< buffered_context< Char > >	args )

vprint_mojibake()

void detail::vprint_mojibake ( FILE * , string_view , const format_args & , bool  )

inline

vprintf()

template<typename Char , typename Context >

void detail::vprintf	(	buffer< Char > &	buf,
		basic_string_view< Char >	format,
		basic_format_args< Context >	args )

write() [1/20]

template<typename Char , typename T , FMT_ENABLE_IF(is_integral< T >::value && !std::is_same< T, bool >::value && !std::is_same< T, Char >::value) >

FMT_CONSTEXPR FMT_INLINE auto detail::write	(	basic_appender< Char >	out,
		T	value,
		const format_specs &	specs,
		locale_ref	loc ) -> basic_appender<Char>

write() [2/20]

template<typename Char , typename OutputIt , FMT_ENABLE_IF(std::is_same< Char, char >::value) >

FMT_CONSTEXPR auto detail::write	(	OutputIt	out,
		basic_string_view< Char >	s,
		const format_specs &	specs ) -> OutputIt

write() [3/20]

template<typename Char , typename OutputIt >

FMT_CONSTEXPR auto detail::write	(	OutputIt	out,
		basic_string_view< Char >	s,
		const format_specs &	specs,
		locale_ref	) -> OutputIt

write() [4/20]

template<typename Char , typename OutputIt >

FMT_CONSTEXPR auto detail::write	(	OutputIt	out,
		basic_string_view< Char >	value ) -> OutputIt

write() [5/20]

template<typename Char , typename OutputIt >

FMT_CONSTEXPR auto detail::write	(	OutputIt	out,
		Char	value ) -> OutputIt

write() [6/20]

template<typename Char , typename OutputIt >

FMT_CONSTEXPR auto detail::write	(	OutputIt	out,
		Char	value,
		const format_specs &	specs,
		locale_ref	loc = {} ) -> OutputIt

write() [7/20]

template<typename Char , typename OutputIt >

FMT_CONSTEXPR auto detail::write	(	OutputIt	out,
		const Char *	s,
		const format_specs &	specs,
		locale_ref	) -> OutputIt

write() [8/20]

template<typename Char , typename OutputIt >

FMT_CONSTEXPR20 auto detail::write	(	OutputIt	out,
		const Char *	value ) -> OutputIt

write() [9/20]

template<typename Char , typename OutputIt , FMT_ENABLE_IF(!std::is_same< Char, char >::value) >

auto detail::write	(	OutputIt	out,
		const std::tm &	time,
		const std::locale &	loc,
		char	format,
		char	modifier = 0 ) -> OutputIt

write() [10/20]

template<typename Char , typename OutputIt , typename T , FMT_ENABLE_IF(has_to_string_view< T >::value) >

auto detail::write ( OutputIt out, const T & value ) -> OutputIt

constexpr

write() [11/20]

template<typename Char , typename OutputIt , typename T , FMT_ENABLE_IF(mapped_type_constant< T, Char >::value== type::custom_type && !std::is_fundamental< T >::value) >

FMT_CONSTEXPR auto detail::write	(	OutputIt	out,
		const T &	value ) -> OutputIt

write() [12/20]

template<typename Char , typename OutputIt , typename T , FMT_ENABLE_IF(std::is_same< T, void >::value) >

auto detail::write	(	OutputIt	out,
		const T *	value,
		const format_specs &	specs = {},
		locale_ref	= {} ) -> OutputIt

write() [13/20]

template<typename Char , typename OutputIt >

auto detail::write	(	OutputIt	out,
		monostate	,
		format_specs	= {},
		locale_ref	= {} ) -> OutputIt

write() [14/20]

template<typename Char , typename OutputIt , typename T , FMT_ENABLE_IF(is_integral< T >::value && !std::is_same< T, bool >::value && !std::is_same< T, Char >::value) >

FMT_CONSTEXPR auto detail::write	(	OutputIt	out,
		T	value ) -> OutputIt

write() [15/20]

template<typename Char , typename OutputIt , typename T , FMT_ENABLE_IF(is_fast_float< T >::value) >

FMT_CONSTEXPR20 auto detail::write	(	OutputIt	out,
		T	value ) -> OutputIt

write() [16/20]

template<typename Char , typename OutputIt , typename T , FMT_ENABLE_IF(is_floating_point< T >::value && !is_fast_float< T >::value) >

auto detail::write ( OutputIt out, T value ) -> OutputIt

inline

write() [17/20]

template<typename Char , typename OutputIt , typename T , bool check = std::is_enum<T>::value && !std::is_same<T, Char>::value && mapped_type_constant<T, Char>::value != type::custom_type, FMT_ENABLE_IF(check) >

FMT_CONSTEXPR auto detail::write	(	OutputIt	out,
		T	value ) -> OutputIt

write() [18/20]

template<typename Char , typename OutputIt , typename T , FMT_ENABLE_IF(is_integral< T >::value && !std::is_same< T, bool >::value && !std::is_same< T, Char >::value && !std::is_same< OutputIt, basic_appender< Char > >::value) >

FMT_CONSTEXPR FMT_INLINE auto detail::write	(	OutputIt	out,
		T	value,
		const format_specs &	specs,
		locale_ref	loc ) -> OutputIt

write() [19/20]

template<typename Char , typename OutputIt , typename T , FMT_ENABLE_IF(std::is_same< T, bool >::value) >

FMT_CONSTEXPR auto detail::write	(	OutputIt	out,
		T	value,
		const format_specs &	specs = {},
		locale_ref	= {} ) -> OutputIt

write() [20/20]

template<typename Char , typename OutputIt , typename T , FMT_ENABLE_IF(is_floating_point< T >::value) >

FMT_CONSTEXPR20 auto detail::write	(	OutputIt	out,
		T	value,
		format_specs	specs,
		locale_ref	loc = {} ) -> OutputIt

write2digits()

template<typename Char >

FMT_CONSTEXPR20 FMT_INLINE void detail::write2digits	(	Char *	out,
		size_t	value )

write_buffer()

template<typename Char >

void detail::write_buffer	(	std::basic_ostream< Char > &	os,
		buffer< Char > &	buf )

write_bytes()

template<typename Char , align default_align = align::left, typename OutputIt >

FMT_CONSTEXPR auto detail::write_bytes	(	OutputIt	out,
		string_view	bytes,
		const format_specs &	specs = {} ) -> OutputIt

write_char()

template<typename Char , typename OutputIt >

FMT_CONSTEXPR auto detail::write_char	(	OutputIt	out,
		Char	value,
		const format_specs &	specs ) -> OutputIt

write_codecvt()

template<typename CodeUnit >

void detail::write_codecvt	(	codecvt_result< CodeUnit > &	out,
		string_view	in,
		const std::locale &	loc )

write_codepoint()

template<size_t width, typename Char , typename OutputIt >

auto detail::write_codepoint	(	OutputIt	out,
		char	prefix,
		uint32_t	cp ) -> OutputIt

write_console()

FMT_FUNC auto detail::write_console	(	int	fd,
		string_view	text ) -> bool

write_digit2_separated()

void detail::write_digit2_separated ( char * buf, unsigned a, unsigned b, unsigned c, char sep )

inline

write_encoded_tm_str()

template<typename OutputIt >

auto detail::write_encoded_tm_str	(	OutputIt	out,
		string_view	in,
		const std::locale &	loc ) -> OutputIt

write_escaped_char()

template<typename Char , typename OutputIt >

auto detail::write_escaped_char	(	OutputIt	out,
		Char	v ) -> OutputIt

write_escaped_cp()

template<typename OutputIt , typename Char >

auto detail::write_escaped_cp	(	OutputIt	out,
		const find_escape_result< Char > &	escape ) -> OutputIt

write_escaped_string()

template<typename Char , typename OutputIt >

auto detail::write_escaped_string	(	OutputIt	out,
		basic_string_view< Char >	str ) -> OutputIt

write_exponent()

template<typename Char , typename OutputIt >

FMT_CONSTEXPR auto detail::write_exponent	(	int	exp,
		OutputIt	out ) -> OutputIt

write_fixed()

template<typename Char , typename Grouping , typename OutputIt , typename DecimalFP >

FMT_CONSTEXPR20 auto detail::write_fixed	(	OutputIt	out,
		const DecimalFP &	f,
		int	significand_size,
		Char	decimal_point,
		const format_specs &	specs,
		sign	s,
		locale_ref	loc = {} ) -> OutputIt

write_float()

template<typename Char , typename OutputIt , typename DecimalFP >

FMT_CONSTEXPR20 auto detail::write_float	(	OutputIt	out,
		const DecimalFP &	f,
		const format_specs &	specs,
		sign	s,
		int	exp_upper,
		locale_ref	loc ) -> OutputIt

write_floating_seconds()

template<typename Duration >

void detail::write_floating_seconds	(	memory_buffer &	buf,
		Duration	duration,
		int	num_fractional_digits = -1 )

write_fractional_seconds()

template<typename Char , typename OutputIt , typename Duration >

void detail::write_fractional_seconds	(	OutputIt &	out,
		Duration	d,
		int	precision = -1 )

write_int() [1/2]

template<typename OutputIt , typename UInt , typename Char >

auto detail::write_int	(	OutputIt	out,
		UInt	value,
		unsigned	prefix,
		const format_specs &	specs,
		const digit_grouping< Char > &	grouping ) -> OutputIt

write_int() [2/2]

template<typename Char , typename OutputIt , typename T >

FMT_CONSTEXPR FMT_INLINE auto detail::write_int	(	OutputIt	out,
		write_int_arg< T >	arg,
		const format_specs &	specs ) -> OutputIt

write_int_noinline()

template<typename Char , typename OutputIt , typename T >

FMT_CONSTEXPR FMT_NOINLINE auto detail::write_int_noinline	(	OutputIt	out,
		write_int_arg< T >	arg,
		const format_specs &	specs ) -> OutputIt

write_loc() [1/2]

auto detail::write_loc ( basic_appender< wchar_t > out, loc_value value, const format_specs & specs, locale_ref loc ) -> bool

inline

write_loc() [2/2]

template<typename OutputIt >

auto detail::write_loc ( OutputIt , const loc_value & , const format_specs & , locale_ref  ) -> bool

inline

write_nonfinite()

template<typename Char , typename OutputIt >

FMT_CONSTEXPR20 auto detail::write_nonfinite	(	OutputIt	out,
		bool	isnan,
		format_specs	specs,
		sign	s ) -> OutputIt

write_padded() [1/2]

template<typename Char , align default_align = align::left, typename OutputIt , typename F >

auto detail::write_padded ( OutputIt out, const format_specs & specs, size_t size, F && f ) -> OutputIt

constexpr

write_padded() [2/2]

template<typename Char , align default_align = align::left, typename OutputIt , typename F >

FMT_CONSTEXPR auto detail::write_padded	(	OutputIt	out,
		const format_specs &	specs,
		size_t	size,
		size_t	width,
		F &&	f ) -> OutputIt

write_padding() [1/2]

template<typename OutputIt >

auto detail::write_padding	(	OutputIt	out,
		pad_type	pad ) -> OutputIt

write_padding() [2/2]

template<typename OutputIt >

auto detail::write_padding	(	OutputIt	out,
		pad_type	pad,
		int	width ) -> OutputIt

write_ptr()

template<typename Char , typename OutputIt , typename UIntPtr >

auto detail::write_ptr	(	OutputIt	out,
		UIntPtr	value,
		const format_specs *	specs ) -> OutputIt

write_significand() [1/7]

template<typename Char , typename UInt , FMT_ENABLE_IF(std::is_integral< UInt >::value) >

auto detail::write_significand ( Char * out, UInt significand, int significand_size, int integral_size, Char decimal_point ) -> Char*

inline

write_significand() [2/7]

template<typename Char , typename OutputIt >

auto detail::write_significand ( OutputIt out, const char * significand, int significand_size ) -> OutputIt

constexpr

write_significand() [3/7]

template<typename OutputIt , typename Char >

FMT_CONSTEXPR auto detail::write_significand	(	OutputIt	out,
		const char *	significand,
		int	significand_size,
		int	integral_size,
		Char	decimal_point ) -> OutputIt

write_significand() [4/7]

template<typename Char , typename OutputIt , typename T , typename Grouping >

FMT_CONSTEXPR20 auto detail::write_significand	(	OutputIt	out,
		T	significand,
		int	significand_size,
		int	exponent,
		const Grouping &	grouping ) -> OutputIt

write_significand() [5/7]

template<typename OutputIt , typename Char , typename T , typename Grouping >

FMT_CONSTEXPR20 auto detail::write_significand	(	OutputIt	out,
		T	significand,
		int	significand_size,
		int	integral_size,
		Char	decimal_point,
		const Grouping &	grouping ) -> OutputIt

write_significand() [6/7]

template<typename Char , typename OutputIt , typename UInt >

auto detail::write_significand ( OutputIt out, UInt significand, int significand_size ) -> OutputIt

inline

write_significand() [7/7]

template<typename OutputIt , typename UInt , typename Char , FMT_ENABLE_IF(!std::is_pointer< remove_cvref_t< OutputIt > >::value) >

auto detail::write_significand ( OutputIt out, UInt significand, int significand_size, int integral_size, Char decimal_point ) -> OutputIt

inline

write_tm_str()

template<typename Char , typename OutputIt , FMT_ENABLE_IF(!std::is_same< Char, char >::value) >

auto detail::write_tm_str	(	OutputIt	out,
		string_view	sv,
		const std::locale &	loc ) -> OutputIt

Variable Documentation

deallocate

struct detail::fixed_string detail::deallocate

invalid_code_point

FMT_INLINE_VARIABLE uint32_t detail::invalid_code_point = ~uint32_t()

constexpr