detail Namespace Reference

detail namespace with internal helper functions More...

Namespaces
namespace	container_input_adapter_factory_impl
namespace	dragonbox
namespace	dtoa_impl
	implements the Grisu2 algorithm for binary to decimal floating-point conversion.
namespace	impl
namespace	tuple
namespace	utility_internal

Classes
struct	actual_object_comparator
struct	all
struct	ansi_color_escape
class	arg_converter
struct	arg_data
struct	arg_data< T, Char, NUM_ARGS, 0 >
struct	arg_formatter
struct	arg_mapper
struct	arg_ref
struct	basic_data
struct	basic_fp
struct	big_decimal_fp
class	bigint
class	binary_reader
	deserialization of CBOR, MessagePack, and UBJSON values More...
class	binary_writer
	serialization to CBOR and MessagePack values More...
class	buffer
	\rst A contiguous memory buffer with an optional growing ability. More...
struct	buffer_traits
class	char_converter
struct	char_t_impl
struct	char_t_impl< S, enable_if_t< is_string< S >::value > >
struct	chrono_format_checker
struct	chrono_formatter
struct	codecvt_result
struct	color_type
class	compile_parse_context
struct	compile_string
class	compiled_string
struct	conditional_helper
struct	conjunction
struct	conjunction< B >
struct	conjunction< B, Bn... >
struct	count_fractional_digits
struct	count_fractional_digits< Num, Den, N, false >
class	counting_buffer
class	counting_iterator
struct	custom_formatter
struct	custom_value
struct	data
struct	default_arg_formatter
struct	detector
struct	detector< Default, void_t< Op< Args... > >, Op, Args... >
class	digit_grouping
class	dynamic_arg_list
struct	dynamic_format_specs
struct	dynamic_spec_id_handler
struct	error_handler
class	exception
	general exception of the basic_json class More...
struct	external_constructor
struct	external_constructor< value_t::array >
struct	external_constructor< value_t::binary >
struct	external_constructor< value_t::boolean >
struct	external_constructor< value_t::number_float >
struct	external_constructor< value_t::number_integer >
struct	external_constructor< value_t::number_unsigned >
struct	external_constructor< value_t::object >
struct	external_constructor< value_t::string >
class	fallback_digit_grouping
class	file_access
class	file_input_adapter
struct	fill_t
struct	find_escape_result
class	fixed_buffer_traits
struct	float_specs
struct	format_as_result
struct	format_decimal_result
class	format_string_checker
struct	format_tuple_element
class	formatbuf
struct	from_json_fn
struct	get_cstring
class	get_locale
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_format_as
struct	has_from_json
struct	has_from_json< BasicJsonType, T, enable_if_t< !is_basic_json< T >::value > >
struct	has_isfinite
struct	has_isfinite< T, enable_if_t< sizeof(std::isfinite(T())) !=0 > >
struct	has_key_compare
struct	has_member_data_tm_gmtoff
struct	has_member_data_tm_gmtoff< T, void_t< decltype(T::tm_gmtoff)> >
struct	has_member_data_tm_zone
struct	has_member_data_tm_zone< T, void_t< decltype(T::tm_zone)> >
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_non_default_from_json
struct	has_non_default_from_json< BasicJsonType, T, enable_if_t< !is_basic_json< T >::value > >
struct	has_to_json
struct	has_to_json< BasicJsonType, T, enable_if_t< !is_basic_json< T >::value > >
struct	identity_tag
class	input_stream_adapter
struct	int_checker
struct	int_checker< true >
struct	integer_sequence
struct	internal_iterator
	an iterator value More...
class	invalid_iterator
	exception indicating errors with iterators More...
struct	is_back_insert_iterator
struct	is_back_insert_iterator< std::back_insert_iterator< Container > >
struct	is_basic_json
struct	is_basic_json< WPI_BASIC_JSON_TPL >
struct	is_basic_json_context
struct	is_bit_reference_like
struct	is_c_string
struct	is_comparable
struct	is_comparable< Compare, A, B, void_t< decltype(std::declval< Compare >()(std::declval< A >(), std::declval< B >())), decltype(std::declval< Compare >()(std::declval< B >(), std::declval< A >()))> >
struct	is_compatible_array_type
struct	is_compatible_array_type_impl
struct	is_compatible_array_type_impl< BasicJsonType, CompatibleArrayType, enable_if_t< is_detected< iterator_t, CompatibleArrayType >::value &&is_iterator_traits< iterator_traits< detected_t< iterator_t, CompatibleArrayType > > >::value &&!std::is_same< CompatibleArrayType, detected_t< range_value_t, CompatibleArrayType > >::value > >
struct	is_compatible_integer_type
struct	is_compatible_integer_type_impl
struct	is_compatible_integer_type_impl< RealIntegerType, CompatibleNumberIntegerType, enable_if_t< std::is_integral< RealIntegerType >::value &&std::is_integral< CompatibleNumberIntegerType >::value &&!std::is_same< bool, CompatibleNumberIntegerType >::value > >
struct	is_compatible_object_type
struct	is_compatible_object_type_impl
struct	is_compatible_object_type_impl< BasicJsonType, CompatibleObjectType, enable_if_t< is_detected< mapped_type_t, CompatibleObjectType >::value &&is_detected< key_type_t, CompatibleObjectType >::value > >
struct	is_compatible_string_type
struct	is_compatible_type
struct	is_compatible_type_impl
struct	is_compatible_type_impl< BasicJsonType, CompatibleType, enable_if_t< is_complete_type< CompatibleType >::value > >
struct	is_compile_string
struct	is_compiled_string
struct	is_complete_type
struct	is_complete_type< T, decltype(void(sizeof(T)))>
struct	is_constructible
struct	is_constructible< const std::pair< T1, T2 > >
struct	is_constructible< const std::tuple< Ts... > >
struct	is_constructible< std::pair< T1, T2 > >
struct	is_constructible< std::tuple< Ts... > >
struct	is_constructible_array_type
struct	is_constructible_array_type_impl
struct	is_constructible_array_type_impl< BasicJsonType, ConstructibleArrayType, enable_if_t< !std::is_same< ConstructibleArrayType, typename BasicJsonType::value_type >::value &&!is_compatible_string_type< BasicJsonType, ConstructibleArrayType >::value &&is_default_constructible< ConstructibleArrayType >::value &&(std::is_move_assignable< ConstructibleArrayType >::value||std::is_copy_assignable< ConstructibleArrayType >::value)&&is_detected< iterator_t, ConstructibleArrayType >::value &&is_iterator_traits< iterator_traits< detected_t< iterator_t, ConstructibleArrayType > > >::value &&is_detected< range_value_t, ConstructibleArrayType >::value &&!std::is_same< ConstructibleArrayType, detected_t< range_value_t, ConstructibleArrayType > >::value &&is_complete_type< detected_t< range_value_t, ConstructibleArrayType > >::value > >
struct	is_constructible_array_type_impl< BasicJsonType, ConstructibleArrayType, enable_if_t< std::is_same< ConstructibleArrayType, typename BasicJsonType::value_type >::value > >
struct	is_constructible_object_type
struct	is_constructible_object_type_impl
struct	is_constructible_object_type_impl< BasicJsonType, ConstructibleObjectType, enable_if_t< is_detected< mapped_type_t, ConstructibleObjectType >::value &&is_detected< key_type_t, ConstructibleObjectType >::value > >
struct	is_constructible_string_type
struct	is_constructible_tuple
struct	is_constructible_tuple< T1, std::tuple< Args... > >
class	is_container_adaptor_like
struct	is_default_constructible
struct	is_default_constructible< const std::pair< T1, T2 > >
struct	is_default_constructible< const std::tuple< Ts... > >
struct	is_default_constructible< std::pair< T1, T2 > >
struct	is_default_constructible< std::tuple< Ts... > >
struct	is_detected_lazy
struct	is_formattable_delayed
struct	is_getable
struct	is_integral
struct	is_integral< int128_opt >
struct	is_integral< uint128_t >
struct	is_iterator_of_multibyte
struct	is_iterator_traits
struct	is_iterator_traits< iterator_traits< T > >
struct	is_json_iterator_of
struct	is_json_iterator_of< BasicJsonType, typename BasicJsonType::const_iterator >
struct	is_json_iterator_of< BasicJsonType, typename BasicJsonType::iterator >
struct	is_json_ref
struct	is_json_ref< json_ref< T > >
class	is_map
struct	is_named_arg
struct	is_named_arg< named_arg< Char, T > >
struct	is_ordered_map
struct	is_output_iterator
struct	is_output_iterator< It, T, void_t< typename std::iterator_traits< It >::iterator_category, decltype(*std::declval< It >()=std::declval< T >())> >
struct	is_range
struct	is_range_
struct	is_range_< T, void >
struct	is_reference_wrapper
struct	is_reference_wrapper< std::reference_wrapper< T > >
struct	is_sax
struct	is_sax_static_asserts
class	is_set
struct	is_specialization_of
struct	is_specialization_of< Primary, Primary< Args... > >
struct	is_statically_named_arg
class	is_std_string_like
struct	is_std_string_like< fmt::basic_string_view< Char > >
struct	is_string
struct	is_transparent
class	is_tuple_formattable_
class	is_tuple_formattable_< T, C, true >
class	is_tuple_like_
struct	is_zero_int
class	iter_impl
	a template for a bidirectional iterator for the basic_json class This class implements a both iterators (iterator and const_iterator) for the basic_json class. More...
class	iteration_proxy
	proxy class for the items() function More...
class	iteration_proxy_value
class	iterator_buffer
class	iterator_buffer< std::back_insert_iterator< Container >, enable_if_t< is_contiguous< Container >::value, typename Container::value_type > >
class	iterator_buffer< T *, T >
class	iterator_buffer< T *, T, fixed_buffer_traits >
class	iterator_input_adapter
struct	iterator_input_adapter_factory
struct	iterator_input_adapter_factory< IteratorType, enable_if_t< is_iterator_of_multibyte< IteratorType >::value > >
struct	iterator_traits
struct	iterator_traits< T *, enable_if_t< std::is_object< T >::value > >
struct	iterator_traits< T, enable_if_t< !std::is_pointer< T >::value > >
struct	iterator_types
struct	iterator_types< It, void_t< typename It::difference_type, typename It::value_type, typename It::pointer, typename It::reference, typename It::iterator_category > >
class	json_ref
class	json_reverse_iterator
	a template for a reverse iterator class More...
class	json_sax_acceptor
class	json_sax_dom_callback_parser
class	json_sax_dom_parser
	SAX implementation to create a JSON value from SAX events. More...
class	lexer
	lexical analysis More...
class	lexer_base
struct	loc_writer
class	locale_ref
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	make_void
struct	named_arg
struct	named_arg_info
struct	named_arg_value
struct	negation
struct	nonesuch
struct	null
struct	null_chrono_spec_handler
class	other_error
	exception indicating other library errors More...
class	out_of_range
	exception indicating access out of the defined range More...
class	output_adapter
struct	output_adapter_protocol
	abstract output adapter interface More...
class	output_stream_adapter
	output adapter for output streams More...
class	output_string_adapter
	output adapter for basic_string More...
class	output_vector_adapter
	output adapter for byte vectors More...
struct	parse_empty_specs
class	parse_error
	exception indicating a parse error More...
class	parser
	syntax analysis More...
struct	position_t
	struct to capture the start position of the current token More...
class	precision_checker
class	primitive_iterator_t
class	printf_arg_formatter
struct	printf_precision_handler
class	printf_width_handler
struct	priority_tag
struct	priority_tag< 0 >
struct	range_default_formatter
struct	range_default_formatter< K, R, Char, enable_if_t<(K==range_format::sequence||K==range_format::map||K==range_format::set)> >
struct	range_format_kind_
struct	range_mapper
class	raw_ostream_adapter
class	serializer
struct	singleton
class	span_input_adapter
struct	static_const
struct	std_string_view
struct	streamed_view
struct	string_literal
struct	string_value
struct	strip_named_arg
struct	strip_named_arg< T, true >
struct	styled_arg
struct	thousands_sep_result
struct	tm_format_checker
class	tm_writer
struct	to_json_fn
class	to_utf8
struct	type_constant
class	type_error
	exception indicating executing a member function with a wrong type More...
class	uint128_fallback
struct	unformattable
struct	unformattable_char
struct	unformattable_pointer
class	utf8_to_utf16
class	value
struct	value_in_range_of_impl1
struct	value_in_range_of_impl1< OfType, T, false >
struct	value_in_range_of_impl1< OfType, T, true >
struct	value_in_range_of_impl2
struct	value_in_range_of_impl2< OfType, T, false, false >
struct	value_in_range_of_impl2< OfType, T, false, true >
struct	value_in_range_of_impl2< OfType, T, true, false >
struct	value_in_range_of_impl2< OfType, T, true, true >
struct	vformat_args
struct	vformat_args< char >
struct	view
class	wide_string_input_adapter
struct	wide_string_input_helper
struct	wide_string_input_helper< BaseInputAdapter, 2 >
struct	wide_string_input_helper< BaseInputAdapter, 4 >
class	width_checker
struct	write_int_arg
struct	write_int_data

