fmt::v8::detail Namespace Reference

Namespaces
	digits
	dragonbox

Classes
struct	accumulator
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	auto_id
struct	basic_impl_data
struct	big_decimal_fp
class	bigint
struct	bits
class	buffer
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
class	compiled_string
struct	conditional_helper
class	counting_buffer
class	counting_iterator
struct	custom_formatter
struct	custom_value
struct	default_arg_formatter
class	digit_grouping
class	dynamic_arg_list
struct	dynamic_format_specs
class	dynamic_specs_handler
struct	error_handler
class	fallback_digit_grouping
struct	fallback_formatter
struct	fallback_formatter< T, Char, enable_if_t< is_streamable< T, Char >::value > >
struct	fallback_uintptr
struct	fill_t
struct	find_escape_result
class	fixed_buffer_traits
struct	float_specs
struct	format_decimal_result
class	format_string_checker
class	formatbuf
struct	fp
struct	gen_digits_handler
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_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 >())), enable_if_t< std::is_copy_constructible< T >::value > > >
struct	impl_data
struct	int_checker
struct	int_checker< true >
struct	integer_sequence
struct	is_back_insert_iterator
struct	is_back_insert_iterator< std::back_insert_iterator< Container > >
struct	is_compiled_string
struct	is_contiguous_back_insert_iterator
struct	is_contiguous_back_insert_iterator< appender >
struct	is_contiguous_back_insert_iterator< std::back_insert_iterator< Container > >
struct	is_integral
struct	is_integral< int128_t >
struct	is_integral< uint128_t >
class	is_map
struct	is_named_arg
struct	is_named_arg< named_arg< Char, T > >
struct	is_output_iterator
struct	is_output_iterator< It, T, void_t< typename std::iterator_traits< It >::iterator_category, decltype(*std::declval< It >()=std::declval< T >())> >
struct	is_range_
struct	is_range_< T, void >
struct	is_reference_wrapper
struct	is_reference_wrapper< std::reference_wrapper< T > >
class	is_set
struct	is_statically_named_arg
class	is_std_string_like
struct	is_std_string_like< fmt::basic_string_view< Char > >
class	is_streamable
struct	is_streamable< T, Char, enable_if_t< std::is_arithmetic< T >::value||std::is_array< T >::value||std::is_pointer< T >::value||std::is_same< T, char8_type >::value||std::is_same< T, std::basic_string< Char > >::value||std::is_same< T, std_string_view< Char > >::value||(std::is_convertible< T, int >::value &&!std::is_enum< T >::value)> >
struct	is_string
class	is_tuple_like_
class	is_zero_int
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	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	named_arg
struct	named_arg_info
struct	named_arg_value
struct	null
struct	null_chrono_spec_handler
class	precision_checker
class	printf_arg_formatter
class	printf_precision_handler
class	printf_width_handler
struct	singleton
class	specs_checker
class	specs_handler
class	specs_setter
struct	std_string_view
struct	string_value
struct	thousands_sep_result
struct	tm_format_checker
class	tm_writer
class	truncating_iterator
class	truncating_iterator< OutputIt, std::false_type >
class	truncating_iterator< OutputIt, std::true_type >
class	truncating_iterator_base
struct	type_constant
struct	type_constant< basic_string_view< Char >, Char >
struct	type_constant< bool, Char >
struct	type_constant< Char, Char >
struct	type_constant< const Char *, Char >
struct	type_constant< const void *, Char >
struct	type_constant< double, Char >
struct	type_constant< float, Char >
struct	type_constant< int, Char >
struct	type_constant< int128_t, Char >
struct	type_constant< long double, Char >
struct	type_constant< long long, Char >
struct	type_constant< uint128_t, Char >
struct	type_constant< unsigned long long, Char >
struct	type_constant< unsigned, Char >
struct	uint128_wrapper
struct	unformattable
struct	unformattable_char
struct	unformattable_const
struct	unformattable_pointer
class	utf8_to_utf16
class	value
struct	view
class	width_checker
struct	write_int_arg
struct	write_int_data

Typedefs
template<typename T >
using	buffer_appender = conditional_t< std::is_same< T, char >::value, appender, std::back_insert_iterator< buffer< T > >>
template<typename T , typename Char >
using	has_fallback_formatter = std::is_constructible< fallback_formatter< T, Char > >
using	long_type = conditional_t< long_short, int, long long >
using	ulong_type = conditional_t< long_short, unsigned, unsigned long long >
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
using	uintptr_t = fallback_uintptr
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 T >
using	checked_ptr = 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_t >::value >
template<typename T >
using	uint32_or_64_or_128_t = conditional_t< num_bits< T >()<=32 &&! 0, 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 >
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	format_func = void(*)(detail::buffer< char > &, int, const char *)
template<size_t... N>
using	index_sequence = integer_sequence< size_t, N... >
template<size_t N>
using	make_index_sequence = make_integer_sequence< size_t, N >
template<typename Range >
using	value_type = remove_cvref_t< decltype(*detail::range_begin(std::declval< Range >()))>
template<typename T >
using	is_exotic_char = bool_constant<!std::is_same< T, char >::value >