Typedefs
template<typename T >
using	is_exotic_char = bool_constant<!std::is_same< T, char >::value >
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 = decltype(*detail::range_begin(std::declval< Range & >()))
template<typename Range >
using	uncvref_type = remove_cvref_t< range_reference_type< Range > >
template<typename Char , typename Element >
using	range_formatter_type = formatter< remove_cvref_t< decltype(range_mapper< buffer_context< Char > >{}.map(std::declval< Element >()))>, Char >
template<typename R >
using	maybe_const_range = conditional_t< has_const_begin_end< R >::value, const R, R >
template<range_format K>
using	range_format_constant = std::integral_constant< range_format, K >
using	uint128_t = conditional_t< FMT_USE_INT128, uint128_opt, uint128_fallback >
using	uintptr_t = uint128_t
template<typename T >
using	iterator_t = decltype(std::begin(std::declval< T & >()))
template<typename T >
using	sentinel_t = decltype(std::end(std::declval< T & >()))
template<typename OutputIt >
using	reserve_iterator = remove_reference_t< decltype(reserve(std::declval< OutputIt & >(), 0))>
template<typename T >
using	is_signed = std::integral_constant< bool, std::numeric_limits< T >::is_signed||std::is_same< T, int128_opt >::value >
template<typename T >
using	is_integer = 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 >
using	float128 = void
template<typename T >
using	is_float128 = std::is_same< T, float128 >
template<typename T >
using	is_floating_point = bool_constant< std::is_floating_point< T >::value||is_float128< T >::value >
template<typename T >
using	uint32_or_64_or_128_t = conditional_t< num_bits< T >()<=32 &&!FMT_REDUCE_INT_INSTANTIATIONS, uint32_t, conditional_t< num_bits< T >()<=64, uint64_t, uint128_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 = conditional_t< std::is_same< T, float >::value||doublish, double, T >
template<typename Char >
using	make_unsigned_char = typename conditional_t< std::is_integral< Char >::value, std::make_unsigned< Char >, type_identity< uint32_t > >::type
using	format_func = void(*)(detail::buffer< char > &, int, const char *)
template<typename T >
using	buffer_appender = conditional_t< std::is_same< T, char >::value, appender, std::back_insert_iterator< buffer< T > > >
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_t = typename format_as_result< T >::type
template<typename T , typename Context >
using	mapped_type_constant = type_constant< decltype(arg_mapper< Context >().map(std::declval< const T & >())), typename Context::char_type >
template<typename... >
using	void_t = void
template<typename BasicJsonType >
using	parser_callback_t = std::function< bool(int, parse_event_t, BasicJsonType &)>
using	contiguous_bytes_input_adapter = decltype(input_adapter(std::declval< const char * >(), std::declval< const char * >()))
template<typename StringType , typename Arg >
using	string_can_append = decltype(std::declval< StringType & >().append(std::declval< Arg && >()))
template<typename StringType , typename Arg >
using	detect_string_can_append = is_detected< string_can_append, StringType, Arg >
template<typename StringType , typename Arg >
using	string_can_append_op = decltype(std::declval< StringType & >()+=std::declval< Arg && >())
template<typename StringType , typename Arg >
using	detect_string_can_append_op = is_detected< string_can_append_op, StringType, Arg >
template<typename StringType , typename Arg >
using	string_can_append_iter = decltype(std::declval< StringType & >().append(std::declval< const Arg & >().begin(), std::declval< const Arg & >().end()))
template<typename StringType , typename Arg >
using	detect_string_can_append_iter = is_detected< string_can_append_iter, StringType, Arg >
template<typename StringType , typename Arg >
using	string_can_append_data = decltype(std::declval< StringType & >().append(std::declval< const Arg & >().data(), std::declval< const Arg & >().size()))
template<typename StringType , typename Arg >
using	detect_string_can_append_data = is_detected< string_can_append_data, StringType, Arg >
template<template< class... > class Op, class... Args>
using	is_detected = typename detector< nonesuch, void, Op, Args... >::value_t
template<template< class... > class Op, class... Args>
using	detected_t = typename detector< nonesuch, void, Op, Args... >::type
template<class Default , template< class... > class Op, class... Args>
using	detected_or = detector< Default, void, Op, Args... >
template<class Default , template< class... > class Op, class... Args>
using	detected_or_t = typename detected_or< Default, Op, Args... >::type
template<class Expected , template< class... > class Op, class... Args>
using	is_detected_exact = std::is_same< Expected, detected_t< Op, Args... > >
template<class To , template< class... > class Op, class... Args>
using	is_detected_convertible = std::is_convertible< detected_t< Op, Args... >, To >
template<typename T >
using	uncvref_t = typename std::remove_cv< typename std::remove_reference< T >::type >::type
template<bool B, typename T = void>
using	enable_if_t = typename std::enable_if< B, T >::type
template<typename T , T N>
using	make_integer_sequence = typename utility_internal::Gen< T, N >::type
template<typename... Ts>
using	index_sequence_for = make_index_sequence< sizeof...(Ts)>
template<typename T >
using	mapped_type_t = typename T::mapped_type
template<typename T >
using	key_type_t = typename T::key_type
template<typename T >
using	value_type_t = typename T::value_type
template<typename T >
using	difference_type_t = typename T::difference_type
template<typename T >
using	pointer_t = typename T::pointer
template<typename T >
using	reference_t = typename T::reference
template<typename T >
using	iterator_category_t = typename T::iterator_category
template<typename T , typename... Args>
using	to_json_function = decltype(T::to_json(std::declval< Args >()...))
template<typename T , typename... Args>
using	from_json_function = decltype(T::from_json(std::declval< Args >()...))
template<typename T , typename U >
using	get_template_function = decltype(std::declval< T >().template get< U >())
template<typename T >
using	detect_key_compare = typename T::key_compare
template<typename BasicJsonType >
using	actual_object_comparator_t = typename actual_object_comparator< BasicJsonType >::type
template<typename T >
using	range_value_t = value_type_t< iterator_traits< iterator_t< T > > >
template<typename T >
using	is_json_pointer = is_specialization_of<::wpi::json_pointer, uncvref_t< T > >
template<typename T >
using	detect_is_transparent = typename T::is_transparent
template<typename Comparator , typename ObjectKeyType , typename KeyTypeCVRef , bool RequireTransparentComparator = true, bool ExcludeObjectKeyType = RequireTransparentComparator, typename KeyType = uncvref_t<KeyTypeCVRef>>
using	is_usable_as_key_type = typename std::conditional< is_comparable< Comparator, ObjectKeyType, KeyTypeCVRef >::value &&!(ExcludeObjectKeyType &&std::is_same< KeyType, ObjectKeyType >::value) &&(!RequireTransparentComparator||is_detected< detect_is_transparent, Comparator >::value) &&!is_json_pointer< KeyType >::value, std::true_type, std::false_type >::type
template<typename BasicJsonType , typename KeyTypeCVRef , bool RequireTransparentComparator = true, bool ExcludeObjectKeyType = RequireTransparentComparator, typename KeyType = uncvref_t<KeyTypeCVRef>>
using	is_usable_as_basic_json_key_type = typename std::conditional< is_usable_as_key_type< typename BasicJsonType::object_comparator_t, typename BasicJsonType::object_t::key_type, KeyTypeCVRef, RequireTransparentComparator, ExcludeObjectKeyType >::value &&!is_json_iterator_of< BasicJsonType, KeyType >::value, std::true_type, std::false_type >::type
template<typename ObjectType , typename KeyType >
using	detect_erase_with_key_type = decltype(std::declval< ObjectType & >().erase(std::declval< KeyType >()))
template<typename BasicJsonType , typename KeyType >
using	has_erase_with_key_type = typename std::conditional< is_detected< detect_erase_with_key_type, typename BasicJsonType::object_t, KeyType >::value, std::true_type, std::false_type >::type
template<typename... Types>
using	all_integral = conjunction< std::is_integral< Types >... >
template<typename... Types>
using	all_signed = conjunction< std::is_signed< Types >... >
template<typename... Types>
using	all_unsigned = conjunction< std::is_unsigned< Types >... >
template<typename... Types>
using	same_sign = std::integral_constant< bool, all_signed< Types... >::value||all_unsigned< Types... >::value >
template<typename OfType , typename T >
using	never_out_of_range = std::integral_constant< bool,(std::is_signed< OfType >::value &&(sizeof(T)< sizeof(OfType)))||(same_sign< OfType, T >::value &&sizeof(OfType)==sizeof(T)) >
template<bool Value>
using	bool_constant = std::integral_constant< bool, Value >
template<typename T >
using	is_c_string_uncvref = is_c_string< uncvref_t< T > >
template<typename T >
using	null_function_t = decltype(std::declval< T & >().null())
template<typename T >
using	boolean_function_t = decltype(std::declval< T & >().boolean(std::declval< bool >()))
template<typename T , typename Integer >
using	number_integer_function_t = decltype(std::declval< T & >().number_integer(std::declval< Integer >()))
template<typename T , typename Unsigned >
using	number_unsigned_function_t = decltype(std::declval< T & >().number_unsigned(std::declval< Unsigned >()))
template<typename T , typename Float , typename String >
using	number_float_function_t = decltype(std::declval< T & >().number_float(std::declval< Float >(), std::declval< const String & >()))
template<typename T , typename String >
using	string_function_t = decltype(std::declval< T & >().string(std::declval< String & >()))
template<typename T , typename Binary >
using	binary_function_t = decltype(std::declval< T & >().binary(std::declval< Binary & >()))
template<typename T >
using	start_object_function_t = decltype(std::declval< T & >().start_object(std::declval< std::size_t >()))
template<typename T , typename String >
using	key_function_t = decltype(std::declval< T & >().key(std::declval< String & >()))
template<typename T >
using	end_object_function_t = decltype(std::declval< T & >().end_object())
template<typename T >
using	start_array_function_t = decltype(std::declval< T & >().start_array(std::declval< std::size_t >()))
template<typename T >
using	end_array_function_t = decltype(std::declval< T & >().end_array())
template<typename T , typename Exception >
using	parse_error_function_t = decltype(std::declval< T & >().parse_error(std::declval< std::size_t >(), std::declval< const std::string & >(), std::declval< const Exception & >()))
template<typename CharType >
using	output_adapter_t = std::shared_ptr< output_adapter_protocol< CharType > >
	a type to simplify interfaces More...

Enumerations
enum class	numeric_system { standard , alternative }
enum class	pad_type { unspecified , none , zero , space }
enum	char8_type : unsigned char
enum class	to_utf8_error_policy { abort , replace }
enum class	float_format : unsigned char { general , exp , fixed , hex }
enum	dragon { predecessor_closer = 1 , fixup = 2 , fixed = 4 }
enum class	int128_opt
enum class	uint128_opt
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) }
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 }
enum class	arg_id_kind { none , index , name }
enum class	state {   start , align , sign , hash ,   zero , width , precision , locale }
enum class	parse_event_t : std::uint8_t {   object_start , object_end , array_start , array_end ,   key , value }
enum class	cbor_tag_handler_t { error , ignore , store }
	how to treat CBOR tags More...
enum class	input_format_t {   json , cbor , msgpack , ubjson ,   bson , bjdata }
	the supported input formats More...
enum class	value_t : std::uint8_t {   null , object , array , string ,   boolean , number_integer , number_unsigned , number_float ,   binary , discarded }
	the JSON type enumeration More...
enum class	error_handler_t { strict , replace , ignore }
	how to treat decoding errors More...

Functions
auto	write_loc (std::back_insert_iterator< detail::buffer< wchar_t > > out, loc_value value, const format_specs< wchar_t > &specs, locale_ref loc) -> bool
template<typename Char >
FMT_CONSTEXPR ansi_color_escape< Char >	make_foreground_color (detail::color_type foreground) noexcept
template<typename Char >
FMT_CONSTEXPR ansi_color_escape< Char >	make_background_color (detail::color_type background) noexcept
template<typename Char >
FMT_CONSTEXPR ansi_color_escape< Char >	make_emphasis (emphasis em) noexcept
template<typename Char >
void	reset_color (buffer< Char > &buffer)
template<typename Char >
void	vformat_to (buffer< Char > &buf, const text_style &ts, basic_string_view< Char > format_str, basic_format_args< buffer_context< type_identity_t< Char > > > args)
null localtime_r	FMT_NOMACRO (...)
null	localtime_s (...)
null	gmtime_r (...)
null	gmtime_s (...)
const std::locale &	get_classic_locale ()
template<typename CodeUnit >
void	write_codecvt (codecvt_result< CodeUnit > &out, string_view in_buf, 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
void	write_digit2_separated (char *buf, unsigned a, unsigned b, unsigned c, char sep)
template<typename Period >
FMT_CONSTEXPR const char *	get_units ()
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 const Char *	parse_chrono_format (const Char *begin, const Char *end, Handler &&handler)
const char *	tm_wday_full_name (int wday)
const char *	tm_wday_short_name (int wday)
const char *	tm_mon_full_name (int mon)
const char *	tm_mon_short_name (int mon)
template<typename T , typename Int , FMT_ENABLE_IF(std::is_integral< T >::value) >
Int	to_nonnegative_int (T value, Int upper)
constexpr long long	pow10 (std::uint32_t n)
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) >
bool	isfinite (T)
template<typename T , FMT_ENABLE_IF(std::is_integral< T >::value) >
T	mod (T x, int y)
template<typename To , typename FromRep , typename FromPeriod >
To	fmt_safe_duration_cast (std::chrono::duration< FromRep, FromPeriod > from)
template<typename Rep , typename Period , FMT_ENABLE_IF(std::is_integral< Rep >::value) >
std::chrono::duration< Rep, std::milli >	get_milliseconds (std::chrono::duration< Rep, Period > d)
template<typename Char , typename Rep , typename OutputIt , FMT_ENABLE_IF(std::is_integral< Rep >::value) >
OutputIt	format_duration_value (OutputIt out, Rep val, int)
template<typename Char , typename OutputIt >
OutputIt	copy_unit (string_view unit, OutputIt out, Char)
template<typename OutputIt >
OutputIt	copy_unit (string_view unit, OutputIt out, wchar_t)
template<typename Char , typename Period , typename OutputIt >
OutputIt	format_duration_unit (OutputIt out)
template<typename Range , typename OutputIt >
auto	copy (const Range &range, OutputIt out) -> OutputIt
template<typename OutputIt >
auto	copy (const char *str, OutputIt out) -> OutputIt
template<typename OutputIt >
auto	copy (char ch, OutputIt out) -> OutputIt
template<typename OutputIt >
auto	copy (wchar_t ch, OutputIt out) -> OutputIt
template<typename T , std::size_t N>
auto	range_begin (const T(&arr)[N]) -> const T *
template<typename T , std::size_t N>
auto	range_end (const T(&arr)[N]) -> const T *
template<typename T >
auto	range_begin (T &&rng) FMT_DECLTYPE_RETURN(static_cast< T && >(rng).begin())
template<typename T >
auto	range_end (T &&rng) FMT_DECLTYPE_RETURN(static_cast< T && >(rng).end())
template<typename T >
auto	range_begin (T &&rng) -> enable_if_t<!has_member_fn_begin_end_t< T && >::value, decltype(begin(static_cast< T && >(rng)))>
template<typename T >
auto	range_end (T &&rng) -> enable_if_t<!has_member_fn_begin_end_t< T && >::value, decltype(end(static_cast< T && >(rng)))>
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 &,...)
FMT_FUNC void	assert_fail (const char *file, int line, const char *message)
FMT_FUNC void	throw_format_error (const char *message)
FMT_FUNC void	format_error_code (detail::buffer< char > &out, int error_code, string_view message) noexcept
FMT_FUNC void	report_error (format_func func, int error_code, const char *message) noexcept
void	fwrite_fully (const void *ptr, size_t size, 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 Char	decimal_point_impl (locale_ref loc)
FMT_FUNC auto	write_loc (appender out, loc_value value, const format_specs<> &specs, locale_ref loc) -> bool
template<typename F >
bool	operator== (basic_fp< F > x, basic_fp< F > y)
FMT_CONSTEXPR uint32_t	rotr (uint32_t n, uint32_t r) noexcept
FMT_CONSTEXPR uint64_t	rotr (uint64_t n, uint32_t r) noexcept
FMT_FUNC bool	write_console (std::FILE *, string_view)
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
FMT_FUNC auto	is_printable (uint32_t cp) -> bool
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_t > () -> 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 Char >
auto	get_data (std::basic_string< Char > &s) -> Char *
template<typename Container >
auto	get_data (Container &c) -> typename Container::value_type *
template<typename Container , FMT_ENABLE_IF(is_contiguous< Container >::value) >
auto	reserve (std::back_insert_iterator< Container > it, size_t n) -> typename Container::value_type *
template<typename T >
auto	reserve (buffer_appender< T > it, size_t n) -> buffer_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 >
auto	to_pointer (buffer_appender< T > it, size_t n) -> T *
template<typename Container , FMT_ENABLE_IF(is_contiguous< Container >::value) >
auto	base_iterator (std::back_insert_iterator< Container > it, typename Container::value_type *) -> std::back_insert_iterator< Container >
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_str_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)
template<typename Char >
auto	compute_width (basic_string_view< Char > s) -> size_t
FMT_CONSTEXPR size_t	compute_width (string_view s)
auto	compute_width (basic_string_view< char8_type > s) -> size_t
template<typename Char >
auto	code_point_index (basic_string_view< Char > s, size_t n) -> size_t
auto	code_point_index (string_view s, size_t n) -> size_t
auto	code_point_index (basic_string_view< char8_type > s, size_t n) -> size_t
template<typename T , FMT_ENABLE_IF(is_signed< T >::value) >
constexpr auto	is_negative (T value) -> bool
template<typename T >
FMT_CONSTEXPR auto	is_supported_floating_point (T) -> bool
constexpr const char *	digits2 (size_t value)
template<typename Char , typename Sign >
constexpr Char	sign (Sign s)
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
template<typename Char >
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	copy2 (Char *dst, const char *src)
template<typename Char , typename UInt >
FMT_CONSTEXPR20 auto	format_decimal (Char *out, UInt value, int size) -> format_decimal_result< Char * >
template<typename Char , typename UInt , typename Iterator , FMT_ENABLE_IF(!std::is_pointer< remove_cvref_t< Iterator > >::value) >
FMT_CONSTEXPR auto	format_decimal (Iterator out, UInt value, int size) -> format_decimal_result< Iterator >
template<unsigned BASE_BITS, typename Char , typename UInt >
FMT_CONSTEXPR auto	format_uint (Char *buffer, UInt value, int num_digits, bool upper=false) -> Char *
template<unsigned BASE_BITS, typename Char , typename It , typename UInt >
FMT_CONSTEXPR auto	format_uint (It out, UInt value, int num_digits, bool upper=false) -> It
uint128_fallback	umul128 (uint64_t x, uint64_t y) noexcept
template<typename Float >
constexpr bool	has_implicit_bit ()
template<typename Float >
constexpr int	num_significand_bits ()
template<typename Float >
constexpr auto	exponent_mask () -> typename dragonbox::float_info< Float >::carrier_uint
template<typename Float >
constexpr auto	exponent_bias () -> int
template<typename Char , typename It >
FMT_CONSTEXPR auto	write_exponent (int exp, It it) -> It
template<int SHIFT = 0, typename F >
FMT_CONSTEXPR basic_fp< F >	normalize (basic_fp< F > value)
FMT_CONSTEXPR uint64_t	multiply (uint64_t lhs, uint64_t rhs)
FMT_CONSTEXPR fp	operator* (fp x, fp y)
template<typename T >
constexpr auto	convert_float (T value) -> convert_float_result< T >
template<typename OutputIt , typename Char >
FMT_NOINLINE FMT_CONSTEXPR auto	fill (OutputIt it, size_t n, const fill_t< Char > &fill) -> OutputIt
template<align::type align = align::left, typename OutputIt , typename Char , typename F >
FMT_CONSTEXPR auto	write_padded (OutputIt out, const format_specs< Char > &specs, size_t size, size_t width, F &&f) -> OutputIt
template<align::type align = align::left, typename OutputIt , typename Char , typename F >
constexpr auto	write_padded (OutputIt out, const format_specs< Char > &specs, size_t size, F &&f) -> OutputIt
template<align::type align = align::left, typename Char , typename OutputIt >
FMT_CONSTEXPR auto	write_bytes (OutputIt out, string_view bytes, const format_specs< Char > &specs) -> OutputIt
template<typename Char , typename OutputIt , typename UIntPtr >
auto	write_ptr (OutputIt out, UIntPtr value, const format_specs< Char > *specs) -> OutputIt
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< Char > &specs) -> OutputIt
template<typename Char , typename OutputIt >
FMT_CONSTEXPR auto	write (OutputIt out, Char value, const format_specs< Char > &specs, locale_ref loc={}) -> OutputIt
template<typename OutputIt , typename Char , typename W >
FMT_CONSTEXPR FMT_INLINE auto	write_int (OutputIt out, int num_digits, unsigned prefix, const format_specs< Char > &specs, W write_digits) -> OutputIt
template<typename OutputIt , typename UInt , typename Char >
auto	write_int (OutputIt out, UInt value, unsigned prefix, const format_specs< Char > &specs, const digit_grouping< Char > &grouping) -> OutputIt
template<typename OutputIt , typename Char >
auto	write_loc (OutputIt, loc_value, const format_specs< Char > &, locale_ref) -> bool
FMT_CONSTEXPR void	prefix_append (unsigned &prefix, unsigned value)
template<typename T >
FMT_CONSTEXPR auto	make_write_int_arg (T value, sign_t sign) -> 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< Char > &specs, locale_ref) -> 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< Char > &specs, locale_ref loc) -> OutputIt
template<typename Char , typename OutputIt , typename T , FMT_ENABLE_IF(is_integral< T >::value && !std::is_same< T, bool >::value && std::is_same< OutputIt, buffer_appender< Char > >::value) >
FMT_CONSTEXPR FMT_INLINE auto	write (OutputIt out, T value, const format_specs< Char > &specs, locale_ref loc) -> OutputIt
template<typename Char , typename OutputIt >
FMT_CONSTEXPR auto	write (OutputIt out, basic_string_view< Char > s, const format_specs< Char > &specs) -> OutputIt
template<typename Char , typename OutputIt >
FMT_CONSTEXPR auto	write (OutputIt out, basic_string_view< type_identity_t< Char > > s, const format_specs< Char > &specs, locale_ref) -> OutputIt
template<typename Char , typename OutputIt >
FMT_CONSTEXPR auto	write (OutputIt out, const Char *s, const format_specs< Char > &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< Char > &specs) -> const Char *
template<typename ErrorHandler = error_handler, typename Char >
FMT_CONSTEXPR auto	parse_float_type_spec (const format_specs< Char > &specs, ErrorHandler &&eh={}) -> float_specs
template<typename Char , typename OutputIt >
FMT_CONSTEXPR20 auto	write_nonfinite (OutputIt out, bool isnan, format_specs< Char > specs, const float_specs &fspecs) -> 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 OutputIt , typename DecimalFP , typename Char , typename Grouping = digit_grouping<Char>>
FMT_CONSTEXPR20 auto	do_write_float (OutputIt out, const DecimalFP &f, const format_specs< Char > &specs, float_specs fspecs, locale_ref loc) -> OutputIt
template<typename OutputIt , typename DecimalFP , typename Char >
FMT_CONSTEXPR20 auto	write_float (OutputIt out, const DecimalFP &f, const format_specs< Char > &specs, float_specs fspecs, locale_ref loc) -> OutputIt
template<typename T >
constexpr bool	isnan (T value)
template<typename T , FMT_ENABLE_IF(std::is_floating_point< T >::value && has_isfinite< T >::value) >
FMT_CONSTEXPR20 bool	isfinite (T value)
template<typename T , FMT_ENABLE_IF(!has_isfinite< T >::value) >
FMT_CONSTEXPR bool	isfinite (T value)
template<typename T , FMT_ENABLE_IF(is_floating_point< T >::value) >
FMT_INLINE FMT_CONSTEXPR bool	signbit (T value)
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, int precision, float_specs specs, buffer< char > &buf)
template<typename Float >
FMT_CONSTEXPR20 auto	format_float (Float value, int precision, float_specs specs, buffer< char > &buf) -> int
template<typename Char , typename OutputIt , typename T >
FMT_CONSTEXPR20 auto	write_float (OutputIt out, T value, format_specs< Char > specs, locale_ref loc) -> OutputIt
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< Char > 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< Char >={}, 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(is_string< 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, basic_format_context<OutputIt, 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< Char > &specs={}, locale_ref={}) -> OutputIt
template<typename Char , typename OutputIt >
FMT_CONSTEXPR auto	write (OutputIt out, Char value) -> OutputIt
template<typename Char , typename OutputIt >
FMT_CONSTEXPR_CHAR_TRAITS 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< Char > &specs={}, locale_ref={}) -> OutputIt
template<typename Char , typename OutputIt , typename T , typename Context = basic_format_context<OutputIt, Char>>
FMT_CONSTEXPR auto	write (OutputIt out, const T &value) -> enable_if_t< std::is_class< T >::value &&!is_string< T >::value &&!is_floating_point< T >::value &&!std::is_same< T, Char >::value &&!std::is_same< T, remove_cvref_t< decltype(arg_mapper< Context >().map(value))> >::value, OutputIt >
template<template< typename > class Handler, typename FormatArg , typename ErrorHandler >
FMT_CONSTEXPR auto	get_dynamic_spec (FormatArg arg, ErrorHandler eh) -> int
template<typename Context , typename ID >
FMT_CONSTEXPR auto	get_arg (Context &ctx, ID id) -> decltype(ctx.arg(id))
template<template< typename > class Handler, typename Context >
FMT_CONSTEXPR void	handle_dynamic_spec (int &value, arg_ref< typename Context::char_type > ref, Context &ctx)
template<typename Locale , typename Char >
auto	vformat (const Locale &loc, basic_string_view< Char > fmt, basic_format_args< buffer_context< type_identity_t< Char > > > args) -> std::basic_string< Char >
template<typename Char >
void	vformat_to (buffer< Char > &buf, basic_string_view< Char > fmt, typename vformat_args< Char >::type args, locale_ref loc)
FMT_BEGIN_EXPORT template FMT_API void	vformat_to (buffer< char > &, string_view, typename vformat_args<>::type, locale_ref)
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 T , typename Context , typename Char >
void	convert_arg (basic_format_arg< Context > &arg, Char type)
template<typename Char >
auto	make_arg_formatter (buffer_appender< Char > iter, format_specs< Char > &s) -> arg_formatter< Char >
template<typename Char >
void	parse_flags (format_specs< Char > &specs, const Char *&it, const Char *end)
template<typename Char , typename GetArg >
auto	parse_header (const Char *&it, const Char *end, format_specs< Char > &specs, GetArg get_arg) -> int
auto	parse_printf_presentation_type (char c, type t) -> presentation_type
template<typename Char , typename Context >
void	vprintf (buffer< Char > &buf, basic_string_view< Char > format, basic_format_args< Context > args)
template<typename T >
const T &	unwrap (const T &v)
template<typename T >
const T &	unwrap (const std::reference_wrapper< T > &v)
template<typename Char , typename InputIt >
FMT_CONSTEXPR counting_iterator	copy_str (InputIt begin, InputIt end, counting_iterator it)
template<typename T , typename... Tail>
const T &	first (const T &value, const Tail &...)
bool	write_ostream_unicode (std::ostream &os, fmt::string_view data)
bool	write_ostream_unicode (std::wostream &, fmt::basic_string_view< wchar_t >)
template<typename Char >
void	write_buffer (std::basic_ostream< Char > &os, buffer< Char > &buf)
template<typename Char , typename T >
void	format_value (buffer< Char > &buf, const T &value, locale_ref loc=locale_ref())
void	vprint_directly (std::ostream &os, string_view format_str, format_args args)
template<typename... T>
FMT_CONSTEXPR void	ignore_unused (const T &...)
constexpr FMT_INLINE auto	is_constant_evaluated (bool default_value=false) noexcept -> bool
template<typename T >
constexpr FMT_INLINE auto	const_check (T value) -> T
template<typename T >
auto	convert_for_visit (T) -> monostate
template<typename Int >
FMT_CONSTEXPR auto	to_unsigned (Int value) -> typename std::make_unsigned< Int >::type
FMT_CONSTEXPR auto	is_utf8 () -> bool
template<typename Char , FMT_ENABLE_IF(is_char< Char >::value) >
FMT_INLINE auto	to_string_view (const Char *s) -> basic_string_view< Char >
template<typename Char , typename Traits , typename Alloc >
auto	to_string_view (const std::basic_string< Char, Traits, Alloc > &s) -> basic_string_view< Char >
template<typename Char >
constexpr auto	to_string_view (basic_string_view< Char > s) -> basic_string_view< Char >
template<typename Char , FMT_ENABLE_IF(!std::is_empty< std_string_view< Char > >::value) >
auto	to_string_view (std_string_view< Char > s) -> basic_string_view< Char >
template<typename S , FMT_ENABLE_IF(is_compile_string< S >::value) >
constexpr auto	to_string_view (const S &s) -> basic_string_view< typename S::char_type >
void	to_string_view (...)
	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 bool	is_integral_type (type t)
constexpr bool	is_arithmetic_type (type t)
constexpr auto	set (type rhs) -> int
constexpr auto	in (type t, int set) -> bool
template<typename Container >
auto	get_container (std::back_insert_iterator< Container > it) -> Container &
template<typename Char , typename InputIt , typename OutputIt >
FMT_CONSTEXPR auto	copy_str (InputIt begin, InputIt end, OutputIt out) -> OutputIt
template<typename Char , typename T , typename U , FMT_ENABLE_IF( std::is_same< remove_const_t< T >, U >::value &&is_char< U >::value) >
FMT_CONSTEXPR auto	copy_str (T *begin, T *end, U *out) -> U *
template<typename Context , typename T >
constexpr auto	has_const_formatter_impl (T *) -> decltype(typename Context::template formatter_type< T >().format(std::declval< const T & >(), std::declval< Context & >()), true)
template<typename Context >
constexpr auto	has_const_formatter_impl (...) -> bool
template<typename T , typename Context >
constexpr auto	has_const_formatter () -> bool
template<typename T , typename OutputIt >
auto	get_buffer (OutputIt out) -> iterator_buffer< OutputIt, T >
template<typename T , typename Buf , FMT_ENABLE_IF(std::is_base_of< buffer< char >, Buf >::value) >
auto	get_buffer (std::back_insert_iterator< Buf > out) -> buffer< char > &
template<typename Buf , typename OutputIt >
FMT_INLINE auto	get_iterator (Buf &buf, OutputIt) -> decltype(buf.out())
template<typename T , typename OutputIt >
auto	get_iterator (buffer< T > &, OutputIt out) -> OutputIt
template<typename Char >
void	init_named_args (named_arg_info< Char > *, int, int)
template<typename Char , typename T , typename... Tail, FMT_ENABLE_IF(!is_named_arg< T >::value) >
void	init_named_args (named_arg_info< Char > *named_args, int arg_count, int named_arg_count, const T &, const Tail &... args)
template<typename... Args>
FMT_CONSTEXPR FMT_INLINE void	init_named_args (std::nullptr_t, int, int, const Args &...)
template<bool B = false>
constexpr auto	count () -> size_t
template<bool B1, bool B2, bool... Tail>
constexpr auto	count () -> size_t
template<typename... Args>
constexpr auto	count_named_args () -> size_t
template<typename... Args>
constexpr auto	count_statically_named_args () -> size_t
template<typename Char , typename InputIt >
auto	copy_str (InputIt begin, InputIt end, appender out) -> appender
template<typename Char , typename InputIt >
auto	copy_str (InputIt begin, InputIt end, std::back_insert_iterator< std::string > out) -> std::back_insert_iterator< std::string >
template<typename Char , typename R , typename OutputIt >
FMT_CONSTEXPR auto	copy_str (R &&rng, OutputIt out) -> OutputIt
template<typename >
constexpr auto	encode_types () -> unsigned long long
template<typename Context , typename Arg , typename... Args>
constexpr auto	encode_types () -> unsigned long long
template<bool PACKED, typename Context , typename T , FMT_ENABLE_IF(PACKED) >
FMT_CONSTEXPR FMT_INLINE auto	make_arg (T &val) -> value< Context >
template<typename Context , typename T >
FMT_CONSTEXPR auto	make_arg (T &val) -> basic_format_arg< Context >
template<bool PACKED, typename Context , typename T , FMT_ENABLE_IF(!PACKED) >
FMT_CONSTEXPR auto	make_arg (T &val) -> basic_format_arg< Context >
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<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 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_t
template<typename Char >
constexpr auto	is_name_start (Char c) -> bool
template<typename Char , typename Handler >
FMT_CONSTEXPR auto	do_parse_arg_id (const Char *begin, const Char *end, Handler &&handler) -> const Char *
template<typename Char , typename Handler >
FMT_CONSTEXPR FMT_INLINE 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, basic_format_parse_context< Char > &ctx) -> const Char *
template<typename Char >
FMT_CONSTEXPR auto	parse_precision (const Char *begin, const Char *end, int &value, arg_ref< Char > &ref, basic_format_parse_context< Char > &ctx) -> const Char *
template<typename Char >
FMT_CONSTEXPR FMT_INLINE auto	parse_format_specs (const Char *begin, const Char *end, dynamic_format_specs< Char > &specs, basic_format_parse_context< Char > &ctx, type arg_type) -> const Char *
template<typename Char , typename Handler >
FMT_CONSTEXPR auto	parse_replacement_field (const Char *begin, const Char *end, Handler &&handler) -> const Char *
template<bool IS_CONSTEXPR, typename Char , typename Handler >
FMT_CONSTEXPR FMT_INLINE void	parse_format_string (basic_string_view< Char > format_str, Handler &&handler)
template<typename T , typename ParseContext >
FMT_CONSTEXPR auto	parse_format_specs (ParseContext &ctx) -> decltype(ctx.begin())
template<typename Char >
FMT_CONSTEXPR auto	check_char_specs (const format_specs< Char > &specs) -> bool
template<typename... Args, typename Char >
FMT_CONSTEXPR auto	get_arg_index_by_name (basic_string_view< Char > name) -> int
template<typename... , typename S , FMT_ENABLE_IF(!is_compile_string< S >::value) >
FMT_INLINE void	check_format_string (const S &)
template<typename... Args, typename S , FMT_ENABLE_IF(is_compile_string< S >::value) >
void	check_format_string (S format_str)
FMT_API void	vprint_mojibake (std::FILE *, string_view, format_args)
static bool	little_endianness (int num=1) noexcept
	determine system byte order More...