Enumerations
enum	numeric_system { numeric_system::standard, numeric_system::alternative }
enum	byte : unsigned char
enum	int128_t
enum	uint128_t
enum	type {   type::none_type, type::int_type, type::uint_type, type::long_long_type,   type::ulong_long_type, type::int128_type, type::uint128_type, type::bool_type,   type::char_type, type::last_integer_type = char_type, type::float_type, type::double_type,   type::long_double_type, type::last_numeric_type = long_double_type, type::cstring_type, type::string_type,   type::pointer_type, type::custom_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	arg_id_kind { arg_id_kind::none, arg_id_kind::index, arg_id_kind::name }
enum	float_format : unsigned char { float_format::general, float_format::exp, float_format::fixed, float_format::hex }
enum	round_direction { round_direction::unknown, round_direction::up, round_direction::down }
enum	char8_type : unsigned char

Functions
template<typename T >
const T &	unwrap (const T &v)
template<typename T >
const T &	unwrap (const std::reference_wrapper< T > &v)
null	localtime_r (...)
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 , enable_if_t<(!std::is_same< Char, char >::value), int > = 0>
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 , enable_if_t<(!std::is_same< Char, char >::value), int > = 0>
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 >
const char *	get_units ()
template<typename Char , typename Handler >
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 , enable_if_t<(std::is_integral< T >::value), int > = 0>
bool	isnan (T)
template<typename T , enable_if_t<(std::is_integral< T >::value), int > = 0>
bool	isfinite (T)
template<typename T , typename Int , enable_if_t<(std::is_integral< T >::value), int > = 0>
Int	to_nonnegative_int (T value, Int upper)
template<typename T , enable_if_t<(std::is_integral< T >::value), int > = 0>
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 , enable_if_t<(std::is_integral< Rep >::value), int > = 0>
std::chrono::duration< Rep, std::milli >	get_milliseconds (std::chrono::duration< Rep, Period > d)
constexpr int	count_fractional_digits (long long num, long long den, int n=0)
constexpr long long	pow10 (std::uint32_t n)
template<class Rep , class Period , enable_if_t<(std::numeric_limits< Rep >::is_signed), int > = 0>
constexpr std::chrono::duration< Rep, Period >	abs (std::chrono::duration< Rep, Period > d)
template<typename Char , typename Rep , typename OutputIt , enable_if_t<(std::is_integral< Rep >::value), int > = 0>
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 Char >
ansi_color_escape< Char >	make_foreground_color (detail::color_type foreground) throw ()
template<typename Char >
ansi_color_escape< Char >	make_background_color (detail::color_type background) throw ()
template<typename Char >
ansi_color_escape< Char >	make_emphasis (emphasis em) throw ()
template<typename Char >
void	fputs (const Char *chars, FILE *stream) throw ()
template<>
void	fputs< wchar_t > (const wchar_t *chars, FILE *stream) throw ()
template<typename Char >
void	reset_color (FILE *stream) throw ()
template<>
void	reset_color< wchar_t > (FILE *stream) throw ()
template<typename Char >
void	reset_color (buffer< Char > &buffer) throw ()
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)
template<typename Char , typename InputIt >
counting_iterator	copy_str (InputIt begin, InputIt end, counting_iterator it)
template<typename T , typename... Tail>
const T &	first (const T &value, const Tail &...)
template<typename... T>
void	ignore_unused (const T &...)
constexpr auto	is_constant_evaluated (bool default_value=false) -> bool throw ()
template<typename T >
constexpr auto	const_check (T value) -> T
void	assert_fail (const char *file, int line, const char *message)
template<typename T >
auto	convert_for_visit (T) -> monostate
template<typename Int >
auto	to_unsigned (Int value) -> typename std::make_unsigned< Int >::type
constexpr auto	is_utf8 () -> bool
void	to_string_view (...)
template<typename... , typename S , enable_if_t<(!is_compile_string< S >::value), int > = 0>
void	check_format_string (const S &)
template<typename... , typename S , enable_if_t<(is_compile_string< S >::value), int > = 0>
void	check_format_string (S)
void	throw_format_error (const char *message)
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 Container >
auto	get_container (std::back_insert_iterator< Container > it) -> Container &
template<typename Char , typename InputIt , typename OutputIt >
auto	copy_str (InputIt begin, InputIt end, OutputIt out) -> OutputIt
template<typename Char , typename T , typename U , enable_if_t<(std::is_same< remove_const_t< T >, U >::value &&is_char< U >::value), int > = 0>
auto	copy_str (T *begin, T *end, U *out) -> U *
template<typename T , typename OutputIt >
auto	get_buffer (OutputIt out) -> iterator_buffer< OutputIt, T >
template<typename Buffer >
auto	get_iterator (Buffer &buf) -> decltype(buf.out())
template<typename T >
auto	get_iterator (buffer< T > &buf) -> buffer_appender< T >
template<typename Char >
void	init_named_args (named_arg_info< Char > *, int, int)
template<typename Char , typename T , typename... Tail, enable_if_t<(!is_named_arg< T >::value), int > = 0>
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>
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
constexpr bool	is_integral_type (type t)
constexpr bool	is_arithmetic_type (type t)
template<typename Context , typename T >
auto	make_arg (const T &value) -> basic_format_arg< Context >
template<typename Char , typename InputIt >
auto	copy_str (InputIt begin, InputIt end, appender out) -> appender
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 IS_PACKED, typename Context , type , typename T , enable_if_t<(IS_PACKED), int > = 0>
auto	make_arg (T &&val) -> value< Context >
template<bool IS_PACKED, typename Context , type , typename T , enable_if_t<(!IS_PACKED), int > = 0>
auto	make_arg (const T &value) -> basic_format_arg< Context >
template<typename Char >
constexpr bool	is_ascii_letter (Char c)
template<typename Char , enable_if_t<(std::is_integral< Char >::value), int > = 0>
constexpr auto	to_ascii (Char value) -> Char
template<typename Char >
auto	code_point_length (const Char *begin) -> int
template<bool IS_CONSTEXPR, typename T , typename Ptr = const T*>
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 >
auto	parse_nonnegative_int (const Char *&begin, const Char *end, int error_value) noexcept -> int
template<typename Char , typename Handler >
auto	parse_align (const Char *begin, const Char *end, Handler &&handler) -> const Char *
template<typename Char >
bool	is_name_start (Char c)
template<typename Char , typename IDHandler >
auto	do_parse_arg_id (const Char *begin, const Char *end, IDHandler &&handler) -> const Char *
template<typename Char , typename IDHandler >
auto	parse_arg_id (const Char *begin, const Char *end, IDHandler &&handler) -> const Char *
template<typename Char , typename Handler >
auto	parse_width (const Char *begin, const Char *end, Handler &&handler) -> const Char *
template<typename Char , typename Handler >
auto	parse_precision (const Char *begin, const Char *end, Handler &&handler) -> const Char *
template<typename Char >
auto	parse_presentation_type (Char type) -> presentation_type
template<typename Char , typename SpecHandler >
auto	parse_format_specs (const Char *begin, const Char *end, SpecHandler &&handler) -> const Char *
template<typename Char , typename Handler >
auto	parse_replacement_field (const Char *begin, const Char *end, Handler &&handler) -> const Char *
template<bool IS_CONSTEXPR, typename Char , typename Handler >
void	parse_format_string (basic_string_view< Char > format_str, Handler &&handler)
template<typename T , typename ParseContext >
auto	parse_format_specs (ParseContext &ctx) -> decltype(ctx.begin())
template<typename ErrorHandler >
void	check_int_type_spec (presentation_type type, ErrorHandler &&eh)
template<typename Char , typename ErrorHandler = error_handler>
auto	check_char_specs (const basic_format_specs< Char > &specs, ErrorHandler &&eh={}) -> bool
template<typename ErrorHandler = error_handler, typename Char >
auto	parse_float_type_spec (const basic_format_specs< Char > &specs, ErrorHandler &&eh={}) -> float_specs
template<typename ErrorHandler = error_handler>
auto	check_cstring_type_spec (presentation_type type, ErrorHandler &&eh={}) -> bool
template<typename ErrorHandler = error_handler>
void	check_string_type_spec (presentation_type type, ErrorHandler &&eh={})
template<typename ErrorHandler >
void	check_pointer_type_spec (presentation_type type, ErrorHandler &&eh)
template<typename... Args, typename Char >
auto	get_arg_index_by_name (basic_string_view< Char > name) -> int
template<typename Char >
void	vformat_to (buffer< Char > &buf, basic_string_view< Char > fmt, basic_format_args< basic_format_context< detail::buffer_appender< type_identity_t< Char > >, type_identity_t< Char > >> args, locale_ref loc={})
void	vprint_mojibake (std::FILE *, string_view, format_args)
void	format_error_code (detail::buffer< char > &out, int error_code, string_view message) throw ()
void	report_error (format_func func, int error_code, const char *message) throw ()
void	fwrite_fully (const void *ptr, size_t size, size_t count, FILE *stream)
template<typename Char >
auto	thousands_sep_impl (locale_ref loc) -> thousands_sep_result< Char >
template<typename Char >
Char	decimal_point_impl (locale_ref loc)
template<>
int	count_digits< 4 > (detail::fallback_uintptr n)
template<typename Float >
constexpr int	num_significand_bits ()
template<int SHIFT = 0>
fp	normalize (fp value)
bool	operator== (fp x, fp y)
uint64_t	multiply (uint64_t lhs, uint64_t rhs)
fp	operator* (fp x, fp y)
fp	get_cached_power (int min_exponent, int &pow10_exponent)
round_direction	get_round_direction (uint64_t divisor, uint64_t remainder, uint64_t error)
digits::result	grisu_gen_digits (fp value, uint64_t error, int &exp, gen_digits_handler &handler)
void	format_dragon (fp value, bool is_predecessor_closer, int num_digits, buffer< char > &buf, int &exp10)
template<typename Float >
int	format_float (Float value, int precision, float_specs specs, buffer< char > &buf)
template<typename T >
int	snprintf_float (T value, int precision, float_specs specs, buffer< char > &buf)
void	print (std::FILE *f, string_view text)
template<typename To , typename From >
auto	bit_cast (const From &from) -> To
auto	is_big_endian () -> bool
auto	to_uintptr (const void *p) -> fallback_uintptr
template<typename T >
constexpr auto	max_value () -> T
template<typename T >
constexpr auto	num_bits () -> int
template<>
constexpr auto	num_bits< int128_t > () -> int
template<>
constexpr auto	num_bits< uint128_t > () -> int
template<>
constexpr auto	num_bits< fallback_uintptr > () -> int
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 T >
constexpr auto	make_checked (T *p, size_t) -> T *
template<typename Container , enable_if_t<(is_contiguous< Container >::value), int > = 0>
auto	reserve (std::back_insert_iterator< Container > it, size_t n) -> checked_ptr< 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 , enable_if_t<(is_contiguous< Container >::value), int > = 0>
auto	base_iterator (std::back_insert_iterator< Container > &it, checked_ptr< 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 >
auto	fill_n (OutputIt out, Size count, const T &value) -> OutputIt
template<typename T , typename Size >
auto	fill_n (T *out, Size count, char value) -> T *
template<typename OutChar , typename InputIt , typename OutputIt >
auto	copy_str_noinline (InputIt begin, InputIt end, OutputIt out) -> OutputIt
auto	utf8_decode (const char *s, uint32_t *c, int *e) -> const char *
template<typename F >
void	for_each_codepoint (string_view s, F f)
template<typename Char >
auto	compute_width (basic_string_view< Char > s) -> size_t
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 (basic_string_view< char8_type > s, size_t n) -> size_t
template<typename T , enable_if_t<(is_signed< T >::value), int > = 0>
auto	is_negative (T value) -> bool
template<typename T , enable_if_t<(std::is_floating_point< T >::value), int > = 0>
auto	is_supported_floating_point (T) -> uint16_t
constexpr const char *	digits2 (size_t value)
template<typename Char , typename Sign >
constexpr Char	sign (Sign s)
template<typename T >
auto	count_digits_fallback (T n) -> int
auto	count_digits (uint64_t n) -> int
template<int BITS, typename UInt >
auto	count_digits (UInt n) -> int
auto	count_digits (uint32_t n) -> int
template<typename Int >
constexpr auto	digits10 () -> int throw ()
template<>
constexpr auto	digits10< int128_t > () -> int throw ()
template<>
constexpr auto	digits10< uint128_t > () -> int throw ()
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 >
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 >
void	copy2 (Char *dst, const char *src)
template<typename Char , typename UInt >
auto	format_decimal (Char *out, UInt value, int size) -> format_decimal_result< Char * >
template<typename Char , typename UInt , typename Iterator , enable_if_t<(!std::is_pointer< remove_cvref_t< Iterator >>::value), int > = 0>
auto	format_decimal (Iterator out, UInt value, int size) -> format_decimal_result< Iterator >
template<unsigned BASE_BITS, typename Char , typename UInt >
auto	format_uint (Char *buffer, UInt value, int num_digits, bool upper=false) -> Char *
template<unsigned BASE_BITS, typename Char >
auto	format_uint (Char *buffer, detail::fallback_uintptr n, int num_digits, bool=false) -> Char *
template<unsigned BASE_BITS, typename Char , typename It , typename UInt >
auto	format_uint (It out, UInt value, int num_digits, bool upper=false) -> It
template<typename T >
constexpr auto	exponent_mask () -> typename dragonbox::float_info< T >::carrier_uint
template<typename Char , typename It >
auto	write_exponent (int exp, It it) -> It
template<typename T >
auto	format_float (T value, int precision, float_specs specs, buffer< char > &buf) -> int
template<typename T >
auto	snprintf_float (T value, int precision, float_specs specs, buffer< char > &buf) -> int
template<typename T >
constexpr auto	promote_float (T value) -> T
constexpr auto	promote_float (float value) -> double
template<typename OutputIt , typename Char >
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 >
auto	write_padded (OutputIt out, const basic_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 basic_format_specs< Char > &specs, size_t size, F &&f) -> OutputIt
template<align::type align = align::left, typename Char , typename OutputIt >
auto	write_bytes (OutputIt out, string_view bytes, const basic_format_specs< Char > &specs) -> OutputIt
template<typename Char , typename OutputIt , typename UIntPtr >
auto	write_ptr (OutputIt out, UIntPtr value, const basic_format_specs< Char > *specs) -> OutputIt
template<typename Char , typename OutputIt >
auto	write_char (OutputIt out, Char value, const basic_format_specs< Char > &specs) -> OutputIt
template<typename Char , typename OutputIt >
auto	write (OutputIt out, Char value, const basic_format_specs< Char > &specs, locale_ref loc={}) -> OutputIt
template<typename OutputIt , typename Char , typename W >
auto	write_int (OutputIt out, int num_digits, unsigned prefix, const basic_format_specs< Char > &specs, W write_digits) -> OutputIt
template<typename OutputIt , typename UInt , typename Char >
auto	write_int_localized (OutputIt out, UInt value, unsigned prefix, const basic_format_specs< Char > &specs, const digit_grouping< Char > &grouping) -> OutputIt
template<typename OutputIt , typename UInt , typename Char >
auto	write_int_localized (OutputIt &out, UInt value, unsigned prefix, const basic_format_specs< Char > &specs, locale_ref loc) -> bool
void	prefix_append (unsigned &prefix, unsigned value)
template<typename T >
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 >
auto	write_int (OutputIt out, write_int_arg< T > arg, const basic_format_specs< Char > &specs, locale_ref loc) -> OutputIt
template<typename Char , typename OutputIt , typename T >
auto	write_int_noinline (OutputIt out, write_int_arg< T > arg, const basic_format_specs< Char > &specs, locale_ref loc) -> OutputIt
template<typename Char , typename OutputIt , typename T , enable_if_t<(is_integral< T >::value &&!std::is_same< T, bool >::value &&std::is_same< OutputIt, buffer_appender< Char >>::value), int > = 0>
auto	write (OutputIt out, T value, const basic_format_specs< Char > &specs, locale_ref loc) -> OutputIt
template<typename Char , typename OutputIt >
auto	write (OutputIt out, basic_string_view< Char > s, const basic_format_specs< Char > &specs) -> OutputIt
template<typename Char , typename OutputIt >
auto	write (OutputIt out, basic_string_view< type_identity_t< Char >> s, const basic_format_specs< Char > &specs, locale_ref) -> OutputIt
template<typename Char , typename OutputIt >
auto	write (OutputIt out, const Char *s, const basic_format_specs< Char > &specs, locale_ref) -> OutputIt
template<typename Char , typename OutputIt >
auto	write_nonfinite (OutputIt out, bool isinf, basic_format_specs< Char > specs, const float_specs &fspecs) -> OutputIt
constexpr auto	get_significand_size (const big_decimal_fp &fp) -> int
template<typename T >
auto	get_significand_size (const dragonbox::decimal_fp< T > &fp) -> 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 >
auto	write_significand (OutputIt out, T significand, int significand_size, int exponent, const Grouping &grouping) -> OutputIt
template<typename Char , typename UInt , enable_if_t<(std::is_integral< UInt >::value), int > = 0>
auto	write_significand (Char *out, UInt significand, int significand_size, int integral_size, Char decimal_point) -> Char *
template<typename OutputIt , typename UInt , typename Char , enable_if_t<(!std::is_pointer< remove_cvref_t< OutputIt >>::value), int > = 0>
auto	write_significand (OutputIt out, UInt significand, int significand_size, int integral_size, Char decimal_point) -> OutputIt
template<typename OutputIt , typename Char >
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 >
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>>
auto	do_write_float (OutputIt out, const DecimalFP &fp, const basic_format_specs< Char > &specs, float_specs fspecs, locale_ref loc) -> OutputIt
template<typename OutputIt , typename DecimalFP , typename Char >
auto	write_float (OutputIt out, const DecimalFP &fp, const basic_format_specs< Char > &specs, float_specs fspecs, locale_ref loc) -> OutputIt
template<typename T , enable_if_t<(std::is_floating_point< T >::value), int > = 0>
bool	isinf (T value)
template<typename T , enable_if_t<(std::is_floating_point< T >::value), int > = 0>
bool	signbit (T value)
template<typename Char , typename OutputIt , typename T , enable_if_t<(std::is_floating_point< T >::value), int > = 0>
auto	write (OutputIt out, T value, basic_format_specs< Char > specs, locale_ref loc={}) -> OutputIt
template<typename Char , typename OutputIt , typename T , enable_if_t<(is_fast_float< T >::value), int > = 0>
auto	write (OutputIt out, T value) -> OutputIt
template<typename Char , typename OutputIt >
auto	write (OutputIt out, monostate, basic_format_specs< Char >={}, locale_ref={}) -> OutputIt
template<typename Char , typename OutputIt >
auto	write (OutputIt out, basic_string_view< Char > value) -> OutputIt
template<typename Char , typename OutputIt , typename T , enable_if_t<(is_string< T >::value), int > = 0>
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, enable_if_t<(check), int > = 0>
auto	write (OutputIt out, T value) -> OutputIt
template<typename Char , typename OutputIt >
auto	write (OutputIt out, Char value) -> OutputIt
template<typename Char , typename OutputIt >
auto	write (OutputIt out, const Char *value) -> OutputIt
template<typename Char , typename OutputIt , typename T , enable_if_t<(std::is_same< T, void >::value), int > = 0>
auto	write (OutputIt out, const T *value, const basic_format_specs< Char > &specs={}, locale_ref={}) -> OutputIt
template<typename Char , typename OutputIt , typename T , typename Context = basic_format_context<OutputIt, Char>>
auto	write (OutputIt out, const T &value) -> enable_if_t< std::is_class< T >::value &&!is_string< T >::value &&!std::is_same< T, Char >::value &&!std::is_same< const T &, decltype(arg_mapper< Context >().map(value))>::value, OutputIt >
template<template< typename > class Handler, typename FormatArg , typename ErrorHandler >
auto	get_dynamic_spec (FormatArg arg, ErrorHandler eh) -> int
template<typename Context , typename ID >
auto	get_arg (Context &ctx, ID id) -> typename Context::format_arg
template<template< typename > class Handler, typename Context >
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 > format_str, basic_format_args< buffer_context< type_identity_t< Char >>> args) -> std::basic_string< Char >
template auto	thousands_sep_impl< char > (locale_ref) -> thousands_sep_result< char >
template auto	thousands_sep_impl< wchar_t > (locale_ref) -> thousands_sep_result< wchar_t >
template auto	format_float< double > (double value, int precision, float_specs specs, buffer< char > &buf) -> int
template auto	format_float< long double > (long double value, int precision, float_specs specs, buffer< char > &buf) -> int
void	snprintf_float (float, int, float_specs, buffer< char > &)=delete
template auto	snprintf_float< double > (double value, int precision, float_specs specs, buffer< char > &buf) -> int
template auto	snprintf_float< long double > (long double value, int precision, float_specs specs, buffer< char > &buf) -> int
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())
template<typename T , typename Context , typename Char >
void	convert_arg (basic_format_arg< Context > &arg, Char type)
template<typename Char >
void	parse_flags (basic_format_specs< Char > &specs, const Char *&it, const Char *end)
template<typename Char , typename GetArg >
int	parse_header (const Char *&it, const Char *end, basic_format_specs< Char > &specs, GetArg get_arg)
template<typename Char , typename Context >
void	vprintf (buffer< Char > &buf, basic_string_view< Char > format, basic_format_args< Context > args)
template<typename RangeT , typename OutputIterator >
OutputIterator	copy (const RangeT &range, OutputIterator out)
template<typename OutputIterator >
OutputIterator	copy (const char *str, OutputIterator out)
template<typename OutputIterator >
OutputIterator	copy (char ch, OutputIterator out)
template<typename OutputIterator >
OutputIterator	copy (wchar_t ch, OutputIterator out)
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) -> decltype(static_cast< T && >(rng).begin())
template<typename T >
auto	range_end (T &&rng) -> decltype(static_cast< T && >(rng).end())
template<class Tuple , class F , size_t... Is>
void	for_each (index_sequence< Is... >, Tuple &&tup, F &&f) throw ()
template<class T >
make_index_sequence< std::tuple_size< T >::value >	get_indexes (T const &)
template<class Tuple , class F >
void	for_each (Tuple &&tup, F &&f)
template<typename OutputIt >
OutputIt	write_delimiter (OutputIt out)
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
auto	is_printable (uint32_t cp) -> bool
auto	needs_escape (uint32_t cp) -> bool
template<typename Char >
auto	find_escape (const Char *begin, const Char *end) -> find_escape_result< Char >
auto	find_escape (const char *begin, const char *end) -> find_escape_result< char >
template<typename Char , typename OutputIt >
auto	write_range_entry (OutputIt out, basic_string_view< Char > str) -> OutputIt
template<typename Char , typename OutputIt , typename T , enable_if_t<(std::is_convertible< T, std_string_view< char >>::value), int > = 0>
auto	write_range_entry (OutputIt out, const T &str) -> OutputIt
template<typename Char , typename OutputIt , typename Arg , enable_if_t<(std::is_same< Arg, Char >::value), int > = 0>
OutputIt	write_range_entry (OutputIt out, const Arg v)
template<typename Char , typename OutputIt , typename Arg , enable_if_t<(!is_std_string_like< typename std::decay< Arg >::type >::value &&!std::is_same< Arg, Char >::value), int > = 0>
OutputIt	write_range_entry (OutputIt out, const Arg &v)