template<typename IteratorType >
iterator_input_adapter_factory< IteratorType >::adapter_type	input_adapter (IteratorType first, IteratorType last)
template<typename ContainerType >
container_input_adapter_factory_impl::container_input_adapter_factory< ContainerType >::adapter_type	input_adapter (const ContainerType &container)
file_input_adapter	input_adapter (std::FILE *file)
input_stream_adapter	input_adapter (std::istream &stream)
input_stream_adapter	input_adapter (std::istream &&stream)
template<typename CharT , typename std::enable_if< std::is_pointer< CharT >::value &&!std::is_array< CharT >::value &&std::is_integral< typename std::remove_pointer< CharT >::type >::value &&sizeof(typename std::remove_pointer< CharT >::type)==1, int >::type = 0>
contiguous_bytes_input_adapter	input_adapter (CharT b)
template<typename T , std::size_t N>
auto	input_adapter (T(&array)[N]) -> decltype(input_adapter(array, array+N))
template<typename string_type >
void	int_to_string (string_type &target, std::size_t value)
template<std::size_t N, typename IteratorType , enable_if_t< N==0, int > = 0>
auto	get (const wpi::detail::iteration_proxy_value< IteratorType > &i) -> decltype(i.key())
std::size_t	concat_length ()
template<typename... Args>
std::size_t	concat_length (const char *cstr, Args &&... rest)
template<typename StringType , typename... Args>
std::size_t	concat_length (const StringType &str, Args &&... rest)
template<typename... Args>
std::size_t	concat_length (const char, Args &&... rest)
template<typename OutStringType >
void	concat_into (OutStringType &)
template<typename OutStringType , typename Arg , typename... Args, enable_if_t< !detect_string_can_append< OutStringType, Arg >::value &&detect_string_can_append_op< OutStringType, Arg >::value, int > = 0>
void	concat_into (OutStringType &out, Arg &&arg, Args &&... rest)
template<typename OutStringType , typename Arg , typename... Args, enable_if_t< !detect_string_can_append< OutStringType, Arg >::value &&!detect_string_can_append_op< OutStringType, Arg >::value &&detect_string_can_append_iter< OutStringType, Arg >::value, int > = 0>
void	concat_into (OutStringType &out, const Arg &arg, Args &&... rest)
template<typename OutStringType = std::string, typename... Args>
OutStringType	concat (Args &&... args)
template<typename FloatType >
JSON_HEDLEY_RETURNS_NON_NULL char *	to_chars (char *first, const char *last, FloatType value)
	generates a decimal representation of the floating-point number value in [first, last). More...
template<typename BasicJsonType >
void	from_json (const BasicJsonType &j, typename std::nullptr_t &n)
template<typename BasicJsonType , typename ArithmeticType , enable_if_t< std::is_arithmetic< ArithmeticType >::value &&!std::is_same< ArithmeticType, typename BasicJsonType::boolean_t >::value, int > = 0>
void	get_arithmetic_value (const BasicJsonType &j, ArithmeticType &val)
template<typename BasicJsonType >
void	from_json (const BasicJsonType &j, typename BasicJsonType::boolean_t &b)
template<typename BasicJsonType >
void	from_json (const BasicJsonType &j, typename BasicJsonType::string_t &s)
template<typename BasicJsonType , typename StringType , enable_if_t< std::is_assignable< StringType &, const typename BasicJsonType::string_t >::value &&is_detected_exact< typename BasicJsonType::string_t::value_type, value_type_t, StringType >::value &&!std::is_same< typename BasicJsonType::string_t, StringType >::value &&!is_json_ref< StringType >::value, int > = 0>
void	from_json (const BasicJsonType &j, StringType &s)
template<typename BasicJsonType >
void	from_json (const BasicJsonType &j, typename BasicJsonType::number_float_t &val)
template<typename BasicJsonType >
void	from_json (const BasicJsonType &j, typename BasicJsonType::number_unsigned_t &val)
template<typename BasicJsonType >
void	from_json (const BasicJsonType &j, typename BasicJsonType::number_integer_t &val)
template<typename BasicJsonType , typename EnumType , enable_if_t< std::is_enum< EnumType >::value, int > = 0>
void	from_json (const BasicJsonType &j, EnumType &e)
template<typename BasicJsonType , typename T , typename Allocator , enable_if_t< is_getable< BasicJsonType, T >::value, int > = 0>
void	from_json (const BasicJsonType &j, std::forward_list< T, Allocator > &l)
template<typename BasicJsonType , typename T , enable_if_t< is_getable< BasicJsonType, T >::value, int > = 0>
void	from_json (const BasicJsonType &j, std::valarray< T > &l)
template<typename BasicJsonType , typename T , std::size_t N>
auto	from_json (const BasicJsonType &j, T(&arr)[N]) -> decltype(j.template get< T >(), void())
template<typename BasicJsonType >
void	from_json_array_impl (const BasicJsonType &j, typename BasicJsonType::array_t &arr, priority_tag< 3 >)
template<typename BasicJsonType , typename T , std::size_t N>
auto	from_json_array_impl (const BasicJsonType &j, std::array< T, N > &arr, priority_tag< 2 >) -> decltype(j.template get< T >(), void())
template<typename BasicJsonType , typename ConstructibleArrayType , enable_if_t< std::is_assignable< ConstructibleArrayType &, ConstructibleArrayType >::value, int > = 0>
auto	from_json_array_impl (const BasicJsonType &j, ConstructibleArrayType &arr, priority_tag< 1 >) -> decltype(arr.reserve(std::declval< typename ConstructibleArrayType::size_type >()), j.template get< typename ConstructibleArrayType::value_type >(), void())
template<typename BasicJsonType , typename ConstructibleArrayType , enable_if_t< std::is_assignable< ConstructibleArrayType &, ConstructibleArrayType >::value, int > = 0>
void	from_json_array_impl (const BasicJsonType &j, ConstructibleArrayType &arr, priority_tag< 0 >)
template<typename BasicJsonType , typename ConstructibleArrayType , enable_if_t< is_constructible_array_type< BasicJsonType, ConstructibleArrayType >::value &&!is_constructible_object_type< BasicJsonType, ConstructibleArrayType >::value &&!is_constructible_string_type< BasicJsonType, ConstructibleArrayType >::value &&!std::is_same< ConstructibleArrayType, typename BasicJsonType::binary_t >::value &&!is_basic_json< ConstructibleArrayType >::value, int > = 0>
auto	from_json (const BasicJsonType &j, ConstructibleArrayType &arr) -> decltype(from_json_array_impl(j, arr, priority_tag< 3 > {}), j.template get< typename ConstructibleArrayType::value_type >(), void())
template<typename BasicJsonType , typename T , std::size_t... Idx>
std::array< T, sizeof...(Idx)>	from_json_inplace_array_impl (BasicJsonType &&j, identity_tag< std::array< T, sizeof...(Idx)> >, index_sequence< Idx... >)
template<typename BasicJsonType , typename T , std::size_t N>
auto	from_json (BasicJsonType &&j, identity_tag< std::array< T, N > > tag) -> decltype(from_json_inplace_array_impl(std::forward< BasicJsonType >(j), tag, make_index_sequence< N > {}))
template<typename BasicJsonType >
void	from_json (const BasicJsonType &j, typename BasicJsonType::binary_t &bin)
template<typename BasicJsonType , typename ConstructibleObjectType , enable_if_t< is_constructible_object_type< BasicJsonType, ConstructibleObjectType >::value, int > = 0>
void	from_json (const BasicJsonType &j, ConstructibleObjectType &obj)
template<typename BasicJsonType , typename ArithmeticType , enable_if_t< std::is_arithmetic< ArithmeticType >::value &&!std::is_same< ArithmeticType, typename BasicJsonType::number_unsigned_t >::value &&!std::is_same< ArithmeticType, typename BasicJsonType::number_integer_t >::value &&!std::is_same< ArithmeticType, typename BasicJsonType::number_float_t >::value &&!std::is_same< ArithmeticType, typename BasicJsonType::boolean_t >::value, int > = 0>
void	from_json (const BasicJsonType &j, ArithmeticType &val)
template<typename BasicJsonType , typename... Args, std::size_t... Idx>
std::tuple< Args... >	from_json_tuple_impl_base (BasicJsonType &&j, index_sequence< Idx... >)
template<typename BasicJsonType , class A1 , class A2 >
std::pair< A1, A2 >	from_json_tuple_impl (BasicJsonType &&j, identity_tag< std::pair< A1, A2 > >, priority_tag< 0 >)
template<typename BasicJsonType , typename A1 , typename A2 >
void	from_json_tuple_impl (BasicJsonType &&j, std::pair< A1, A2 > &p, priority_tag< 1 >)
template<typename BasicJsonType , typename... Args>
std::tuple< Args... >	from_json_tuple_impl (BasicJsonType &&j, identity_tag< std::tuple< Args... > >, priority_tag< 2 >)
template<typename BasicJsonType , typename... Args>
void	from_json_tuple_impl (BasicJsonType &&j, std::tuple< Args... > &t, priority_tag< 3 >)
template<typename BasicJsonType , typename TupleRelated >
auto	from_json (BasicJsonType &&j, TupleRelated &&t) -> decltype(from_json_tuple_impl(std::forward< BasicJsonType >(j), std::forward< TupleRelated >(t), priority_tag< 3 > {}))
template<typename BasicJsonType , typename Key , typename Value , typename Compare , typename Allocator , typename = enable_if_t < !std::is_constructible < typename BasicJsonType::string_t, Key >::value >>
void	from_json (const BasicJsonType &j, std::map< Key, Value, Compare, Allocator > &m)
template<typename BasicJsonType , typename Key , typename Value , typename Hash , typename KeyEqual , typename Allocator , typename = enable_if_t < !std::is_constructible < typename BasicJsonType::string_t, Key >::value >>
void	from_json (const BasicJsonType &j, std::unordered_map< Key, Value, Hash, KeyEqual, Allocator > &m)
template<typename BasicJsonType , typename T , enable_if_t< std::is_same< T, typename BasicJsonType::boolean_t >::value, int > = 0>
void	to_json (BasicJsonType &j, T b) noexcept
template<typename BasicJsonType , typename BoolRef , enable_if_t<((std::is_same< std::vector< bool >::reference, BoolRef >::value &&!std::is_same< std::vector< bool >::reference, typename BasicJsonType::boolean_t & >::value)||(std::is_same< std::vector< bool >::const_reference, BoolRef >::value &&!std::is_same< detail::uncvref_t< std::vector< bool >::const_reference >, typename BasicJsonType::boolean_t >::value)) &&std::is_convertible< const BoolRef &, typename BasicJsonType::boolean_t >::value, int > = 0>
void	to_json (BasicJsonType &j, const BoolRef &b) noexcept
template<typename BasicJsonType , typename CompatibleString , enable_if_t< std::is_constructible< typename BasicJsonType::string_t, CompatibleString >::value, int > = 0>
void	to_json (BasicJsonType &j, const CompatibleString &s)
template<typename BasicJsonType >
void	to_json (BasicJsonType &j, typename BasicJsonType::string_t &&s)
template<typename BasicJsonType , typename FloatType , enable_if_t< std::is_floating_point< FloatType >::value, int > = 0>
void	to_json (BasicJsonType &j, FloatType val) noexcept
template<typename BasicJsonType , typename CompatibleNumberUnsignedType , enable_if_t< is_compatible_integer_type< typename BasicJsonType::number_unsigned_t, CompatibleNumberUnsignedType >::value, int > = 0>
void	to_json (BasicJsonType &j, CompatibleNumberUnsignedType val) noexcept
template<typename BasicJsonType , typename CompatibleNumberIntegerType , enable_if_t< is_compatible_integer_type< typename BasicJsonType::number_integer_t, CompatibleNumberIntegerType >::value, int > = 0>
void	to_json (BasicJsonType &j, CompatibleNumberIntegerType val) noexcept
template<typename BasicJsonType , typename EnumType , enable_if_t< std::is_enum< EnumType >::value, int > = 0>
void	to_json (BasicJsonType &j, EnumType e) noexcept
template<typename BasicJsonType >
void	to_json (BasicJsonType &j, const std::vector< bool > &e)
template<typename BasicJsonType , typename CompatibleArrayType , enable_if_t< is_compatible_array_type< BasicJsonType, CompatibleArrayType >::value &&!is_compatible_object_type< BasicJsonType, CompatibleArrayType >::value &&!is_compatible_string_type< BasicJsonType, CompatibleArrayType >::value &&!std::is_same< typename BasicJsonType::binary_t, CompatibleArrayType >::value &&!is_basic_json< CompatibleArrayType >::value, int > = 0>
void	to_json (BasicJsonType &j, const CompatibleArrayType &arr)
template<typename BasicJsonType >
void	to_json (BasicJsonType &j, const typename BasicJsonType::binary_t &bin)
template<typename BasicJsonType , typename T , enable_if_t< std::is_convertible< T, BasicJsonType >::value, int > = 0>
void	to_json (BasicJsonType &j, const std::valarray< T > &arr)
template<typename BasicJsonType >
void	to_json (BasicJsonType &j, typename BasicJsonType::array_t &&arr)
template<typename BasicJsonType , typename CompatibleObjectType , enable_if_t< is_compatible_object_type< BasicJsonType, CompatibleObjectType >::value &&!is_basic_json< CompatibleObjectType >::value, int > = 0>
void	to_json (BasicJsonType &j, const CompatibleObjectType &obj)
template<typename BasicJsonType >
void	to_json (BasicJsonType &j, typename BasicJsonType::object_t &&obj)
template<typename BasicJsonType , typename T , std::size_t N, enable_if_t< !std::is_constructible< typename BasicJsonType::string_t, const T(&)[N]>::value, int > = 0>
void	to_json (BasicJsonType &j, const T(&arr)[N])
template<typename BasicJsonType , typename T1 , typename T2 , enable_if_t< std::is_constructible< BasicJsonType, T1 >::value &&std::is_constructible< BasicJsonType, T2 >::value, int > = 0>
void	to_json (BasicJsonType &j, const std::pair< T1, T2 > &p)
template<typename BasicJsonType , typename T , enable_if_t< std::is_same< T, iteration_proxy_value< typename BasicJsonType::iterator > >::value, int > = 0>
void	to_json (BasicJsonType &j, const T &b)
template<typename BasicJsonType , typename Tuple , std::size_t... Idx>
void	to_json_tuple_impl (BasicJsonType &j, const Tuple &t, index_sequence< Idx... >)
bool	operator< (const value_t lhs, const value_t rhs) noexcept
	comparison operator for JSON types More...