Variables
constexpr unsigned char	micro [] = "\u00B5"
constexpr int	invalid_arg_index = -1
static constexpr uint64_t	log10_2_significand = 0x4d104d427de7fbcc
constexpr uint32_t	invalid_code_point = ~uint32_t()

Typedef Documentation

buffer_appender

template<typename T >

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

checked_ptr

template<typename T >

using fmt::v8::detail::checked_ptr = typedef T*

format_func

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

has_fallback_formatter

template<typename T , typename Char >

using fmt::v8::detail::has_fallback_formatter = typedef std::is_constructible<fallback_formatter<T, Char> >

index_sequence

template<size_t... N>

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

is_exotic_char

template<typename T >

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

is_integer

template<typename T >

using fmt::v8::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_signed

template<typename T >

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

iterator_t

template<typename T >

using fmt::v8::detail::iterator_t = typedef decltype(std::begin(std::declval<T&>()))

long_type

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

make_index_sequence

template<size_t N>

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

mapped_type_constant

template<typename T , typename Context >

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

reserve_iterator

template<typename OutputIt >

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

sentinel_t

template<typename T >

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

uint32_or_64_or_128_t

template<typename T >

using fmt::v8::detail::uint32_or_64_or_128_t = typedef conditional_t<num_bits<T>() <= 32 && ! 0 , uint32_t, conditional_t<num_bits<T>() <= 64, uint64_t, uint128_t> >

uint64_or_128_t

template<typename T >

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

uintptr_t

using fmt::v8::detail::uintptr_t = typedef fallback_uintptr

ulong_type

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

value_type

template<typename Range >

using fmt::v8::detail::value_type = typedef remove_cvref_t<decltype(*detail::range_begin(std::declval<Range>()))>

void_t

template<typename... >

using fmt::v8::detail::void_t = typedef void

Enumeration Type Documentation

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 fmt::v8::detail::arg_id_kind

strong

Enumerator
none
index
name

byte

enum fmt::v8::detail::byte : unsigned char

strong

char8_type

enum fmt::v8::detail::char8_type : unsigned char

float_format

enum fmt::v8::detail::float_format : unsigned char

strong

Enumerator
general
exp
fixed
hex

int128_t

enum fmt::v8::detail::int128_t

strong

numeric_system

enum fmt::v8::detail::numeric_system

strong

Enumerator
standard
alternative

round_direction

enum fmt::v8::detail::round_direction

strong

Enumerator
unknown
up
down

type

enum fmt::v8::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_t

enum fmt::v8::detail::uint128_t

strong

Function Documentation

abs()

template<class Rep , class Period , enable_if_t<(std::numeric_limits< Rep >::is_signed), int > = 0>

constexpr std::chrono::duration< Rep, Period > fmt::v8::detail::abs ( std::chrono::duration< Rep, Period >  d )

constexpr

Here is the caller graph for this function:

assert_fail()

void fmt::v8::detail::assert_fail	(	const char *	file,
		int	line,
		const char *	message
	)

Here is the call graph for this function:

assume()

void fmt::v8::detail::assume ( bool  condition )

inline

Here is the call graph for this function:

Here is the caller graph for this function:

base_iterator() [1/2]

template<typename Iterator >

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

constexpr

Here is the caller graph for this function:

base_iterator() [2/2]

template<typename Container , enable_if_t<(is_contiguous< Container >::value), int > = 0>

auto fmt::v8::detail::base_iterator ( std::back_insert_iterator< Container > &  it, checked_ptr< typename Container::value_type >    ) -> std::back_insert_iterator<Container>

inline

Here is the caller graph for this function:

bit_cast()

template<typename To , typename From >

auto fmt::v8::detail::bit_cast

(

const From &

from

)

-> To

Here is the call graph for this function:

check_char_specs()

template<typename Char , typename ErrorHandler = error_handler>

auto fmt::v8::detail::check_char_specs	(	const basic_format_specs< Char > &	specs,
		ErrorHandler &&	eh = {}
	)		-> bool

Here is the caller graph for this function:

check_cstring_type_spec()

template<typename ErrorHandler = error_handler>

auto fmt::v8::detail::check_cstring_type_spec	(	presentation_type	type,
		ErrorHandler &&	eh = {}
	)		-> bool

Here is the caller graph for this function:

check_format_string() [1/2]

template<typename... , typename S , enable_if_t<(!is_compile_string< S >::value), int > = 0>

void fmt::v8::detail::check_format_string ( const S &  )

inline

Here is the caller graph for this function:

check_format_string() [2/2]

template<typename... , typename S , enable_if_t<(is_compile_string< S >::value), int > = 0>

void fmt::v8::detail::check_format_string

(

S

format_str

)

Here is the call graph for this function:

Here is the caller graph for this function:

check_int_type_spec()

template<typename ErrorHandler >

void fmt::v8::detail::check_int_type_spec	(	presentation_type	type,
		ErrorHandler &&	eh
	)

Here is the caller graph for this function:

check_pointer_type_spec()

template<typename ErrorHandler >

void fmt::v8::detail::check_pointer_type_spec	(	presentation_type	type,
		ErrorHandler &&	eh
	)

Here is the caller graph for this function:

check_string_type_spec()

template<typename ErrorHandler = error_handler>

void fmt::v8::detail::check_string_type_spec	(	presentation_type	type,
		ErrorHandler &&	eh = {}
	)

Here is the caller graph for this function:

code_point_index() [1/2]

template<typename Char >

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

inline

code_point_index() [2/2]

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

inline

Here is the caller graph for this function:

code_point_length()

template<typename Char >

auto fmt::v8::detail::code_point_length

(

const Char *

begin

)

-> int

Here is the call graph for this function:

Here is the caller graph for this function:

compute_width() [1/3]

template<typename Char >

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

inline

compute_width() [2/3]

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

inline

Here is the caller graph for this function:

compute_width() [3/3]

size_t fmt::v8::detail::compute_width ( string_view  s )

inline

Here is the call graph for this function:

const_check()

template<typename T >

constexpr auto fmt::v8::detail::const_check ( T  value ) -> T

inlineconstexpr

Here is the call graph for this function:

Here is the caller graph for this function:

convert_arg()

template<typename T , typename Context , typename Char >

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

Here is the call graph for this function:

Here is the caller graph for this function:

convert_for_visit()

template<typename T >

auto fmt::v8::detail::convert_for_visit ( T  ) -> monostate

inline

Here is the caller graph for this function:

copy() [1/4]

template<typename OutputIterator >

OutputIterator fmt::v8::detail::copy	(	char	ch,
		OutputIterator	out
	)

copy() [2/4]

template<typename OutputIterator >

OutputIterator fmt::v8::detail::copy	(	const char *	str,
		OutputIterator	out
	)

copy() [3/4]

template<typename RangeT , typename OutputIterator >

OutputIterator fmt::v8::detail::copy	(	const RangeT &	range,
		OutputIterator	out
	)

Here is the call graph for this function:

Here is the caller graph for this function:

copy() [4/4]

template<typename OutputIterator >

OutputIterator fmt::v8::detail::copy	(	wchar_t	ch,
		OutputIterator	out
	)

Here is the caller graph for this function:

copy2()

template<typename Char >

void fmt::v8::detail::copy2 ( Char *  dst, const char *  src  )

inline

Here is the call graph for this function:

Here is the caller graph for this function:

copy_str() [1/4]

template<typename Char , typename InputIt >

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

Here is the call graph for this function:

copy_str() [2/4]

template<typename Char , typename InputIt >

counting_iterator fmt::v8::detail::copy_str ( InputIt  begin, InputIt  end, counting_iterator  it  )

inline

Here is the call graph for this function:

copy_str() [3/4]

template<typename Char , typename InputIt , typename OutputIt >

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

Here is the call graph for this function:

copy_str() [4/4]

template<typename Char , typename T , typename U , enable_if_t<(std::is_same< remove_const_t< T >, U >::value &&is_char< U >::value), int > = 0>

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

Here is the call graph for this function:

copy_str_noinline()

template<typename OutChar , typename InputIt , typename OutputIt >

auto fmt::v8::detail::copy_str_noinline	(	InputIt	begin,
		InputIt	end,
		OutputIt	out
	)		-> OutputIt

Here is the call graph for this function:

copy_unit() [1/2]

template<typename Char , typename OutputIt >

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

Here is the call graph for this function:

copy_unit() [2/2]