std::size_t	combine (std::size_t seed, std::size_t h) noexcept
template<typename BasicJsonType >
std::size_t	hash (const BasicJsonType &j)
	hash a JSON value More...
template<typename StringType >
void	replace_substring (StringType &s, const StringType &f, const StringType &t)
	replace all occurrences of a substring by another string More...
template<typename StringType >
StringType	escape (StringType s)
	string escaping as described in RFC 6901 (Sect. 4) More...
template<typename StringType >
static void	unescape (StringType &s)
	string unescaping as described in RFC 6901 (Sect. 4) More...
template<typename T , typename... Args>
constexpr std::array< T, sizeof...(Args)>	make_array (Args &&... args)
template<typename T , typename U , enable_if_t< !std::is_same< T, U >::value, int > = 0>
T	conditional_static_cast (U value)
template<typename OfType , typename T >
constexpr bool	value_in_range_of (T val)

Variables
constexpr FMT_INLINE_VARIABLE uint32_t	invalid_code_point = ~uint32_t()

Detailed Description

detail namespace with internal helper functions

This namespace collects functions that should not be exposed, implementations of some basic_json methods, and meta-programming helpers.

Since

version 2.1.0

Typedef Documentation

actual_object_comparator_t

template<typename BasicJsonType >

using detail::actual_object_comparator_t = typedef typename actual_object_comparator<BasicJsonType>::type

all_integral

template<typename... Types>

using detail::all_integral = typedef conjunction<std::is_integral<Types>...>

all_signed

template<typename... Types>

using detail::all_signed = typedef conjunction<std::is_signed<Types>...>

all_unsigned

template<typename... Types>

using detail::all_unsigned = typedef conjunction<std::is_unsigned<Types>...>

binary_function_t

template<typename T , typename Binary >

using detail::binary_function_t = typedef decltype(std::declval<T&>().binary(std::declval<Binary&>()))

bool_constant

template<bool Value>

using detail::bool_constant = typedef std::integral_constant<bool, Value>

boolean_function_t

template<typename T >

using detail::boolean_function_t = typedef decltype(std::declval<T&>().boolean(std::declval<bool>()))

buffer_appender

template<typename T >

using detail::buffer_appender = typedef conditional_t<std::is_same<T, char>::value, appender, std::back_insert_iterator<buffer<T> >>

contiguous_bytes_input_adapter

using detail::contiguous_bytes_input_adapter = typedef decltype(input_adapter(std::declval<const char*>(), std::declval<const char*>()))

convert_float_result

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

using detail::convert_float_result = typedef conditional_t<std::is_same<T, float>::value || doublish, double, T>

detect_erase_with_key_type

template<typename ObjectType , typename KeyType >

using detail::detect_erase_with_key_type = typedef decltype(std::declval<ObjectType&>().erase(std::declval<KeyType>()))

detect_is_transparent

template<typename T >

using detail::detect_is_transparent = typedef typename T::is_transparent

detect_key_compare

template<typename T >

using detail::detect_key_compare = typedef typename T::key_compare

detect_string_can_append

template<typename StringType , typename Arg >

using detail::detect_string_can_append = typedef is_detected<string_can_append, StringType, Arg>

detect_string_can_append_data

template<typename StringType , typename Arg >

using detail::detect_string_can_append_data = typedef is_detected<string_can_append_data, StringType, Arg>

detect_string_can_append_iter

template<typename StringType , typename Arg >

using detail::detect_string_can_append_iter = typedef is_detected<string_can_append_iter, StringType, Arg>

detect_string_can_append_op

template<typename StringType , typename Arg >

using detail::detect_string_can_append_op = typedef is_detected<string_can_append_op, StringType, Arg>

detected_or

template<class Default , template< class... > class Op, class... Args>

using detail::detected_or = typedef detector<Default, void, Op, Args...>

detected_or_t

template<class Default , template< class... > class Op, class... Args>

using detail::detected_or_t = typedef typename detected_or<Default, Op, Args...>::type

detected_t

template<template< class... > class Op, class... Args>

using detail::detected_t = typedef typename detector<nonesuch, void, Op, Args...>::type

difference_type_t

template<typename T >

using detail::difference_type_t = typedef typename T::difference_type

enable_if_t

template<bool B, typename T = void>

using detail::enable_if_t = typedef typename std::enable_if<B, T>::type

end_array_function_t

template<typename T >

using detail::end_array_function_t = typedef decltype(std::declval<T&>().end_array())

end_object_function_t

template<typename T >

using detail::end_object_function_t = typedef decltype(std::declval<T&>().end_object())

float128

using detail::float128 = typedef void

format_as_t

template<typename T >

using detail::format_as_t = typedef typename format_as_result<T>::type

format_func

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

fp

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

from_json_function

template<typename T , typename... Args>

using detail::from_json_function = typedef decltype(T::from_json(std::declval<Args>()...))

get_template_function

template<typename T , typename U >

using detail::get_template_function = typedef decltype(std::declval<T>().template get<U>())

has_erase_with_key_type

template<typename BasicJsonType , typename KeyType >

using detail::has_erase_with_key_type = typedef typename std::conditional < is_detected < detect_erase_with_key_type, typename BasicJsonType::object_t, KeyType >::value, std::true_type, std::false_type >::type

index_sequence

template<size_t... N>

using detail::index_sequence = typedef integer_sequence<size_t, Ints...>

index_sequence_for

template<typename... Ts>

using detail::index_sequence_for = typedef make_index_sequence<sizeof...(Ts)>

is_c_string_uncvref

template<typename T >

using detail::is_c_string_uncvref = typedef is_c_string<uncvref_t<T> >

is_detected

template<template< class... > class Op, class... Args>

using detail::is_detected = typedef typename detector<nonesuch, void, Op, Args...>::value_t

is_detected_convertible

template<class To , template< class... > class Op, class... Args>

using detail::is_detected_convertible = typedef std::is_convertible<detected_t<Op, Args...>, To>

is_detected_exact

template<class Expected , template< class... > class Op, class... Args>

using detail::is_detected_exact = typedef std::is_same<Expected, detected_t<Op, Args...> >

is_exotic_char

template<typename T >

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

is_float128

template<typename T >

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

is_floating_point

template<typename T >

using detail::is_floating_point = typedef bool_constant<std::is_floating_point<T>::value || is_float128<T>::value>

is_integer

template<typename T >

using detail::is_integer = typedef 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_json_pointer

template<typename T >

using detail::is_json_pointer = typedef is_specialization_of<::wpi::json_pointer, uncvref_t<T> >

is_signed

template<typename T >

using detail::is_signed = typedef std::integral_constant<bool, std::numeric_limits<T>::is_signed || std::is_same<T, int128_opt>::value>

is_usable_as_basic_json_key_type

template<typename BasicJsonType , typename KeyTypeCVRef , bool RequireTransparentComparator = true, bool ExcludeObjectKeyType = RequireTransparentComparator, typename KeyType = uncvref_t<KeyTypeCVRef>>

using detail::is_usable_as_basic_json_key_type = typedef typename std::conditional < is_usable_as_key_type<typename BasicJsonType::object_comparator_t, typename BasicJsonType::object_t::key_type, KeyTypeCVRef, RequireTransparentComparator, ExcludeObjectKeyType>::value && !is_json_iterator_of<BasicJsonType, KeyType>::value, std::true_type, std::false_type >::type

is_usable_as_key_type

template<typename Comparator , typename ObjectKeyType , typename KeyTypeCVRef , bool RequireTransparentComparator = true, bool ExcludeObjectKeyType = RequireTransparentComparator, typename KeyType = uncvref_t<KeyTypeCVRef>>

using detail::is_usable_as_key_type = typedef typename std::conditional < is_comparable<Comparator, ObjectKeyType, KeyTypeCVRef>::value && !(ExcludeObjectKeyType && std::is_same<KeyType, ObjectKeyType>::value) && (!RequireTransparentComparator || is_detected <detect_is_transparent, Comparator>::value) && !is_json_pointer<KeyType>::value, std::true_type, std::false_type >::type

iterator_category_t

template<typename T >

using detail::iterator_category_t = typedef typename T::iterator_category

iterator_t

template<typename T >

using detail::iterator_t = typedef enable_if_t<is_range<R>::value, result_of_begin<decltype(std::declval<R&>())> >

key_function_t

template<typename T , typename String >

using detail::key_function_t = typedef decltype(std::declval<T&>().key(std::declval<String&>()))

key_type_t

template<typename T >

using detail::key_type_t = typedef typename T::key_type

long_type

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

make_index_sequence

template<size_t N>

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

make_integer_sequence

template<typename T , T N>

using detail::make_integer_sequence = typedef typename utility_internal::Gen<T, N>::type

make_unsigned_char

template<typename Char >

using detail::make_unsigned_char = typedef typename conditional_t<std::is_integral<Char>::value, std::make_unsigned<Char>, type_identity<uint32_t> >::type

mapped_type_constant

template<typename T , typename Context >

using detail::mapped_type_constant = typedef type_constant<decltype(arg_mapper<Context>().map(std::declval<const T&>())), typename Context::char_type>

mapped_type_t

template<typename T >

using detail::mapped_type_t = typedef typename T::mapped_type

maybe_const_range

template<typename R >

using detail::maybe_const_range = typedef conditional_t<has_const_begin_end<R>::value, const R, R>

never_out_of_range

template<typename OfType , typename T >

using detail::never_out_of_range = typedef std::integral_constant < bool, (std::is_signed<OfType>::value && (sizeof(T) < sizeof(OfType))) || (same_sign<OfType, T>::value && sizeof(OfType) == sizeof(T)) >

null_function_t

template<typename T >

using detail::null_function_t = typedef decltype(std::declval<T&>().null())

number_float_function_t

template<typename T , typename Float , typename String >

using detail::number_float_function_t = typedef decltype(std::declval<T&>().number_float( std::declval<Float>(), std::declval<const String&>()))

number_integer_function_t

template<typename T , typename Integer >

using detail::number_integer_function_t = typedef decltype(std::declval<T&>().number_integer(std::declval<Integer>()))

number_unsigned_function_t

template<typename T , typename Unsigned >

using detail::number_unsigned_function_t = typedef decltype(std::declval<T&>().number_unsigned(std::declval<Unsigned>()))

output_adapter_t

template<typename CharType >

using detail::output_adapter_t = typedef std::shared_ptr<output_adapter_protocol<CharType> >

a type to simplify interfaces

parse_error_function_t

template<typename T , typename Exception >

using detail::parse_error_function_t = typedef decltype(std::declval<T&>().parse_error( std::declval<std::size_t>(), std::declval<const std::string&>(), std::declval<const Exception&>()))

parser_callback_t

template<typename BasicJsonType >

using detail::parser_callback_t = typedef std::function<bool(int , parse_event_t , BasicJsonType& )>

pointer_t

template<typename T >

using detail::pointer_t = typedef typename T::pointer

range_format_constant

template<range_format K>

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

range_formatter_type

template<typename Char , typename Element >

using detail::range_formatter_type = typedef formatter<remove_cvref_t<decltype(range_mapper<buffer_context<Char> >{}.map( std::declval<Element>()))>, Char>

range_reference_type

template<typename Range >

using detail::range_reference_type = typedef decltype(*detail::range_begin(std::declval<Range&>()))

range_value_t

template<typename T >

using detail::range_value_t = typedef value_type_t<iterator_traits<iterator_t<T> >>

reference_t

template<typename T >

using detail::reference_t = typedef typename T::reference

reserve_iterator

template<typename OutputIt >

using detail::reserve_iterator = typedef remove_reference_t<decltype(reserve(std::declval<OutputIt&>(), 0))>

same_sign

template<typename... Types>

using detail::same_sign = typedef std::integral_constant < bool, all_signed<Types...>::value || all_unsigned<Types...>::value >

sentinel_t

template<typename T >

using detail::sentinel_t = typedef decltype(std::end(std::declval<T&>()))

start_array_function_t

template<typename T >

using detail::start_array_function_t = typedef decltype(std::declval<T&>().start_array(std::declval<std::size_t>()))

start_object_function_t

template<typename T >

using detail::start_object_function_t = typedef decltype(std::declval<T&>().start_object(std::declval<std::size_t>()))

string_can_append

template<typename StringType , typename Arg >

using detail::string_can_append = typedef decltype(std::declval<StringType&>().append(std::declval < Arg && > ()))

string_can_append_data

template<typename StringType , typename Arg >

using detail::string_can_append_data = typedef decltype(std::declval<StringType&>().append(std::declval<const Arg&>().data(), std::declval<const Arg&>().size()))

string_can_append_iter

template<typename StringType , typename Arg >

using detail::string_can_append_iter = typedef decltype(std::declval<StringType&>().append(std::declval<const Arg&>().begin(), std::declval<const Arg&>().end()))

string_can_append_op

template<typename StringType , typename Arg >

using detail::string_can_append_op = typedef decltype(std::declval<StringType&>() += std::declval < Arg && > ())

string_function_t

template<typename T , typename String >

using detail::string_function_t = typedef decltype(std::declval<T&>().string(std::declval<String&>()))

to_json_function

template<typename T , typename... Args>

using detail::to_json_function = typedef decltype(T::to_json(std::declval<Args>()...))

tuple_index_sequence

template<typename T >

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

uint128_t

using detail::uint128_t = typedef 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 = typedef 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 = typedef conditional_t<num_bits<T>() <= 64, uint64_t, uint128_t>

uintptr_t

using detail::uintptr_t = typedef uint128_t

ulong_type

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

uncvref_t

template<typename T >

using detail::uncvref_t = typedef typename std::remove_cv<typename std::remove_reference<T>::type>::type

uncvref_type

template<typename Range >

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

value_type_t

template<typename T >

using detail::value_type_t = typedef typename T::value_type

void_t

template<typename... >

using detail::void_t = typedef typename make_void<Ts...>::type

Enumeration Type Documentation

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

arg_id_kind

enum class detail::arg_id_kind

strong

Enumerator
none
index
name

cbor_tag_handler_t

enum class detail::cbor_tag_handler_t

strong

how to treat CBOR tags

Enumerator
error	throw a parse_error exception in case of a tag
ignore	ignore tags
store	store tags as binary type

char8_type

enum detail::char8_type : unsigned char

dragon

enum detail::dragon

Enumerator
predecessor_closer
fixup
fixed

error_handler_t

enum class detail::error_handler_t

strong

how to treat decoding errors

Enumerator
strict	throw a type_error exception in case of invalid UTF-8
replace	replace invalid UTF-8 sequences with U+FFFD
ignore	ignore invalid UTF-8 sequences

float_format

enum class detail::float_format : unsigned char

strong

Enumerator
general
exp
fixed
hex

input_format_t

enum class detail::input_format_t

strong

the supported input formats

Enumerator
json
cbor
msgpack
ubjson
bson
bjdata

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
unspecified
none
zero
space

parse_event_t

enum class detail::parse_event_t : std::uint8_t

strong

Enumerator
object_start	the parser read { and started to process a JSON object
object_end	the parser read } and finished processing a JSON object
array_start	the parser read [ and started to process a JSON array
array_end	the parser read ] and finished processing a JSON array
key	the parser read a key of a value in an object
value	the parser finished reading a JSON value

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

value_t

enum class detail::value_t : std::uint8_t

strong

the JSON type enumeration