template<typename OutputIt >

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

Here is the call graph for this function:

Here is the caller graph for this function:

count() [1/2]

template<bool B = false>

constexpr auto fmt::v8::detail::count ( ) -> size_t

constexpr

count() [2/2]

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

constexpr auto fmt::v8::detail::count ( ) -> size_t

constexpr

Here is the caller graph for this function:

count_digits() [1/3]

template<int BITS, typename UInt >

auto fmt::v8::detail::count_digits

(

UInt

n

)

-> int

count_digits() [2/3]

auto fmt::v8::detail::count_digits ( uint32_t  n ) -> int

inline

Here is the call graph for this function:

Here is the caller graph for this function:

count_digits() [3/3]

auto fmt::v8::detail::count_digits ( uint64_t  n ) -> int

inline

Here is the call graph for this function:

Here is the caller graph for this function:

count_digits< 4 >()

template<>

auto fmt::v8::detail::count_digits< 4 >

(

detail::fallback_uintptr

n

)

Here is the caller graph for this function:

count_digits_fallback()

template<typename T >

auto fmt::v8::detail::count_digits_fallback

(

T

n

)

-> int

Here is the caller graph for this function:

count_fractional_digits()

constexpr int fmt::v8::detail::count_fractional_digits ( long long  num, long long  den, int  n = 0  )

constexpr

Here is the caller graph for this function:

count_named_args()

template<typename... Args>

constexpr auto fmt::v8::detail::count_named_args ( ) -> size_t

constexpr

Here is the call graph for this function:

count_statically_named_args()

template<typename... Args>

constexpr auto fmt::v8::detail::count_statically_named_args ( ) -> size_t

constexpr

Here is the call graph for this function:

decimal_point() [1/2]

template<typename Char >

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

inline

Here is the caller graph for this function:

decimal_point() [2/2]

template<>

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

inline

Here is the caller graph for this function:

decimal_point_impl() [1/2]

template<typename Char >

template auto fmt::v8::detail::decimal_point_impl

(

locale_ref

loc

)

Here is the call graph for this function:

decimal_point_impl() [2/2]

template<typename Char >

auto fmt::v8::detail::decimal_point_impl

(

locale_ref

loc

)

-> Char

Here is the call graph for this function:

digits10()

template<typename Int >

constexpr auto fmt::v8::detail::digits10 ( ) -> int throw ( )

constexpr

Here is the caller graph for this function:

digits10< int128_t >()

template<>

constexpr auto fmt::v8::detail::digits10< int128_t > ( ) -> int throw ( )

constexpr

digits10< uint128_t >()

template<>

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

constexpr

digits2()

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

constexpr

Here is the caller graph for this function:

do_parse_arg_id()

template<typename Char , typename IDHandler >

auto fmt::v8::detail::do_parse_arg_id	(	const Char *	begin,
		const Char *	end,
		IDHandler &&	handler
	)		-> const Char*

Here is the call graph for this function:

Here is the caller graph for this function:

do_write()

template<typename Char >

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

inline

Here is the call graph for this function:

do_write_float()

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

auto fmt::v8::detail::do_write_float	(	OutputIt	out,
		const DecimalFP &	fp,
		const basic_format_specs< Char > &	specs,
		float_specs	fspecs,
		locale_ref	loc
	)		-> OutputIt

Here is the call graph for this function:

Here is the caller graph for this function:

encode_types() [1/2]

template<typename >

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

constexpr

encode_types() [2/2]

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

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

constexpr

equal2() [1/2]

template<typename Char >

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

equal2() [2/2]

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

inline

Here is the caller graph for this function:

exponent_mask()

template<typename T >

constexpr auto fmt::v8::detail::exponent_mask ( ) -> typename dragonbox::float_info<T>::carrier_uint

constexpr

Here is the caller graph for this function:

fill()

template<typename OutputIt , typename Char >

auto fmt::v8::detail::fill	(	OutputIt	it,
		size_t	n,
		const fill_t< Char > &	fill
	)		-> OutputIt

Here is the call graph for this function:

Here is the caller graph for this function:

fill_n() [1/2]

template<typename OutputIt , typename Size , typename T >

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

Here is the caller graph for this function:

fill_n() [2/2]

template<typename T , typename Size >

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

Here is the call graph for this function:

Here is the caller graph for this function:

find()

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

find< false, char >()

template<>

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

inline

Here is the call graph for this function:

find_escape() [1/2]

template<typename Char >

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

Here is the call graph for this function:

find_escape() [2/2]

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

inline

Here is the call graph for this function:

Here is the caller graph for this function:

first()

template<typename T , typename... Tail>

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

Here is the caller graph for this function:

fmt_safe_duration_cast()

template<typename To , typename FromRep , typename FromPeriod >

To fmt::v8::detail::fmt_safe_duration_cast

(

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

from

)

for_each() [1/2]

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

void fmt::v8::detail::for_each	(	index_sequence< Is... >	,
		Tuple &&	tup,
		F &&	f
	)
throw	(
	)

Here is the call graph for this function:

for_each() [2/2]

template<class Tuple , class F >

void fmt::v8::detail::for_each	(	Tuple &&	tup,
		F &&	f
	)

Here is the call graph for this function:

Here is the caller graph for this function:

for_each_codepoint()

template<typename F >

void fmt::v8::detail::for_each_codepoint	(	string_view	s,
		F	f
	)

Here is the call graph for this function:

Here is the caller graph for this function:

format_decimal() [1/2]

template<typename Char , typename UInt >

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

Here is the call graph for this function:

format_decimal() [2/2]

template<typename Char , typename UInt , typename Iterator , enable_if_t<(!std::is_pointer< remove_cvref_t< Iterator >>::value), int > = 0>

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

inline

Here is the call graph for this function:

Here is the caller graph for this function:

format_dragon()

void fmt::v8::detail::format_dragon ( fp  value, bool  is_predecessor_closer, int  num_digits, buffer< char > &  buf, int &  exp10  )

inline

Here is the call graph for this function:

Here is the caller graph for this function:

format_duration_unit()

template<typename Char , typename Period , typename OutputIt >

OutputIt fmt::v8::detail::format_duration_unit

(

OutputIt

out

)

Here is the call graph for this function:

format_duration_value()

template<typename Char , typename Rep , typename OutputIt , enable_if_t<(std::is_integral< Rep >::value), int > = 0>

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

format_error_code()

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

Here is the call graph for this function:

Here is the caller graph for this function:

format_float() [1/2]

template<typename Float >

int fmt::v8::detail::format_float	(	Float	value,
		int	precision,
		float_specs	specs,
		buffer< char > &	buf
	)

Here is the call graph for this function:

format_float() [2/2]

template<typename T >

auto fmt::v8::detail::format_float	(	T	value,
		int	precision,
		float_specs	specs,
		buffer< char > &	buf
	)		-> int

format_float< double >()

template auto fmt::v8::detail::format_float< double >	(	double	value,
		int	precision,
		float_specs	specs,
		buffer< char > &	buf
	)		-> int

format_float< long double >()

template auto fmt::v8::detail::format_float< long double >	(	long double	value,
		int	precision,
		float_specs	specs,
		buffer< char > &	buf
	)		-> int

format_uint() [1/3]

template<unsigned BASE_BITS, typename Char >

auto fmt::v8::detail::format_uint	(	Char *	buffer,
		detail::fallback_uintptr	n,
		int	num_digits,
		bool	= false
	)		-> Char*

format_uint() [2/3]

template<unsigned BASE_BITS, typename Char , typename UInt >

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

Here is the call graph for this function:

format_uint() [3/3]

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

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

inline

Here is the call graph for this function:

format_value()

template<typename Char , typename T >

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

Here is the call graph for this function:

Here is the caller graph for this function:

fputs()

template<typename Char >

void fmt::v8::detail::fputs ( const Char *  chars, FILE *  stream  ) throw ( )

inline

Here is the caller graph for this function:

fputs< wchar_t >()

template<>

void fmt::v8::detail::fputs< wchar_t > ( const wchar_t *  chars, FILE *  stream  ) throw ( )

inline

fwrite_fully()

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

inline

Here is the call graph for this function:

Here is the caller graph for this function:

get_arg()

template<typename Context , typename ID >

auto fmt::v8::detail::get_arg	(	Context &	ctx,
		ID	id
	)		-> typename Context::format_arg

Here is the call graph for this function:

Here is the caller graph for this function:

get_arg_index_by_name()

template<typename... Args, typename Char >

auto fmt::v8::detail::get_arg_index_by_name

(

basic_string_view< Char >

name

)

-> int

Here is the call graph for this function:

Here is the caller graph for this function:

get_buffer()

template<typename T , typename OutputIt >

auto fmt::v8::detail::get_buffer

(

OutputIt

out

)

-> iterator_buffer<OutputIt, T>

Here is the caller graph for this function:

get_cached_power()

fp fmt::v8::detail::get_cached_power ( int  min_exponent, int &  pow10_exponent  )

inline

Here is the caller graph for this function:

get_classic_locale()

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

inline

Here is the caller graph for this function:

get_container()

template<typename Container >

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

inline

Here is the caller graph for this function:

get_data() [1/2]

template<typename Container >

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

inline

Here is the caller graph for this function:

get_data() [2/2]

template<typename Char >

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

inline

get_dynamic_spec()

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

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