This enumeration collects the different JSON types. It is internally used to distinguish the stored values, and the functions basic_json::is_null(), basic_json::is_object(), basic_json::is_array(), basic_json::is_string(), basic_json::is_boolean(), basic_json::is_number() (with basic_json::is_number_integer(), basic_json::is_number_unsigned(), and basic_json::is_number_float()), basic_json::is_discarded(), basic_json::is_primitive(), and basic_json::is_structured() rely on it.

Note

There are three enumeration entries (number_integer, number_unsigned, and number_float), because the library distinguishes these three types for numbers: basic_json::number_unsigned_t is used for unsigned integers, basic_json::number_integer_t is used for signed integers, and basic_json::number_float_t is used for floating-point numbers or to approximate integers which do not fit in the limits of their respective type.

See also

see basic_json::basic_json(const value_t value_type) – create a JSON value with the default value for a given type

Since

version 1.0.0

Enumerator
null	null value
object	object (unordered set of name/value pairs)
array	array (ordered collection of values)
string	string value
boolean	boolean value
number_integer	number value (signed integer)
number_unsigned	number value (unsigned integer)
number_float	number value (floating-point)
binary	binary array (ordered collection of bytes)
discarded	discarded by the parser callback function

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 >

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

constexpr

base_iterator() [2/2]

template<typename Container , FMT_ENABLE_IF(is_contiguous< Container >::value) >

auto detail::base_iterator ( std::back_insert_iterator< Container >  it, typename Container::value_type *    ) -> std::back_insert_iterator<Container>

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()

template<typename Char >

FMT_CONSTEXPR auto detail::check_char_specs

(

const format_specs< Char > &

specs

)

-> bool

check_format_string() [1/2]

template<typename... , typename S , FMT_ENABLE_IF(!is_compile_string< S >::value) >

FMT_INLINE void detail::check_format_string

(

const S &

)

check_format_string() [2/2]

template<typename... Args, typename S , FMT_ENABLE_IF(is_compile_string< S >::value) >

void detail::check_format_string

(

S

format_str

)

code_point_index() [1/3]

template<typename Char >

auto detail::code_point_index ( basic_string_view< Char >  s, size_t  n  ) -> size_t

inline

code_point_index() [2/3]

auto detail::code_point_index ( basic_string_view< char8_type >  s, size_t  n  ) -> size_t

inline

code_point_index() [3/3]

auto detail::code_point_index ( string_view  s, size_t  n  ) -> size_t

inline

code_point_length()

template<typename Char >

FMT_CONSTEXPR auto detail::code_point_length

(

const Char *

begin

)

-> int

combine()

std::size_t detail::combine ( std::size_t  seed, std::size_t  h  )

inlinenoexcept

compute_width() [1/3]

template<typename Char >

auto detail::compute_width ( basic_string_view< Char >  s ) -> size_t

inline

compute_width() [2/3]

auto detail::compute_width ( basic_string_view< char8_type >  s ) -> size_t

inline

compute_width() [3/3]

FMT_CONSTEXPR size_t detail::compute_width ( string_view  s )

inline

concat()

template<typename OutStringType = std::string, typename... Args>

OutStringType detail::concat ( Args &&...  args )

inline

concat_into() [1/3]

template<typename OutStringType >

void detail::concat_into ( OutStringType &  )

inline

concat_into() [2/3]

template<typename OutStringType , typename Arg , typename... Args, enable_if_t< !detect_string_can_append< OutStringType, Arg >::value &&detect_string_can_append_op< OutStringType, Arg >::value, int > = 0>

void detail::concat_into ( OutStringType &  out, Arg &&  arg, Args &&...  rest  )

inline

concat_into() [3/3]

template<typename OutStringType , typename Arg , typename... Args, enable_if_t< !detect_string_can_append< OutStringType, Arg >::value &&!detect_string_can_append_op< OutStringType, Arg >::value &&detect_string_can_append_iter< OutStringType, Arg >::value, int > = 0>

void detail::concat_into ( OutStringType &  out, const Arg &  arg, Args &&...  rest  )

inline

concat_length() [1/4]

std::size_t detail::concat_length ( )

inline

concat_length() [2/4]

template<typename... Args>

std::size_t detail::concat_length ( const char *  cstr, Args &&...  rest  )

inline

concat_length() [3/4]

template<typename... Args>

std::size_t detail::concat_length ( const char  , Args &&...  rest  )

inline

concat_length() [4/4]

template<typename StringType , typename... Args>

std::size_t detail::concat_length ( const StringType &  str, Args &&...  rest  )

inline

conditional_static_cast()

template<typename T , typename U , enable_if_t< !std::is_same< T, U >::value, int > = 0>

T detail::conditional_static_cast

(

U

value

)

const_check()

template<typename T >

constexpr FMT_INLINE auto detail::const_check ( T  value ) -> 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 >

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

constexpr

convert_for_visit()

template<typename T >

auto detail::convert_for_visit

(

T

)

-> monostate

copy() [1/4]

template<typename OutputIt >

auto detail::copy	(	char	ch,
		OutputIt	out
	)		-> OutputIt

copy() [2/4]

template<typename OutputIt >

auto detail::copy	(	const char *	str,
		OutputIt	out
	)		-> OutputIt

copy() [3/4]

template<typename Range , typename OutputIt >

auto detail::copy	(	const Range &	range,
		OutputIt	out
	)		-> OutputIt

copy() [4/4]

template<typename OutputIt >

auto detail::copy	(	wchar_t	ch,
		OutputIt	out
	)		-> OutputIt

copy2()

template<typename Char >

FMT_CONSTEXPR20 FMT_INLINE void detail::copy2	(	Char *	dst,
		const char *	src
	)

copy_str() [1/6]

template<typename Char , typename InputIt >

auto detail::copy_str	(	InputIt	begin,
		InputIt	end,
		appender	out
	)		-> appender

copy_str() [2/6]

template<typename Char , typename InputIt >

FMT_CONSTEXPR counting_iterator detail::copy_str ( InputIt  begin, InputIt  end, counting_iterator  it  )

inline

copy_str() [3/6]

template<typename Char , typename InputIt , typename OutputIt >

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

copy_str() [4/6]

template<typename Char , typename InputIt >

auto detail::copy_str	(	InputIt	begin,
		InputIt	end,
		std::back_insert_iterator< std::string >	out
	)		-> std::back_insert_iterator<std::string>

copy_str() [5/6]

template<typename Char , typename R , typename OutputIt >

FMT_CONSTEXPR auto detail::copy_str	(	R &&	rng,
		OutputIt	out
	)		-> OutputIt

copy_str() [6/6]

template<typename Char , typename T , typename U , FMT_ENABLE_IF( std::is_same< remove_const_t< T >, U >::value &&is_char< U >::value) >

FMT_CONSTEXPR auto detail::copy_str	(	T *	begin,
		T *	end,
		U *	out
	)		-> U*

copy_str_noinline()

template<typename OutChar , typename InputIt , typename OutputIt >

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

copy_unit() [1/2]

template<typename Char , typename OutputIt >

OutputIt detail::copy_unit	(	string_view	unit,
		OutputIt	out,
		Char
	)

copy_unit() [2/2]

template<typename OutputIt >

OutputIt detail::copy_unit	(	string_view	unit,
		OutputIt	out,
		wchar_t
	)

count() [1/2]

template<bool B = false>

constexpr auto detail::count ( ) -> size_t

constexpr

count() [2/2]

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

constexpr auto detail::count ( ) -> size_t

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... Args>

constexpr auto detail::count_named_args ( ) -> size_t

constexpr

count_statically_named_args()

template<typename... Args>

constexpr auto detail::count_statically_named_args ( ) -> size_t

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

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 >

template FMT_API auto detail::decimal_point_impl

(

locale_ref

loc

)

decimal_point_impl() [2/3]

template<typename Char >

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

digits10()

template<typename Int >

constexpr auto detail::digits10 ( ) -> int

constexprnoexcept

digits10< int128_opt >()

template<>

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

constexprnoexcept

digits10< uint128_t >()

template<>

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

constexprnoexcept

digits2()

constexpr const char * detail::digits2 ( size_t  value )

constexpr

do_parse_arg_id()

template<typename Char , typename Handler >

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

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 OutputIt , typename DecimalFP , typename Char , typename Grouping = digit_grouping<Char>>

FMT_CONSTEXPR20 auto detail::do_write_float	(	OutputIt	out,
		const DecimalFP &	f,
		const format_specs< Char > &	specs,
		float_specs	fspecs,
		locale_ref	loc
	)		-> OutputIt

encode_types() [1/2]

template<typename >

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

constexpr

encode_types() [2/2]

template<typename Context , typename Arg , typename... Args>

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

constexpr

equal2() [1/2]

template<typename Char >

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

equal2() [2/2]

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

inline

escape()

template<typename StringType >

StringType detail::escape ( StringType  s )

inline

string escaping as described in RFC 6901 (Sect. 4)

Parameters

[in]

s

string to escape

Returns

escaped string

Note the order of escaping "~" to "~0" and "/" to "~1" is important.

exponent_bias()

template<typename Float >

constexpr auto detail::exponent_bias ( ) -> int

constexpr

exponent_mask()

template<typename Float >

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

constexpr

fill()

template<typename OutputIt , typename Char >

FMT_NOINLINE FMT_CONSTEXPR auto detail::fill	(	OutputIt	it,
		size_t	n,
		const fill_t< Char > &	fill
	)		-> 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>

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

FMT_NOMACRO()

null localtime_r detail::FMT_NOMACRO (   ... )

inline

fmt_safe_duration_cast()

template<typename To , typename FromRep , typename FromPeriod >

To detail::fmt_safe_duration_cast

(

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

from

)

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_decimal() [1/2]

template<typename Char , typename UInt >

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

format_decimal() [2/2]

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

FMT_CONSTEXPR auto detail::format_decimal ( Iterator  out, UInt  value, int  size  ) -> format_decimal_result<Iterator>

inline

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 >

OutputIt detail::format_duration_unit

(

OutputIt

out

)

format_duration_value()

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

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

format_error_code()

FMT_API 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,
		float_specs	specs,
		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,
		int	precision,
		float_specs	specs,
		buffer< char > &	buf
	)

format_uint() [1/2]

template<unsigned BASE_BITS, typename Char , typename UInt >

FMT_CONSTEXPR auto detail::format_uint	(	Char *	buffer,
		UInt	value,
		int	num_digits,
		bool	upper = false
	)		-> Char*

format_uint() [2/2]

template<unsigned BASE_BITS, typename Char , typename It , typename UInt >

FMT_CONSTEXPR auto detail::format_uint ( It  out, UInt  value, int  num_digits, bool  upper = false  ) -> It

inline

format_value()

template<typename Char , typename T >

void detail::format_value	(	buffer< Char > &	buf,
		const T &	value,
		locale_ref	loc = locale_ref()
	)

from_json() [1/19]

template<typename BasicJsonType , typename T , std::size_t N>

auto detail::from_json	(	BasicJsonType &&	j,
		identity_tag< std::array< T, N > >	tag
	)		-> decltype(from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {}))

from_json() [2/19]

template<typename BasicJsonType , typename TupleRelated >

auto detail::from_json	(	BasicJsonType &&	j,
		TupleRelated &&	t
	)		-> decltype(from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {}))

from_json() [3/19]

template<typename BasicJsonType , typename ArithmeticType , enable_if_t< std::is_arithmetic< ArithmeticType >::value &&!std::is_same< ArithmeticType, typename BasicJsonType::number_unsigned_t >::value &&!std::is_same< ArithmeticType, typename BasicJsonType::number_integer_t >::value &&!std::is_same< ArithmeticType, typename BasicJsonType::number_float_t >::value &&!std::is_same< ArithmeticType, typename BasicJsonType::boolean_t >::value, int > = 0>

void detail::from_json ( const BasicJsonType &  j, ArithmeticType &  val  )

inline

from_json() [4/19]

template<typename BasicJsonType , typename ConstructibleArrayType , enable_if_t< is_constructible_array_type< BasicJsonType, ConstructibleArrayType >::value &&!is_constructible_object_type< BasicJsonType, ConstructibleArrayType >::value &&!is_constructible_string_type< BasicJsonType, ConstructibleArrayType >::value &&!std::is_same< ConstructibleArrayType, typename BasicJsonType::binary_t >::value &&!is_basic_json< ConstructibleArrayType >::value, int > = 0>

auto detail::from_json	(	const BasicJsonType &	j,
		ConstructibleArrayType &	arr
	)		-> decltype(from_json_array_impl(j, arr, priority_tag<3> {}), j.template get<typename ConstructibleArrayType::value_type>(), void())

from_json() [5/19]

template<typename BasicJsonType , typename ConstructibleObjectType , enable_if_t< is_constructible_object_type< BasicJsonType, ConstructibleObjectType >::value, int > = 0>

void detail::from_json ( const BasicJsonType &  j, ConstructibleObjectType &  obj  )

inline

from_json() [6/19]

template<typename BasicJsonType , typename EnumType , enable_if_t< std::is_enum< EnumType >::value, int > = 0>

void detail::from_json ( const BasicJsonType &  j, EnumType &  e  )

inline

from_json() [7/19]

template<typename BasicJsonType , typename T , typename Allocator , enable_if_t< is_getable< BasicJsonType, T >::value, int > = 0>

void detail::from_json ( const BasicJsonType &  j, std::forward_list< T, Allocator > &  l  )

inline

from_json() [8/19]

template<typename BasicJsonType , typename Key , typename Value , typename Compare , typename Allocator , typename = enable_if_t < !std::is_constructible < typename BasicJsonType::string_t, Key >::value >>

void detail::from_json ( const BasicJsonType &  j, std::map< Key, Value, Compare, Allocator > &  m  )

inline

from_json() [9/19]

template<typename BasicJsonType , typename Key , typename Value , typename Hash , typename KeyEqual , typename Allocator , typename = enable_if_t < !std::is_constructible < typename BasicJsonType::string_t, Key >::value >>

void detail::from_json ( const BasicJsonType &  j, std::unordered_map< Key, Value, Hash, KeyEqual, Allocator > &  m  )

inline

from_json() [10/19]

template<typename BasicJsonType , typename T , enable_if_t< is_getable< BasicJsonType, T >::value, int > = 0>

void detail::from_json ( const BasicJsonType &  j, std::valarray< T > &  l  )

inline

from_json() [11/19]

template<typename BasicJsonType , typename StringType , enable_if_t< std::is_assignable< StringType &, const typename BasicJsonType::string_t >::value &&is_detected_exact< typename BasicJsonType::string_t::value_type, value_type_t, StringType >::value &&!std::is_same< typename BasicJsonType::string_t, StringType >::value &&!is_json_ref< StringType >::value, int > = 0>

void detail::from_json ( const BasicJsonType &  j, StringType &  s  )

inline

from_json() [12/19]

template<typename BasicJsonType , typename T , std::size_t N>

auto detail::from_json	(	const BasicJsonType &	j,
		T(&)	arr[N]
	)		-> decltype(j.template get<T>(), void())

from_json() [13/19]

template<typename BasicJsonType >

void detail::from_json ( const BasicJsonType &  j, typename BasicJsonType::binary_t &  bin  )

inline

from_json() [14/19]

template<typename BasicJsonType >

void detail::from_json ( const BasicJsonType &  j, typename BasicJsonType::boolean_t &  b  )

inline

from_json() [15/19]

template<typename BasicJsonType >

void detail::from_json ( const BasicJsonType &  j, typename BasicJsonType::number_float_t &  val  )

inline

from_json() [16/19]

template<typename BasicJsonType >

void detail::from_json ( const BasicJsonType &  j, typename BasicJsonType::number_integer_t &  val  )

inline

from_json() [17/19]

template<typename BasicJsonType >