Here is the call graph for this function:

get_indexes()

template<class T >

make_index_sequence<std::tuple_size<T>::value> fmt::v8::detail::get_indexes

(

T const &

)

Here is the caller graph for this function:

get_iterator() [1/2]

template<typename Buffer >

auto fmt::v8::detail::get_iterator

(

Buffer &

buf

)

-> decltype(buf.out())

Here is the caller graph for this function:

get_iterator() [2/2]

template<typename T >

auto fmt::v8::detail::get_iterator

(

buffer< T > &

buf

)

-> buffer_appender<T>

Here is the caller graph for this function:

get_milliseconds()

template<typename Rep , typename Period , enable_if_t<(std::is_integral< Rep >::value), int > = 0>

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

inline

get_round_direction()

round_direction fmt::v8::detail::get_round_direction ( uint64_t  divisor, uint64_t  remainder, uint64_t  error  )

inline

Here is the caller graph for this function:

get_significand_size() [1/2]

constexpr auto fmt::v8::detail::get_significand_size ( const big_decimal_fp &  fp ) -> int

constexpr

get_significand_size() [2/2]

template<typename T >

auto fmt::v8::detail::get_significand_size ( const dragonbox::decimal_fp< T > &  fp ) -> int

inline

Here is the call graph for this function:

Here is the caller graph for this function:

get_units()

template<typename Period >

const char* fmt::v8::detail::get_units ( )

inline

Here is the call graph for this function:

gmtime_r()

null fmt::v8::detail::gmtime_r (   ... )

inline

Here is the caller graph for this function:

gmtime_s()

null fmt::v8::detail::gmtime_s (   ... )

inline

Here is the caller graph for this function:

grisu_gen_digits()

digits::result fmt::v8::detail::grisu_gen_digits ( fp  value, uint64_t  error, int &  exp, gen_digits_handler &  handler  )

inline

Here is the call graph for this function:

Here is the caller graph for this function:

handle_dynamic_spec()

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

void fmt::v8::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 fmt::v8::detail::has_const_formatter ( ) -> bool

constexpr

has_const_formatter_impl() [1/2]

template<typename Context >

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

constexpr

has_const_formatter_impl() [2/2]

template<typename Context , typename T >

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

constexpr

ignore_unused()

template<typename... T>

void fmt::v8::detail::ignore_unused

(

const T &

...

)

Here is the caller graph for this function:

init_named_args() [1/3]

template<typename Char >

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

inline

init_named_args() [2/3]

template<typename Char , typename T , typename... Tail, enable_if_t<(!is_named_arg< T >::value), int > = 0>

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

Here is the call graph for this function:

init_named_args() [3/3]

template<typename... Args>

void fmt::v8::detail::init_named_args ( std::nullptr_t  , int  , int  , const Args &  ...  )

inline

Here is the caller graph for this function:

is_arithmetic_type()

constexpr bool fmt::v8::detail::is_arithmetic_type ( type  t )

constexpr

Here is the caller graph for this function:

is_ascii_letter()

template<typename Char >

constexpr bool fmt::v8::detail::is_ascii_letter ( Char  c )

constexpr

Here is the caller graph for this function:

is_big_endian()

auto fmt::v8::detail::is_big_endian ( ) -> bool

inline

Here is the caller graph for this function:

is_constant_evaluated()

constexpr auto fmt::v8::detail::is_constant_evaluated ( bool  default_value = false ) -> bool throw ( )

inlineconstexpr

Here is the call graph for this function:

Here is the caller graph for this function:

is_integral_type()

constexpr bool fmt::v8::detail::is_integral_type ( type  t )

constexpr

Here is the caller graph for this function:

is_name_start()

template<typename Char >

bool fmt::v8::detail::is_name_start

(

Char

c

)

Here is the caller graph for this function:

is_negative()

template<typename T , enable_if_t<(is_signed< T >::value), int > = 0>

auto fmt::v8::detail::is_negative

(

T

value

)

-> bool

Here is the caller graph for this function:

is_printable() [1/2]

auto fmt::v8::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]

auto fmt::v8::detail::is_printable ( uint32_t  cp ) -> bool

inline

Here is the caller graph for this function:

is_supported_floating_point()

template<typename T , enable_if_t<(std::is_floating_point< T >::value), int > = 0>

auto fmt::v8::detail::is_supported_floating_point

(

T

)

-> uint16_t

Here is the call graph for this function:

Here is the caller graph for this function:

is_utf8()

constexpr auto fmt::v8::detail::is_utf8 ( ) -> bool

constexpr

Here is the caller graph for this function:

isfinite()

template<typename T , enable_if_t<(std::is_integral< T >::value), int > = 0>

bool fmt::v8::detail::isfinite ( T  value )

inline

Here is the caller graph for this function:

isinf()

template<typename T , enable_if_t<(std::is_floating_point< T >::value), int > = 0>

bool fmt::v8::detail::isinf

(

T

value

)

Here is the call graph for this function:

Here is the caller graph for this function:

isnan()

template<typename T , enable_if_t<(std::is_integral< T >::value), int > = 0>

bool fmt::v8::detail::isnan ( T  value )

inline

Here is the caller graph for this function:

localtime_r()

null fmt::v8::detail::localtime_r (   ... )

inline

Here is the caller graph for this function:

localtime_s()

null fmt::v8::detail::localtime_s (   ... )

inline

Here is the caller graph for this function:

make_arg() [1/3]

template<typename Context , typename T >

auto fmt::v8::detail::make_arg

(

const T &

value

)

-> basic_format_arg<Context>

Here is the call graph for this function:

make_arg() [2/3]

template<bool IS_PACKED, typename Context , type , typename T , enable_if_t<(!IS_PACKED), int > = 0>

auto fmt::v8::detail::make_arg ( const T &  value ) -> basic_format_arg<Context>

inline

Here is the caller graph for this function:

make_arg() [3/3]

template<bool IS_PACKED, typename Context , type , typename T , enable_if_t<(IS_PACKED), int > = 0>

auto fmt::v8::detail::make_arg ( T &&  val ) -> value<Context>

inline

Here is the call graph for this function:

make_background_color()

template<typename Char >

ansi_color_escape<Char> fmt::v8::detail::make_background_color	(	detail::color_type	background	)
throw	(
	)

make_checked()

template<typename T >

constexpr auto fmt::v8::detail::make_checked ( T *  p, size_t    ) -> T*

constexpr

Here is the caller graph for this function:

make_emphasis()

template<typename Char >

ansi_color_escape<Char> fmt::v8::detail::make_emphasis	(	emphasis	em	)
throw	(
	)

make_foreground_color()

template<typename Char >

ansi_color_escape<Char> fmt::v8::detail::make_foreground_color	(	detail::color_type	foreground	)
throw	(
	)

make_write_int_arg()

template<typename T >

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

Here is the call graph for this function:

Here is the caller graph for this function:

max_value()

template<typename T >

constexpr auto fmt::v8::detail::max_value ( ) -> T

constexpr

Here is the call graph for this function:

mod()

template<typename T , enable_if_t<(std::is_integral< T >::value), int > = 0>

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

inline

Here is the caller graph for this function:

multiply()

uint64_t fmt::v8::detail::multiply ( uint64_t  lhs, uint64_t  rhs  )

inline

Here is the caller graph for this function:

needs_escape()

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

inline

Here is the call graph for this function:

Here is the caller graph for this function:

normalize()

template<int SHIFT = 0>

fp fmt::v8::detail::normalize

(

fp

value

)

Here is the caller graph for this function:

num_bits()

template<typename T >

constexpr auto fmt::v8::detail::num_bits ( ) -> int

constexpr

Here is the caller graph for this function:

num_bits< fallback_uintptr >()

template<>

constexpr auto fmt::v8::detail::num_bits< fallback_uintptr > ( ) -> int

constexpr

num_bits< int128_t >()

template<>

constexpr auto fmt::v8::detail::num_bits< int128_t > ( ) -> int

constexpr

num_bits< uint128_t >()

template<>

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

constexpr

num_significand_bits()

template<typename Float >

constexpr int fmt::v8::detail::num_significand_bits ( )

constexpr

operator*()

fp fmt::v8::detail::operator* ( fp  x, fp  y  )

inline

Here is the call graph for this function:

Here is the caller graph for this function:

operator==()

bool fmt::v8::detail::operator== ( fp  x, fp  y  )

inline

parse_align()

template<typename Char , typename Handler >

auto fmt::v8::detail::parse_align	(	const Char *	begin,
		const Char *	end,
		Handler &&	handler
	)		-> const Char*

Here is the call graph for this function:

Here is the caller graph for this function:

parse_arg_id()

template<typename Char , typename IDHandler >

auto fmt::v8::detail::parse_arg_id ( const Char *  begin, const Char *  end, IDHandler &&  handler  ) -> const Char*

inline

Here is the call graph for this function:

Here is the caller graph for this function:

parse_chrono_format()

template<typename Char , typename Handler >

const Char* fmt::v8::detail::parse_chrono_format	(	const Char *	begin,
		const Char *	end,
		Handler &&	handler
	)

Here is the call graph for this function:

Here is the caller graph for this function:

parse_flags()

template<typename Char >

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

Here is the call graph for this function:

Here is the caller graph for this function:

parse_float_type_spec()