void detail::from_json ( const BasicJsonType &  j, typename BasicJsonType::number_unsigned_t &  val  )

inline

from_json() [18/19]

template<typename BasicJsonType >

void detail::from_json ( const BasicJsonType &  j, typename BasicJsonType::string_t &  s  )

inline

from_json() [19/19]

template<typename BasicJsonType >

void detail::from_json ( const BasicJsonType &  j, typename std::nullptr_t &  n  )

inline

from_json_array_impl() [1/4]

template<typename BasicJsonType , typename ConstructibleArrayType , enable_if_t< std::is_assignable< ConstructibleArrayType &, ConstructibleArrayType >::value, int > = 0>

void detail::from_json_array_impl ( const BasicJsonType &  j, ConstructibleArrayType &  arr, priority_tag< 0 >    )

inline

from_json_array_impl() [2/4]

template<typename BasicJsonType , typename ConstructibleArrayType , enable_if_t< std::is_assignable< ConstructibleArrayType &, ConstructibleArrayType >::value, int > = 0>

auto detail::from_json_array_impl	(	const BasicJsonType &	j,
		ConstructibleArrayType &	arr,
		priority_tag< 1 >
	)		-> decltype( arr.reserve(std::declval<typename ConstructibleArrayType::size_type>()), j.template get<typename ConstructibleArrayType::value_type>(), void())

from_json_array_impl() [3/4]

template<typename BasicJsonType , typename T , std::size_t N>

auto detail::from_json_array_impl	(	const BasicJsonType &	j,
		std::array< T, N > &	arr,
		priority_tag< 2 >
	)		-> decltype(j.template get<T>(), void())

from_json_array_impl() [4/4]

template<typename BasicJsonType >

void detail::from_json_array_impl ( const BasicJsonType &  j, typename BasicJsonType::array_t &  arr, priority_tag< 3 >    )

inline

from_json_inplace_array_impl()

template<typename BasicJsonType , typename T , std::size_t... Idx>

std::array< T, sizeof...(Idx)> detail::from_json_inplace_array_impl	(	BasicJsonType &&	j,
		identity_tag< std::array< T, sizeof...(Idx)> >	,
		index_sequence< Idx... >
	)

from_json_tuple_impl() [1/4]

template<typename BasicJsonType , class A1 , class A2 >

std::pair< A1, A2 > detail::from_json_tuple_impl	(	BasicJsonType &&	j,
		identity_tag< std::pair< A1, A2 > >	,
		priority_tag< 0 >
	)

from_json_tuple_impl() [2/4]

template<typename BasicJsonType , typename... Args>

std::tuple< Args... > detail::from_json_tuple_impl	(	BasicJsonType &&	j,
		identity_tag< std::tuple< Args... > >	,
		priority_tag< 2 >
	)

from_json_tuple_impl() [3/4]

template<typename BasicJsonType , typename A1 , typename A2 >

void detail::from_json_tuple_impl ( BasicJsonType &&  j, std::pair< A1, A2 > &  p, priority_tag< 1 >    )

inline

from_json_tuple_impl() [4/4]

template<typename BasicJsonType , typename... Args>

void detail::from_json_tuple_impl ( BasicJsonType &&  j, std::tuple< Args... > &  t, priority_tag< 3 >    )

inline

from_json_tuple_impl_base()

template<typename BasicJsonType , typename... Args, std::size_t... Idx>

std::tuple< Args... > detail::from_json_tuple_impl_base	(	BasicJsonType &&	j,
		index_sequence< Idx... >
	)

fwrite_fully()

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

inline

get()

template<std::size_t N, typename IteratorType , enable_if_t< N==0, int > = 0>

auto detail::get

(

const wpi::detail::iteration_proxy_value< IteratorType > &

i

)

-> decltype(i.key())

get_arg()

template<typename Context , typename ID >

FMT_CONSTEXPR auto detail::get_arg	(	Context &	ctx,
		ID	id
	)		-> decltype(ctx.arg(id))

get_arg_index_by_name()

template<typename... Args, typename Char >

FMT_CONSTEXPR auto detail::get_arg_index_by_name

(

basic_string_view< Char >

name

)

-> int

get_arithmetic_value()

template<typename BasicJsonType , typename ArithmeticType , enable_if_t< std::is_arithmetic< ArithmeticType >::value &&!std::is_same< ArithmeticType, typename BasicJsonType::boolean_t >::value, int > = 0>

void detail::get_arithmetic_value	(	const BasicJsonType &	j,
		ArithmeticType &	val
	)

get_buffer() [1/2]

template<typename T , typename OutputIt >

auto detail::get_buffer

(

OutputIt

out

)

-> iterator_buffer<OutputIt, T>

get_buffer() [2/2]

template<typename T , typename Buf , FMT_ENABLE_IF(std::is_base_of< buffer< char >, Buf >::value) >

auto detail::get_buffer

(

std::back_insert_iterator< Buf >

out

)

-> buffer<char>&

get_classic_locale()

const std::locale & detail::get_classic_locale ( )

inline

get_container()

template<typename Container >

auto detail::get_container ( std::back_insert_iterator< Container >  it ) -> Container&

inline

get_data() [1/2]

template<typename Container >

auto detail::get_data ( Container &  c ) -> typename Container::value_type*

inline

get_data() [2/2]

template<typename Char >

auto detail::get_data ( std::basic_string< Char > &  s ) -> Char*

inline

get_dynamic_spec()

template<template< typename > class Handler, typename FormatArg , typename ErrorHandler >

FMT_CONSTEXPR auto detail::get_dynamic_spec	(	FormatArg	arg,
		ErrorHandler	eh
	)		-> int

get_iterator() [1/2]

template<typename Buf , typename OutputIt >

FMT_INLINE 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) >

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

inline

get_significand_size() [1/2]

constexpr 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 const char * detail::get_units ( )

inline

gmtime_r()

null detail::gmtime_r (   ... )

inline

gmtime_s()

null detail::gmtime_s (   ... )

inline

handle_dynamic_spec()

template<template< typename > class Handler, typename Context >

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

has_const_formatter()

template<typename T , typename Context >

constexpr auto detail::has_const_formatter ( ) -> bool

constexpr

has_const_formatter_impl() [1/2]

template<typename Context >

constexpr auto detail::has_const_formatter_impl (   ... ) -> bool

constexpr

has_const_formatter_impl() [2/2]

template<typename Context , typename T >

constexpr auto detail::has_const_formatter_impl ( T *  ) -> decltype(typename Context::template formatter_type<T>().format( std::declval<const T&>(), std::declval<Context&>()), true)

constexpr

has_implicit_bit()

template<typename Float >

constexpr bool detail::has_implicit_bit ( )

constexpr

hash()

template<typename BasicJsonType >

std::size_t detail::hash

(

const BasicJsonType &

j

)

hash a JSON value

The hash function tries to rely on std::hash where possible. Furthermore, the type of the JSON value is taken into account to have different hash values for null, 0, 0U, and false, etc.

Template Parameters

BasicJsonType

basic_json specialization

Parameters

j	JSON value to hash

Returns

hash value of j

ignore_unused()

template<typename... T>

FMT_CONSTEXPR void detail::ignore_unused

(

const T &

...

)

in()

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

constexpr

init_named_args() [1/3]

template<typename Char >

void detail::init_named_args ( named_arg_info< Char > *  , int  , int    )

inline

init_named_args() [2/3]

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

void detail::init_named_args	(	named_arg_info< Char > *	named_args,
		int	arg_count,
		int	named_arg_count,
		const T &	arg,
		const Tail &...	args
	)

init_named_args() [3/3]

template<typename... Args>

FMT_CONSTEXPR FMT_INLINE void detail::init_named_args	(	std::nullptr_t	,
		int	,
		int	,
		const Args &	...
	)

input_adapter() [1/7]

template<typename CharT , typename std::enable_if< std::is_pointer< CharT >::value &&!std::is_array< CharT >::value &&std::is_integral< typename std::remove_pointer< CharT >::type >::value &&sizeof(typename std::remove_pointer< CharT >::type)==1, int >::type = 0>

contiguous_bytes_input_adapter detail::input_adapter

(

CharT

b

)

input_adapter() [2/7]

template<typename ContainerType >

container_input_adapter_factory_impl::container_input_adapter_factory< ContainerType >::adapter_type detail::input_adapter

(

const ContainerType &

container

)

input_adapter() [3/7]

template<typename IteratorType >

iterator_input_adapter_factory< IteratorType >::adapter_type detail::input_adapter	(	IteratorType	first,
		IteratorType	last
	)

input_adapter() [4/7]

file_input_adapter detail::input_adapter ( std::FILE *  file )

inline

input_adapter() [5/7]

input_stream_adapter detail::input_adapter ( std::istream &&  stream )

inline

input_adapter() [6/7]

input_stream_adapter detail::input_adapter ( std::istream &  stream )

inline

input_adapter() [7/7]

template<typename T , std::size_t N>

auto detail::input_adapter

(

T(&)

array[N]

)

-> decltype(input_adapter(array, array + N))

int_to_string()

template<typename string_type >

void detail::int_to_string	(	string_type &	target,
		std::size_t	value
	)

is_arithmetic_type()

constexpr bool detail::is_arithmetic_type ( type  t )

constexpr

is_big_endian()

auto detail::is_big_endian ( ) -> bool

inline

is_constant_evaluated()

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

constexprnoexcept

is_integral_type()

constexpr bool detail::is_integral_type ( type  t )

constexpr

is_name_start()

template<typename Char >

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

constexpr

is_negative()

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

constexpr 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_API auto detail::is_printable

(

uint32_t

cp

)

-> bool

is_supported_floating_point()

template<typename T >

FMT_CONSTEXPR auto detail::is_supported_floating_point

(

T

)

-> bool

is_utf8()

FMT_CONSTEXPR auto detail::is_utf8 ( ) -> bool

inline

isfinite() [1/3]

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

FMT_CONSTEXPR20 bool detail::isfinite

(

T

value

)

isfinite() [2/3]

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

FMT_CONSTEXPR bool detail::isfinite

(

T

value

)

isfinite() [3/3]

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

bool detail::isfinite ( T  )

inline

isnan()

template<typename T >

constexpr bool detail::isnan ( T  value )

constexpr

little_endianness()

static bool detail::little_endianness ( int  num = 1 )

inlinestaticnoexcept

determine system byte order

Returns

true if and only if system's byte order is little endian

Note

from https://stackoverflow.com/a/1001328/266378

localtime_s()

null detail::localtime_s (   ... )

inline

make_arg() [1/3]

template<typename Context , typename T >

FMT_CONSTEXPR auto detail::make_arg

(

T &

val

)

-> basic_format_arg<Context>

make_arg() [2/3]

template<bool PACKED, typename Context , typename T , FMT_ENABLE_IF(!PACKED) >

FMT_CONSTEXPR auto detail::make_arg ( T &  val ) -> basic_format_arg<Context>

inline

make_arg() [3/3]

template<bool PACKED, typename Context , typename T , FMT_ENABLE_IF(PACKED) >

FMT_CONSTEXPR FMT_INLINE auto detail::make_arg

(

T &

val

)

-> value<Context>

make_arg_formatter()

template<typename Char >

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

make_array()

template<typename T , typename... Args>

constexpr std::array< T, sizeof...(Args)> detail::make_array ( Args &&...  args )

inlineconstexpr

make_background_color()

template<typename Char >

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

noexcept

make_emphasis()

template<typename Char >

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

noexcept

make_foreground_color()

template<typename Char >

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

noexcept

make_write_int_arg()

template<typename T >

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

max_value()

template<typename T >

constexpr 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) >

T detail::mod ( T  x, int  y  )

inline

multiply()

FMT_CONSTEXPR uint64_t detail::multiply ( uint64_t  lhs, uint64_t  rhs  )

inline

needs_escape()

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

inline

normalize()

template<int SHIFT = 0, typename F >

FMT_CONSTEXPR basic_fp< F > detail::normalize

(

basic_fp< F >

value

)

num_bits()

template<typename T >

constexpr auto detail::num_bits ( ) -> int

constexpr

num_bits< int128_opt >()

template<>

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

constexpr

num_bits< uint128_t >()

template<>

constexpr auto detail::num_bits< uint128_t > ( ) -> int

constexpr

num_significand_bits()

template<typename Float >

constexpr int detail::num_significand_bits ( )

constexpr

operator*()

FMT_CONSTEXPR fp detail::operator* ( fp  x, fp  y  )

inline

operator<()

bool detail::operator< ( const value_t  lhs, const value_t  rhs  )

inlinenoexcept

comparison operator for JSON types

Returns an ordering that is similar to Python:

• order: null < boolean < number < object < array < string < binary
• furthermore, each type is not smaller than itself
• discarded values are not comparable
• binary is represented as a b"" string in python and directly comparable to a string; however, making a binary array directly comparable with a string would be surprising behavior in a JSON file.

Since

version 1.0.0

operator==()

template<typename F >

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

inline

parse_align() [1/2]

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

inline

parse_align() [2/2]

template<typename Char >

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

parse_arg_id()

template<typename Char , typename Handler >

FMT_CONSTEXPR FMT_INLINE 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 const Char * detail::parse_chrono_format	(	const Char *	begin,
		const Char *	end,
		Handler &&	handler
	)

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,
		basic_format_parse_context< Char > &	ctx
	)		-> const Char*

parse_flags()

template<typename Char >

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

parse_float_type_spec()

template<typename ErrorHandler = error_handler, typename Char >

FMT_CONSTEXPR auto detail::parse_float_type_spec	(	const format_specs< Char > &	specs,
		ErrorHandler &&	eh = {}
	)		-> float_specs

parse_format_specs() [1/2]

template<typename Char >

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

parse_format_specs() [2/2]

template<typename T , typename ParseContext >

FMT_CONSTEXPR auto detail::parse_format_specs

(

ParseContext &

ctx

)

-> decltype(ctx.begin())

parse_format_string()

template<bool IS_CONSTEXPR, typename Char , typename Handler >

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

parse_header()

template<typename Char , typename GetArg >

auto detail::parse_header	(	const Char *&	it,
		const Char *	end,
		format_specs< Char > &	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,
		int &	value,
		arg_ref< Char > &	ref,
		basic_format_parse_context< Char > &	ctx
	)		-> const Char*

parse_printf_presentation_type()

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

inline

parse_replacement_field()

template<typename Char , typename Handler >

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

pow10()

constexpr long long detail::pow10 ( std::uint32_t  n )

constexpr

prefix_append()

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

inline

print()

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

range_begin() [1/3]

template<typename T , std::size_t N>

auto detail::range_begin

(

const T(&)

arr[N]

)

-> const T*

range_begin() [2/3]

template<typename T >

auto detail::range_begin

(

T &&

rng

)

-> enable_if_t<!has_member_fn_begin_end_t<T&&>::value, decltype(begin(static_cast<T&&>(rng)))>

range_begin() [3/3]

template<typename T >

auto detail::range_begin

(

T &&

rng

)

&&

range_end() [1/3]

template<typename T , std::size_t N>

auto detail::range_end

(

const T(&)

arr[N]

)

-> const T*

range_end() [2/3]

template<typename T >

auto detail::range_end

(

T &&

rng

)

-> enable_if_t<!has_member_fn_begin_end_t<T&&>::value, decltype(end(static_cast<T&&>(rng)))>

range_end() [3/3]

template<typename T >

auto detail::range_end

(

T &&

rng

)

&&

replace_substring()

template<typename StringType >

void detail::replace_substring ( StringType &  s, const StringType &  f, const StringType &  t  )

inline

replace all occurrences of a substring by another string

Parameters