template<typename ErrorHandler = error_handler, typename Char >

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

Here is the caller graph for this function:

parse_format_specs() [1/2]

template<typename Char , typename SpecHandler >

auto fmt::v8::detail::parse_format_specs ( const Char *  begin, const Char *  end, SpecHandler &&  handler  ) -> const Char*

inline

Here is the call graph for this function:

Here is the caller graph for this function:

parse_format_specs() [2/2]

template<typename T , typename ParseContext >

auto fmt::v8::detail::parse_format_specs

(

ParseContext &

ctx

)

-> decltype(ctx.begin())

Here is the call graph for this function:

Here is the caller graph for this function:

parse_format_string()

template<bool IS_CONSTEXPR, typename Char , typename Handler >

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

inline

Here is the call graph for this function:

parse_header()

template<typename Char , typename GetArg >

int fmt::v8::detail::parse_header	(	const Char *&	it,
		const Char *	end,
		basic_format_specs< Char > &	specs,
		GetArg	get_arg
	)

Here is the call graph for this function:

Here is the caller graph for this function:

parse_nonnegative_int()

template<typename Char >

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

noexcept

Here is the call graph for this function:

Here is the caller graph for this function:

parse_precision()

template<typename Char , typename Handler >

auto fmt::v8::detail::parse_precision	(	const Char *	begin,
		const Char *	end,
		Handler &&	handler
	)		-> const Char*

Here is the call graph for this function:

Here is the caller graph for this function:

parse_presentation_type()

template<typename Char >

auto fmt::v8::detail::parse_presentation_type

(

Char

type

)

-> presentation_type

Here is the call graph for this function:

Here is the caller graph for this function:

parse_replacement_field()

template<typename Char , typename Handler >

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

Here is the call graph for this function:

Here is the caller graph for this function:

parse_width()

template<typename Char , typename Handler >

auto fmt::v8::detail::parse_width	(	const Char *	begin,
		const Char *	end,
		Handler &&	handler
	)		-> const Char*

Here is the call graph for this function:

Here is the caller graph for this function:

pow10()

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

constexpr

Here is the caller graph for this function:

prefix_append()

void fmt::v8::detail::prefix_append ( unsigned &  prefix, unsigned  value  )

inline

Here is the call graph for this function:

Here is the caller graph for this function:

print()

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

Here is the call graph for this function:

Here is the caller graph for this function:

promote_float() [1/2]

constexpr auto fmt::v8::detail::promote_float ( float  value ) -> double

constexpr

Here is the call graph for this function:

promote_float() [2/2]

template<typename T >

constexpr auto fmt::v8::detail::promote_float ( T  value ) -> T

constexpr

Here is the call graph for this function:

range_begin() [1/2]

template<typename T , std::size_t N>

auto fmt::v8::detail::range_begin

(

const T(&)

arr[N]

)

-> const T*

Here is the caller graph for this function:

range_begin() [2/2]

template<typename T >

auto fmt::v8::detail::range_begin

(

T &&

rng

)

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

range_end() [1/2]

template<typename T , std::size_t N>

auto fmt::v8::detail::range_end

(

const T(&)

arr[N]

)

-> const T*

Here is the caller graph for this function:

range_end() [2/2]

template<typename T >

auto fmt::v8::detail::range_end

(

T &&

rng

)

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

report_error()

void fmt::v8::detail::report_error	(	format_func	func,
		int	error_code,
		const char *	message
	)
throw	(
	)

Here is the call graph for this function:

Here is the caller graph for this function:

reserve() [1/3]

template<typename T >

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

inline

Here is the call graph for this function:

reserve() [2/3]

template<typename Iterator >

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

constexpr

Here is the caller graph for this function:

reserve() [3/3]

template<typename Container , enable_if_t<(is_contiguous< Container >::value), int > = 0>

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

inline

Here is the call graph for this function:

reset_color() [1/2]

template<typename Char >

void fmt::v8::detail::reset_color ( buffer< Char > &  buffer ) throw ( )

inline

Here is the call graph for this function:

reset_color() [2/2]

template<typename Char >

void fmt::v8::detail::reset_color ( FILE *  stream ) throw ( )

inline

Here is the call graph for this function:

reset_color< wchar_t >()

template<>

void fmt::v8::detail::reset_color< wchar_t > ( FILE *  stream ) throw ( )

inline

Here is the call graph for this function:

sign()

template<typename Char , typename Sign >

constexpr Char fmt::v8::detail::sign ( Sign  s )

constexpr

Here is the call graph for this function:

Here is the caller graph for this function:

signbit()

template<typename T , enable_if_t<(std::is_floating_point< T >::value), int > = 0>

bool fmt::v8::detail::signbit ( T  value )

inline

Here is the call graph for this function:

Here is the caller graph for this function:

snprintf_float() [1/3]

void fmt::v8::detail::snprintf_float ( float  , int  , float_specs  , buffer< char > &    )

delete

snprintf_float() [2/3]

template<typename T >

int fmt::v8::detail::snprintf_float	(	T	value,
		int	precision,
		float_specs	specs,
		buffer< char > &	buf
	)

Here is the call graph for this function:

Here is the caller graph for this function:

snprintf_float() [3/3]

template<typename T >

auto fmt::v8::detail::snprintf_float	(	T	value,
		int	precision,
		float_specs	specs,
		buffer< char > &	buf
	)		-> int

Here is the call graph for this function:

Here is the caller graph for this function:

snprintf_float< double >()

template auto fmt::v8::detail::snprintf_float< double >	(	double	value,
		int	precision,
		float_specs	specs,
		buffer< char > &	buf
	)		-> int

snprintf_float< long double >()

template auto fmt::v8::detail::snprintf_float< long double >	(	long double	value,
		int	precision,
		float_specs	specs,
		buffer< char > &	buf
	)		-> int

thousands_sep() [1/2]

template<typename Char >

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

inline

Here is the call graph for this function:

Here is the caller graph for this function:

thousands_sep() [2/2]

template<>

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

inline

Here is the call graph for this function:

thousands_sep_impl()

template<typename Char >

auto fmt::v8::detail::thousands_sep_impl

(

locale_ref

loc

)

-> thousands_sep_result< Char >

Here is the call graph for this function:

thousands_sep_impl< char >()

template auto fmt::v8::detail::thousands_sep_impl< char >

(

locale_ref

)

-> thousands_sep_result< char >

Here is the caller graph for this function:

thousands_sep_impl< wchar_t >()

template auto fmt::v8::detail::thousands_sep_impl< wchar_t >

(

locale_ref

)

-> thousands_sep_result< wchar_t >

Here is the caller graph for this function:

throw_format_error()

void fmt::v8::detail::throw_format_error

(

const char *

message

)

Here is the caller graph for this function:

tm_mon_full_name()

const char* fmt::v8::detail::tm_mon_full_name ( int  mon )

inline

Here is the caller graph for this function:

tm_mon_short_name()

const char* fmt::v8::detail::tm_mon_short_name ( int  mon )

inline

Here is the caller graph for this function:

tm_wday_full_name()

const char* fmt::v8::detail::tm_wday_full_name ( int  wday )

inline

Here is the caller graph for this function:

tm_wday_short_name()

const char* fmt::v8::detail::tm_wday_short_name ( int  wday )

inline

Here is the caller graph for this function:

to_ascii()

template<typename Char , enable_if_t<(std::is_integral< Char >::value), int > = 0>

constexpr auto fmt::v8::detail::to_ascii ( Char  value ) -> Char

constexpr

Here is the call graph for this function:

Here is the caller graph for this function:

to_nonnegative_int()

template<typename T , typename Int , enable_if_t<(std::is_integral< T >::value), int > = 0>

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

inline

Here is the call graph for this function:

Here is the caller graph for this function:

to_pointer() [1/2]

template<typename T >

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

Here is the call graph for this function:

to_pointer() [2/2]

template<typename T , typename OutputIt >

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

constexpr

to_string_view()

void fmt::v8::detail::to_string_view

(

...

)

Here is the caller graph for this function:

to_uintptr()

auto fmt::v8::detail::to_uintptr ( const void *  p ) -> fallback_uintptr

inline

Here is the caller graph for this function:

to_unsigned()

template<typename Int >

auto fmt::v8::detail::to_unsigned

(

Int

value

)

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

Here is the call graph for this function:

Here is the caller graph for this function:

unwrap() [1/2]

template<typename T >

const T& fmt::v8::detail::unwrap

(

const std::reference_wrapper< T > &

v

)

Here is the caller graph for this function:

unwrap() [2/2]

template<typename T >

const T& fmt::v8::detail::unwrap

(

const T &

v

)

utf8_decode()

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

inline

Here is the call graph for this function:

Here is the caller graph for this function:

vformat()

template<typename Locale , typename Char >

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

Here is the call graph for this function:

vformat_to() [1/2]

template<typename Char >

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

Here is the call graph for this function:

vformat_to() [2/2]

template<typename Char >

void fmt::v8::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
	)

Here is the call graph for this function:

Here is the caller graph for this function:

vprint_mojibake()

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

inline

Here is the caller graph for this function:

vprintf()

template<typename Char , typename Context >

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

Here is the call graph for this function:

write() [1/16]

template<typename Char , typename OutputIt >

auto fmt::v8::detail::write	(	OutputIt	out,
		basic_string_view< Char >	s,
		const basic_format_specs< Char > &	specs
	)		-> OutputIt

Here is the call graph for this function:

write() [2/16]

template<typename Char , typename OutputIt >

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

Here is the call graph for this function:

write() [3/16]

template<typename Char , typename OutputIt >

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

Here is the call graph for this function:

write() [4/16]

template<typename Char , typename OutputIt >

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

Here is the call graph for this function:

write() [5/16]

template<typename Char , typename OutputIt >

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

write() [6/16]

template<typename Char , typename OutputIt >

auto fmt::v8::detail::write	(	OutputIt	out,
		const Char *	s,
		const basic_format_specs< Char > &	specs,
		locale_ref
	)		-> OutputIt

Here is the call graph for this function:

write() [7/16]

template<typename Char , typename OutputIt >

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

Here is the call graph for this function:

write() [8/16]

template<typename Char , typename OutputIt , enable_if_t<(!std::is_same< Char, char >::value), int > = 0>

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

Here is the call graph for this function:

Here is the caller graph for this function:

write() [9/16]

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

write() [10/16]

template<typename Char , typename OutputIt , typename T , enable_if_t<(is_string< T >::value), int > = 0>

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

constexpr

Here is the call graph for this function:

write() [11/16]

template<typename Char , typename OutputIt , typename T , enable_if_t<(std::is_same< T, void >::value), int > = 0>

auto fmt::v8::detail::write	(	OutputIt	out,
		const T *	value,
		const basic_format_specs< Char > &	specs = {},
		locale_ref	= {}
	)		-> OutputIt

write() [12/16]

template<typename Char , typename OutputIt >

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

write() [13/16]

template<typename Char , typename OutputIt , typename T , enable_if_t<(is_fast_float< T >::value), int > = 0>

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

inline

Here is the call graph for this function:

write() [14/16]

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, enable_if_t<(check), int > = 0>

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

write() [15/16]

template<typename Char , typename OutputIt , typename T , enable_if_t<(std::is_floating_point< T >::value), int > = 0>

auto fmt::v8::detail::write	(	OutputIt	out,
		T	value,
		basic_format_specs< Char >	specs,
		locale_ref	loc = {}
	)		-> OutputIt

write() [16/16]

template<typename Char , typename OutputIt , typename T , enable_if_t<(is_integral< T >::value &&!std::is_same< T, bool >::value &&std::is_same< OutputIt, buffer_appender< Char >>::value), int > = 0>

auto fmt::v8::detail::write ( OutputIt  out, T  value, const basic_format_specs< Char > &  specs = {}, locale_ref  loc = {}  ) -> OutputIt

inline

Here is the call graph for this function:

write_buffer()

template<typename Char >

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

Here is the call graph for this function:

Here is the caller graph for this function:

write_bytes()

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

auto fmt::v8::detail::write_bytes	(	OutputIt	out,
		string_view	bytes,
		const basic_format_specs< Char > &	specs
	)		-> OutputIt

Here is the caller graph for this function:

write_char()

template<typename Char , typename OutputIt >

auto fmt::v8::detail::write_char	(	OutputIt	out,
		Char	value,
		const basic_format_specs< Char > &	specs
	)		-> OutputIt

Here is the call graph for this function:

Here is the caller graph for this function:

write_codecvt()

template<typename CodeUnit >

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

Here is the call graph for this function:

Here is the caller graph for this function:

write_delimiter()

template<typename OutputIt >

OutputIt fmt::v8::detail::write_delimiter

(

OutputIt

out

)

Here is the caller graph for this function:

write_digit2_separated()

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

inline

Here is the call graph for this function:

Here is the caller graph for this function:

write_encoded_tm_str()

template<typename OutputIt >

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

Here is the call graph for this function:

write_exponent()

template<typename Char , typename It >

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

Here is the call graph for this function:

write_float()

template<typename OutputIt , typename DecimalFP , typename Char >

auto fmt::v8::detail::write_float	(	OutputIt	out,
		const DecimalFP &	fp,
		const basic_format_specs< Char > &	specs,
		float_specs	fspecs,
		locale_ref	loc
	)		-> OutputIt

Here is the call graph for this function:

Here is the caller graph for this function:

write_int() [1/2]

template<typename OutputIt , typename Char , typename W >

auto fmt::v8::detail::write_int ( OutputIt  out, int  num_digits, unsigned  prefix, const basic_format_specs< Char > &  specs, W  write_digits  ) -> OutputIt

inline

Here is the call graph for this function:

write_int() [2/2]

template<typename Char , typename OutputIt , typename T >

auto fmt::v8::detail::write_int ( OutputIt  out, write_int_arg< T >  arg, const basic_format_specs< Char > &  specs, locale_ref  loc  ) -> OutputIt

inline

Here is the call graph for this function:

Here is the caller graph for this function:

write_int_localized() [1/2]

template<typename OutputIt , typename UInt , typename Char >

auto fmt::v8::detail::write_int_localized	(	OutputIt &	out,
		UInt	value,
		unsigned	prefix,
		const basic_format_specs< Char > &	specs,
		locale_ref	loc
	)		-> bool

Here is the caller graph for this function:

write_int_localized() [2/2]

template<typename OutputIt , typename UInt , typename Char >

auto fmt::v8::detail::write_int_localized	(	OutputIt	out,
		UInt	value,
		unsigned	prefix,
		const basic_format_specs< Char > &	specs,
		const digit_grouping< Char > &	grouping
	)		-> OutputIt

Here is the call graph for this function:

write_int_noinline()

template<typename Char , typename OutputIt , typename T >

auto fmt::v8::detail::write_int_noinline	(	OutputIt	out,
		write_int_arg< T >	arg,
		const basic_format_specs< Char > &	specs,
		locale_ref	loc
	)		-> OutputIt

Here is the call graph for this function:

Here is the caller graph for this function:

write_nonfinite()

template<typename Char , typename OutputIt >

auto fmt::v8::detail::write_nonfinite	(	OutputIt	out,
		bool	isinf,
		basic_format_specs< Char >	specs,
		const float_specs &	fspecs
	)		-> OutputIt

Here is the call graph for this function:

Here is the caller graph for this function:

write_padded() [1/2]

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

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

constexpr

Here is the caller graph for this function:

write_padded() [2/2]

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

auto fmt::v8::detail::write_padded	(	OutputIt	out,
		const basic_format_specs< Char > &	specs,
		size_t	size,
		size_t	width,
		F &&	f
	)		-> OutputIt

Here is the call graph for this function:

write_ptr()

template<typename Char , typename OutputIt , typename UIntPtr >

auto fmt::v8::detail::write_ptr	(	OutputIt	out,
		UIntPtr	value,
		const basic_format_specs< Char > *	specs
	)		-> OutputIt

Here is the call graph for this function:

write_range_entry() [1/4]

template<typename Char , typename OutputIt >

auto fmt::v8::detail::write_range_entry	(	OutputIt	out,
		basic_string_view< Char >	str
	)		-> OutputIt

Here is the call graph for this function:

write_range_entry() [2/4]

template<typename Char , typename OutputIt , typename Arg , enable_if_t<(!is_std_string_like< typename std::decay< Arg >::type >::value &&!std::is_same< Arg, Char >::value), int > = 0>

OutputIt fmt::v8::detail::write_range_entry	(	OutputIt	out,
		const Arg &	v
	)

write_range_entry() [3/4]

template<typename Char , typename OutputIt , typename Arg , enable_if_t<(std::is_same< Arg, Char >::value), int > = 0>

OutputIt fmt::v8::detail::write_range_entry	(	OutputIt	out,
		const Arg	v
	)

write_range_entry() [4/4]

template<typename Char , typename OutputIt , typename T , enable_if_t<(std::is_convertible< T, std_string_view< char >>::value), int > = 0>

auto fmt::v8::detail::write_range_entry ( OutputIt  out, const T &  str  ) -> OutputIt

inline

write_significand() [1/7]

template<typename Char , typename UInt , enable_if_t<(std::is_integral< UInt >::value), int > = 0>

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

inline

Here is the call graph for this function:

write_significand() [2/7]

template<typename Char , typename OutputIt >

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

constexpr

write_significand() [3/7]

template<typename OutputIt , typename Char >

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

Here is the call graph for this function:

write_significand() [4/7]

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

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

Here is the call graph for this function:

write_significand() [5/7]

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

write_significand() [6/7]

template<typename Char , typename OutputIt , typename UInt >

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

inline

write_significand() [7/7]

template<typename OutputIt , typename UInt , typename Char , enable_if_t<(!std::is_pointer< remove_cvref_t< OutputIt >>::value), int > = 0>

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

inline

Here is the call graph for this function:

write_tm_str()

template<typename Char , typename OutputIt , enable_if_t<(!std::is_same< Char, char >::value), int > = 0>

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

Here is the call graph for this function:

Variable Documentation

invalid_arg_index

constexpr int fmt::v8::detail::invalid_arg_index = -1

constexpr

invalid_code_point

constexpr uint32_t fmt::v8::detail::invalid_code_point = ~uint32_t()

constexpr

log10_2_significand

constexpr uint64_t fmt::v8::detail::log10_2_significand = 0x4d104d427de7fbcc

staticconstexpr

micro

constexpr unsigned char fmt::v8::detail::micro[] = "\u00B5"

constexpr