[in,out]	s	the string to manipulate; changed so that all occurrences of f are replaced with t
[in]	f	the substring to replace with t
[in]	t	the string to replace f

Precondition

The search string f must not be empty. This precondition is enforced with an assertion.

Since

version 2.0.0

report_error()

FMT_API void detail::report_error ( format_func  func, int  error_code, const char *  message  )

noexcept

reserve() [1/3]

template<typename T >

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

inline

reserve() [2/3]

template<typename Iterator >

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

constexpr

reserve() [3/3]

template<typename Container , FMT_ENABLE_IF(is_contiguous< Container >::value) >

auto detail::reserve ( std::back_insert_iterator< Container >  it, size_t  n  ) -> typename Container::value_type*

inline

reset_color()

template<typename Char >

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

inline

rotr() [1/2]

FMT_CONSTEXPR uint32_t detail::rotr ( uint32_t  n, uint32_t  r  )

inlinenoexcept

rotr() [2/2]

FMT_CONSTEXPR uint64_t detail::rotr ( uint64_t  n, uint32_t  r  )

inlinenoexcept

set()

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

constexpr

sign()

template<typename Char , typename Sign >

constexpr Char detail::sign ( Sign  s )

constexpr

signbit()

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

FMT_INLINE FMT_CONSTEXPR bool detail::signbit

(

T

value

)

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 >()

template FMT_API auto detail::thousands_sep_impl< char >

(

locale_ref

)

-> thousands_sep_result< char >

thousands_sep_impl< wchar_t >()

template FMT_API auto detail::thousands_sep_impl< wchar_t >

(

locale_ref

)

-> thousands_sep_result< wchar_t >

throw_format_error()

FMT_NORETURN FMT_API void detail::throw_format_error

(

const char *

message

)

tm_mon_full_name()

const char * detail::tm_mon_full_name ( int  mon )

inline

tm_mon_short_name()

const char * detail::tm_mon_short_name ( int  mon )

inline

tm_wday_full_name()

const char * detail::tm_wday_full_name ( int  wday )

inline

tm_wday_short_name()

const char * detail::tm_wday_short_name ( int  wday )

inline

to_ascii()

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

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

constexpr

to_chars()

template<typename FloatType >

JSON_HEDLEY_RETURNS_NON_NULL char * detail::to_chars	(	char *	first,
		const char *	last,
		FloatType	value
	)

generates a decimal representation of the floating-point number value in [first, last).

The format of the resulting decimal representation is similar to printf's g format. Returns an iterator pointing past-the-end of the decimal representation.

Note

The input number must be finite, i.e. NaN's and Inf's are not supported.

The buffer must be large enough.

The result is NOT null-terminated.

to_json() [1/18]

template<typename BasicJsonType , typename CompatibleNumberIntegerType , enable_if_t< is_compatible_integer_type< typename BasicJsonType::number_integer_t, CompatibleNumberIntegerType >::value, int > = 0>

void detail::to_json ( BasicJsonType &  j, CompatibleNumberIntegerType  val  )

inlinenoexcept

to_json() [2/18]

template<typename BasicJsonType , typename CompatibleNumberUnsignedType , enable_if_t< is_compatible_integer_type< typename BasicJsonType::number_unsigned_t, CompatibleNumberUnsignedType >::value, int > = 0>

void detail::to_json ( BasicJsonType &  j, CompatibleNumberUnsignedType  val  )

inlinenoexcept

to_json() [3/18]

template<typename BasicJsonType , typename BoolRef , enable_if_t<((std::is_same< std::vector< bool >::reference, BoolRef >::value &&!std::is_same< std::vector< bool >::reference, typename BasicJsonType::boolean_t & >::value)||(std::is_same< std::vector< bool >::const_reference, BoolRef >::value &&!std::is_same< detail::uncvref_t< std::vector< bool >::const_reference >, typename BasicJsonType::boolean_t >::value)) &&std::is_convertible< const BoolRef &, typename BasicJsonType::boolean_t >::value, int > = 0>

void detail::to_json ( BasicJsonType &  j, const BoolRef &  b  )

inlinenoexcept

to_json() [4/18]

template<typename BasicJsonType , typename CompatibleArrayType , enable_if_t< is_compatible_array_type< BasicJsonType, CompatibleArrayType >::value &&!is_compatible_object_type< BasicJsonType, CompatibleArrayType >::value &&!is_compatible_string_type< BasicJsonType, CompatibleArrayType >::value &&!std::is_same< typename BasicJsonType::binary_t, CompatibleArrayType >::value &&!is_basic_json< CompatibleArrayType >::value, int > = 0>

void detail::to_json ( BasicJsonType &  j, const CompatibleArrayType &  arr  )

inline

to_json() [5/18]

template<typename BasicJsonType , typename CompatibleObjectType , enable_if_t< is_compatible_object_type< BasicJsonType, CompatibleObjectType >::value &&!is_basic_json< CompatibleObjectType >::value, int > = 0>

void detail::to_json ( BasicJsonType &  j, const CompatibleObjectType &  obj  )

inline

to_json() [6/18]

template<typename BasicJsonType , typename CompatibleString , enable_if_t< std::is_constructible< typename BasicJsonType::string_t, CompatibleString >::value, int > = 0>

void detail::to_json ( BasicJsonType &  j, const CompatibleString &  s  )

inline

to_json() [7/18]

template<typename BasicJsonType , typename T1 , typename T2 , enable_if_t< std::is_constructible< BasicJsonType, T1 >::value &&std::is_constructible< BasicJsonType, T2 >::value, int > = 0>

void detail::to_json ( BasicJsonType &  j, const std::pair< T1, T2 > &  p  )

inline

to_json() [8/18]

template<typename BasicJsonType , typename T , enable_if_t< std::is_convertible< T, BasicJsonType >::value, int > = 0>

void detail::to_json ( BasicJsonType &  j, const std::valarray< T > &  arr  )

inline

to_json() [9/18]

template<typename BasicJsonType >

void detail::to_json ( BasicJsonType &  j, const std::vector< bool > &  e  )

inline

to_json() [10/18]

template<typename BasicJsonType , typename T , enable_if_t< std::is_same< T, iteration_proxy_value< typename BasicJsonType::iterator > >::value, int > = 0>

void detail::to_json ( BasicJsonType &  j, const T &  b  )

inline

to_json() [11/18]

template<typename BasicJsonType , typename T , std::size_t N, enable_if_t< !std::is_constructible< typename BasicJsonType::string_t, const T(&)[N]>::value, int > = 0>

void detail::to_json ( BasicJsonType &  j, const T(&)  arr[N]  )

inline

to_json() [12/18]

template<typename BasicJsonType >

void detail::to_json ( BasicJsonType &  j, const typename BasicJsonType::binary_t &  bin  )

inline

to_json() [13/18]

template<typename BasicJsonType , typename EnumType , enable_if_t< std::is_enum< EnumType >::value, int > = 0>

void detail::to_json ( BasicJsonType &  j, EnumType  e  )

inlinenoexcept

to_json() [14/18]

template<typename BasicJsonType , typename FloatType , enable_if_t< std::is_floating_point< FloatType >::value, int > = 0>

void detail::to_json ( BasicJsonType &  j, FloatType  val  )

inlinenoexcept

to_json() [15/18]

template<typename BasicJsonType , typename T , enable_if_t< std::is_same< T, typename BasicJsonType::boolean_t >::value, int > = 0>

void detail::to_json ( BasicJsonType &  j, T  b  )

inlinenoexcept

to_json() [16/18]

template<typename BasicJsonType >

void detail::to_json ( BasicJsonType &  j, typename BasicJsonType::array_t &&  arr  )

inline

to_json() [17/18]

template<typename BasicJsonType >

void detail::to_json ( BasicJsonType &  j, typename BasicJsonType::object_t &&  obj  )

inline

to_json() [18/18]

template<typename BasicJsonType >

void detail::to_json ( BasicJsonType &  j, typename BasicJsonType::string_t &&  s  )

inline

to_json_tuple_impl()

template<typename BasicJsonType , typename Tuple , std::size_t... Idx>

void detail::to_json_tuple_impl ( BasicJsonType &  j, const Tuple &  t, index_sequence< Idx... >    )

inline

to_nonnegative_int()

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

Int detail::to_nonnegative_int ( T  value, Int  upper  )

inline

to_pointer() [1/2]

template<typename T >

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

to_pointer() [2/2]

template<typename T , typename OutputIt >

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

constexpr

to_string_view() [1/6]

void detail::to_string_view

(

...

)

to_string_view() [2/6]

template<typename Char >

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

constexpr

to_string_view() [3/6]

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

FMT_INLINE auto detail::to_string_view

(

const Char *

s

)

-> basic_string_view<Char>

to_string_view() [4/6]

template<typename S , FMT_ENABLE_IF(is_compile_string< S >::value) >

constexpr auto detail::to_string_view ( const S &  s ) -> basic_string_view<typename S::char_type>

constexpr

to_string_view() [5/6]

template<typename Char , typename Traits , typename Alloc >

auto detail::to_string_view ( const std::basic_string< Char, Traits, Alloc > &  s ) -> basic_string_view<Char>

inline

to_string_view() [6/6]

template<typename Char , FMT_ENABLE_IF(!std::is_empty< std_string_view< Char > >::value) >

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

inline

to_unsigned()

template<typename Int >

FMT_CONSTEXPR auto detail::to_unsigned

(

Int

value

)

-> typename std::make_unsigned<Int>::type

umul128()

uint128_fallback detail::umul128 ( uint64_t  x, uint64_t  y  )

inlinenoexcept

unescape()

template<typename StringType >

static void detail::unescape ( StringType &  s )

static

string unescaping as described in RFC 6901 (Sect. 4)

Parameters

[in]

s

string to unescape

Returns

unescaped string

Note the order of escaping "~1" to "/" and "~0" to "~" is important.

unwrap() [1/2]

template<typename T >

const T & detail::unwrap

(

const std::reference_wrapper< T > &

v

)

unwrap() [2/2]

template<typename T >

const T & detail::unwrap

(

const T &

v

)

utf8_decode()

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

inline

value_in_range_of()

template<typename OfType , typename T >

constexpr bool detail::value_in_range_of ( T  val )

inlineconstexpr

vformat()

template<typename Locale , typename Char >

auto detail::vformat	(	const Locale &	loc,
		basic_string_view< Char >	fmt,
		basic_format_args< buffer_context< type_identity_t< Char > > >	args
	)		-> std::basic_string<Char>

vformat_to() [1/3]

FMT_BEGIN_EXPORT template FMT_API void detail::vformat_to	(	buffer< char > &	,
		string_view	,
		typename vformat_args<>::type	,
		locale_ref
	)

vformat_to() [2/3]

template<typename Char >

void detail::vformat_to	(	buffer< Char > &	buf,
		basic_string_view< Char >	fmt,
		typename vformat_args< Char >::type	args,
		locale_ref	loc
	)

vformat_to() [3/3]

template<typename Char >

void detail::vformat_to	(	buffer< Char > &	buf,
		const text_style &	ts,
		basic_string_view< Char >	format_str,
		basic_format_args< buffer_context< type_identity_t< Char > > >	args
	)

vprint_directly()

void detail::vprint_directly ( std::ostream &  os, string_view  format_str, format_args  args  )

inline

vprint_mojibake()

void detail::vprint_mojibake ( std::FILE *  , string_view  , format_args    )

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/19]

template<typename Char , typename OutputIt >

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

write() [2/19]

template<typename Char , typename OutputIt >

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

write() [3/19]

template<typename Char , typename OutputIt >

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

write() [4/19]

template<typename Char , typename OutputIt >

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

write() [5/19]

template<typename Char , typename OutputIt >

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

write() [6/19]

template<typename Char , typename OutputIt >

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

write() [7/19]

template<typename Char , typename OutputIt >

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

write() [8/19]

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() [9/19]

template<typename Char , typename OutputIt , typename T , typename Context = basic_format_context<OutputIt, Char>>

FMT_CONSTEXPR auto detail::write	(	OutputIt	out,
		const T &	value
	)		-> enable_if_t< std::is_class<T>::value && !is_string<T>::value && !is_floating_point<T>::value && !std::is_same<T, Char>::value && !std::is_same<T, remove_cvref_t<decltype(arg_mapper<Context>().map( value))>>::value, OutputIt>

write() [10/19]

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

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

constexpr

write() [11/19]

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< Char > &	specs = {},
		locale_ref	= {}
	)		-> OutputIt

write() [12/19]

template<typename Char , typename OutputIt >

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

write() [13/19]

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() [14/19]

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() [15/19]

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() [16/19]

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

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

write() [17/19]

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

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

write() [18/19]

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< Char > &	specs = {},
		locale_ref	= {}
	)		-> OutputIt

write() [19/19]

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< Char >	specs,
		locale_ref	loc = {}
	)		-> OutputIt

write_buffer()

template<typename Char >

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

write_bytes()

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

FMT_CONSTEXPR auto detail::write_bytes	(	OutputIt	out,
		string_view	bytes,
		const format_specs< Char > &	specs
	)		-> OutputIt

write_char()

template<typename Char , typename OutputIt >

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

write_codecvt()

template<typename CodeUnit >

void detail::write_codecvt	(	codecvt_result< CodeUnit > &	out,
		string_view	in_buf,
		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_API bool detail::write_console	(	std::FILE *	,
		string_view
	)

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 It >

FMT_CONSTEXPR auto detail::write_exponent	(	int	exp,
		It	it
	)		-> It

write_float() [1/2]

template<typename OutputIt , typename DecimalFP , typename Char >

FMT_CONSTEXPR20 auto detail::write_float	(	OutputIt	out,
		const DecimalFP &	f,
		const format_specs< Char > &	specs,
		float_specs	fspecs,
		locale_ref	loc
	)		-> OutputIt

write_float() [2/2]

template<typename Char , typename OutputIt , typename T >

FMT_CONSTEXPR20 auto detail::write_float	(	OutputIt	out,
		T	value,
		format_specs< Char >	specs,
		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/3]

template<typename OutputIt , typename Char , typename W >

FMT_CONSTEXPR FMT_INLINE auto detail::write_int	(	OutputIt	out,
		int	num_digits,
		unsigned	prefix,
		const format_specs< Char > &	specs,
		W	write_digits
	)		-> OutputIt

write_int() [2/3]

template<typename OutputIt , typename UInt , typename Char >

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

write_int() [3/3]

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< Char > &	specs,
		locale_ref
	)		-> 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< Char > &	specs,
		locale_ref	loc
	)		-> OutputIt

write_loc() [1/3]

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

write_loc() [2/3]

template<typename OutputIt , typename Char >

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

inline

write_loc() [3/3]

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

inline

write_nonfinite()

template<typename Char , typename OutputIt >

FMT_CONSTEXPR20 auto detail::write_nonfinite	(	OutputIt	out,
		bool	isnan,
		format_specs< Char >	specs,
		const float_specs &	fspecs
	)		-> OutputIt

write_ostream_unicode() [1/2]

bool detail::write_ostream_unicode ( std::ostream &  os, fmt::string_view  data  )

inline

write_ostream_unicode() [2/2]

bool detail::write_ostream_unicode ( std::wostream &  , fmt::basic_string_view< wchar_t >    )

inline

write_padded() [1/2]

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

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

constexpr

write_padded() [2/2]

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

FMT_CONSTEXPR auto detail::write_padded	(	OutputIt	out,
		const format_specs< Char > &	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< Char > *	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 >

constexpr 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

invalid_code_point

constexpr FMT_INLINE_VARIABLE uint32_t detail::invalid_code_point = ~uint32_t()

constexpr