fmt::v8 Namespace Reference

Namespaces
	align
	detail
	detail_exported
	literals
	safe_duration_cast
	sign

Classes
class	appender
class	basic_cstring_view
class	basic_format_arg
class	basic_format_args
class	basic_format_context
class	basic_format_parse_context
struct	basic_format_specs
class	basic_format_string
class	basic_memory_buffer
class	basic_printf_context
class	basic_printf_parse_context
struct	basic_runtime
class	basic_string_view
class	buffered_file
class	bytes
struct	compile_string
class	dynamic_format_arg_store
class	dynamic_formatter
class	format_arg_store
class	format_error
class	format_int
struct	format_to_n_result
struct	formatter
struct	formatter< bytes >
struct	formatter< Char *, Char >
struct	formatter< Char[N], Char >
struct	formatter< detail::bigint >
struct	formatter< detail::byte, Char >
struct	formatter< detail::std_string_view< Char >, Char >
struct	formatter< group_digits_view< T > >
struct	formatter< join_view< It, Sentinel, Char >, Char >
struct	formatter< long, Char >
struct	formatter< short, Char >
struct	formatter< signed char, Char >
struct	formatter< std::basic_string< Char >, Char >
struct	formatter< std::chrono::duration< Rep, Period >, Char >
struct	formatter< std::chrono::time_point< std::chrono::system_clock, Duration >, Char >
struct	formatter< std::error_code, Char >
struct	formatter< std::nullptr_t, Char >
struct	formatter< std::tm, Char >
struct	formatter< T, Char, enable_if_t< detail::is_map< T >::value &&(is_formattable< detail::value_type< T >, Char >::value||detail::has_fallback_formatter< detail::value_type< T >, Char >::value) > >
struct	formatter< T, Char, enable_if_t< detail::type_constant< T, Char >::value !=detail::type::custom_type > >
struct	formatter< T, Char, enable_if_t< fmt::is_range< T, Char >::value &&(is_formattable< detail::value_type< T >, Char >::value||detail::has_fallback_formatter< detail::value_type< T >, Char >::value) > >
struct	formatter< tuple_join_view< Char, T... >, Char >
struct	formatter< TupleT, Char, enable_if_t< fmt::is_tuple_like< TupleT >::value > >
struct	formatter< unsigned char, Char >
struct	formatter< unsigned long, Char >
struct	formatter< unsigned short, Char >
struct	formatter< void *, Char >
struct	formatter< weekday, Char >
struct	group_digits_view
struct	is_char
struct	is_char< char >
struct	is_char< char16_t >
struct	is_char< char32_t >
struct	is_char< detail::char8_type >
struct	is_char< wchar_t >
struct	is_compile_string
struct	is_contiguous
struct	is_contiguous< basic_memory_buffer< T, SIZE, Allocator > >
struct	is_contiguous< std::basic_string< Char > >
struct	is_range
struct	is_tuple_like
struct	join_view
struct	monostate
struct	printf_formatter
struct	rgb
class	text_style
struct	tuple_join_view
struct	type_identity
class	weekday
class	year_month_day

Typedefs
template<bool B, typename T = void>
using	enable_if_t = typename std::enable_if< B, T >::type
template<bool B, typename T , typename F >
using	conditional_t = typename std::conditional< B, T, F >::type
template<bool B>
using	bool_constant = std::integral_constant< bool, B >
template<typename T >
using	remove_reference_t = typename std::remove_reference< T >::type
template<typename T >
using	remove_const_t = typename std::remove_const< T >::type
template<typename T >
using	remove_cvref_t = typename std::remove_cv< remove_reference_t< T > >::type
template<typename T >
using	type_identity_t = typename type_identity< T >::type
using	string_view = basic_string_view< char >
template<typename S >
using	char_t = typename detail::char_t_impl< S >::type
using	format_parse_context = basic_format_parse_context< char >
template<typename T , typename Context >
using	has_formatter = std::is_constructible< typename Context::template formatter_type< T > >
template<typename Char >
using	buffer_context = basic_format_context< detail::buffer_appender< Char >, Char >
using	format_context = buffer_context< char >
template<typename T , typename Char = char>
using	is_formattable = bool_constant< !std::is_base_of< detail::unformattable, decltype(detail::arg_mapper< buffer_context< Char > >().map(std::declval< T >()))>::value &&!detail::has_fallback_formatter< T, Char >::value >
using	format_args = basic_format_args< format_context >
using	align_t = align::type
using	sign_t = sign::type
using	format_specs = basic_format_specs< char >
template<typename... Args>
using	format_string = basic_format_string< char, type_identity_t< Args >... >
using	memory_buffer = basic_memory_buffer< char >
template<typename It , typename Sentinel , typename Char >
using	arg_join = join_view< It, Sentinel, Char >
using	cstring_view = basic_cstring_view< char >
using	wcstring_view = basic_cstring_view< wchar_t >
template<typename Char >
using	basic_printf_context_t = basic_printf_context< detail::buffer_appender< Char >, Char >
using	printf_context = basic_printf_context_t< char >
using	wprintf_context = basic_printf_context_t< wchar_t >
using	printf_args = basic_format_args< printf_context >
using	wprintf_args = basic_format_args< wprintf_context >
template<typename Char , typename... T>
using	tuple_arg_join = tuple_join_view< Char, T... >
using	wstring_view = basic_string_view< wchar_t >
using	wformat_parse_context = basic_format_parse_context< wchar_t >
using	wformat_context = buffer_context< wchar_t >
using	wformat_args = basic_format_args< wformat_context >
using	wmemory_buffer = basic_memory_buffer< wchar_t >
template<typename... Args>
using	wformat_string = basic_format_string< wchar_t, type_identity_t< Args >... >

Enumerations
enum	color : uint32_t {   color::alice_blue = 0xF0F8FF, color::antique_white = 0xFAEBD7, color::aqua = 0x00FFFF, color::aquamarine = 0x7FFFD4,   color::azure = 0xF0FFFF, color::beige = 0xF5F5DC, color::bisque = 0xFFE4C4, color::black = 0x000000,   color::blanched_almond = 0xFFEBCD, color::blue = 0x0000FF, color::blue_violet = 0x8A2BE2, color::brown = 0xA52A2A,   color::burly_wood = 0xDEB887, color::cadet_blue = 0x5F9EA0, color::chartreuse = 0x7FFF00, color::chocolate = 0xD2691E,   color::coral = 0xFF7F50, color::cornflower_blue = 0x6495ED, color::cornsilk = 0xFFF8DC, color::crimson = 0xDC143C,   color::cyan = 0x00FFFF, color::dark_blue = 0x00008B, color::dark_cyan = 0x008B8B, color::dark_golden_rod = 0xB8860B,   color::dark_gray = 0xA9A9A9, color::dark_green = 0x006400, color::dark_khaki = 0xBDB76B, color::dark_magenta = 0x8B008B,   color::dark_olive_green = 0x556B2F, color::dark_orange = 0xFF8C00, color::dark_orchid = 0x9932CC, color::dark_red = 0x8B0000,   color::dark_salmon = 0xE9967A, color::dark_sea_green = 0x8FBC8F, color::dark_slate_blue = 0x483D8B, color::dark_slate_gray = 0x2F4F4F,   color::dark_turquoise = 0x00CED1, color::dark_violet = 0x9400D3, color::deep_pink = 0xFF1493, color::deep_sky_blue = 0x00BFFF,   color::dim_gray = 0x696969, color::dodger_blue = 0x1E90FF, color::fire_brick = 0xB22222, color::floral_white = 0xFFFAF0,   color::forest_green = 0x228B22, color::fuchsia = 0xFF00FF, color::gainsboro = 0xDCDCDC, color::ghost_white = 0xF8F8FF,   color::gold = 0xFFD700, color::golden_rod = 0xDAA520, color::gray = 0x808080, color::green = 0x008000,   color::green_yellow = 0xADFF2F, color::honey_dew = 0xF0FFF0, color::hot_pink = 0xFF69B4, color::indian_red = 0xCD5C5C,   color::indigo = 0x4B0082, color::ivory = 0xFFFFF0, color::khaki = 0xF0E68C, color::lavender = 0xE6E6FA,   color::lavender_blush = 0xFFF0F5, color::lawn_green = 0x7CFC00, color::lemon_chiffon = 0xFFFACD, color::light_blue = 0xADD8E6,   color::light_coral = 0xF08080, color::light_cyan = 0xE0FFFF, color::light_golden_rod_yellow = 0xFAFAD2, color::light_gray = 0xD3D3D3,   color::light_green = 0x90EE90, color::light_pink = 0xFFB6C1, color::light_salmon = 0xFFA07A, color::light_sea_green = 0x20B2AA,   color::light_sky_blue = 0x87CEFA, color::light_slate_gray = 0x778899, color::light_steel_blue = 0xB0C4DE, color::light_yellow = 0xFFFFE0,   color::lime = 0x00FF00, color::lime_green = 0x32CD32, color::linen = 0xFAF0E6, color::magenta = 0xFF00FF,   color::maroon = 0x800000, color::medium_aquamarine = 0x66CDAA, color::medium_blue = 0x0000CD, color::medium_orchid = 0xBA55D3,   color::medium_purple = 0x9370DB, color::medium_sea_green = 0x3CB371, color::medium_slate_blue = 0x7B68EE, color::medium_spring_green = 0x00FA9A,   color::medium_turquoise = 0x48D1CC, color::medium_violet_red = 0xC71585, color::midnight_blue = 0x191970, color::mint_cream = 0xF5FFFA,   color::misty_rose = 0xFFE4E1, color::moccasin = 0xFFE4B5, color::navajo_white = 0xFFDEAD, color::navy = 0x000080,   color::old_lace = 0xFDF5E6, color::olive = 0x808000, color::olive_drab = 0x6B8E23, color::orange = 0xFFA500,   color::orange_red = 0xFF4500, color::orchid = 0xDA70D6, color::pale_golden_rod = 0xEEE8AA, color::pale_green = 0x98FB98,   color::pale_turquoise = 0xAFEEEE, color::pale_violet_red = 0xDB7093, color::papaya_whip = 0xFFEFD5, color::peach_puff = 0xFFDAB9,   color::peru = 0xCD853F, color::pink = 0xFFC0CB, color::plum = 0xDDA0DD, color::powder_blue = 0xB0E0E6,   color::purple = 0x800080, color::rebecca_purple = 0x663399, color::red = 0xFF0000, color::rosy_brown = 0xBC8F8F,   color::royal_blue = 0x4169E1, color::saddle_brown = 0x8B4513, color::salmon = 0xFA8072, color::sandy_brown = 0xF4A460,   color::sea_green = 0x2E8B57, color::sea_shell = 0xFFF5EE, color::sienna = 0xA0522D, color::silver = 0xC0C0C0,   color::sky_blue = 0x87CEEB, color::slate_blue = 0x6A5ACD, color::slate_gray = 0x708090, color::snow = 0xFFFAFA,   color::spring_green = 0x00FF7F, color::steel_blue = 0x4682B4, color::tan = 0xD2B48C, color::teal = 0x008080,   color::thistle = 0xD8BFD8, color::tomato = 0xFF6347, color::turquoise = 0x40E0D0, color::violet = 0xEE82EE,   color::wheat = 0xF5DEB3, color::white = 0xFFFFFF, color::white_smoke = 0xF5F5F5, color::yellow = 0xFFFF00,   color::yellow_green = 0x9ACD32 }
enum	terminal_color : uint8_t {   terminal_color::black = 30, terminal_color::red, terminal_color::green, terminal_color::yellow,   terminal_color::blue, terminal_color::magenta, terminal_color::cyan, terminal_color::white,   terminal_color::bright_black = 90, terminal_color::bright_red, terminal_color::bright_green, terminal_color::bright_yellow,   terminal_color::bright_blue, terminal_color::bright_magenta, terminal_color::bright_cyan, terminal_color::bright_white }
enum	emphasis : uint8_t {   emphasis::bold = 1, emphasis::faint = 1 << 1, emphasis::italic = 1 << 2, emphasis::underline = 1 << 3,   emphasis::blink = 1 << 4, emphasis::reverse = 1 << 5, emphasis::conceal = 1 << 6, emphasis::strikethrough = 1 << 7 }
enum	presentation_type : unsigned char {   presentation_type::none, presentation_type::dec, presentation_type::oct, presentation_type::hex_lower,   presentation_type::hex_upper, presentation_type::bin_lower, presentation_type::bin_upper, presentation_type::hexfloat_lower,   presentation_type::hexfloat_upper, presentation_type::exp_lower, presentation_type::exp_upper, presentation_type::fixed_lower,   presentation_type::fixed_upper, presentation_type::general_lower, presentation_type::general_upper, presentation_type::chr,   presentation_type::string, presentation_type::pointer }
enum	{ inline_buffer_size = 500 }

Functions
std::tm	localtime (std::time_t time)
std::tm	localtime (std::chrono::time_point< std::chrono::system_clock > time_point)
std::tm	gmtime (std::time_t time)
std::tm	gmtime (std::chrono::time_point< std::chrono::system_clock > time_point)
text_style	fg (detail::color_type foreground) throw ()
text_style	bg (detail::color_type background) throw ()
text_style	operator| (emphasis lhs, emphasis rhs) throw ()
template<typename S , typename Char = char_t<S>>
void	vprint (std::FILE *f, const text_style &ts, const S &format, basic_format_args< buffer_context< type_identity_t< Char >>> args)
template<typename S , typename... Args, enable_if_t<(detail::is_string< S >::value), int > = 0>
void	print (std::FILE *f, const text_style &ts, const S &format_str, const Args &... args)
template<typename S , typename... Args, enable_if_t<(detail::is_string< S >::value), int > = 0>
void	print (const text_style &ts, const S &format_str, const Args &... args)
template<typename S , typename Char = char_t<S>>
std::basic_string< Char >	vformat (const text_style &ts, const S &format_str, basic_format_args< buffer_context< type_identity_t< Char >>> args)
template<typename S , typename... Args, typename Char = char_t<S>>
std::basic_string< Char >	format (const text_style &ts, const S &format_str, const Args &... args)
template<typename OutputIt , typename Char , enable_if_t<(detail::is_output_iterator< OutputIt, Char >::value), int > = 0>
OutputIt	vformat_to (OutputIt out, const text_style &ts, basic_string_view< Char > format_str, basic_format_args< buffer_context< type_identity_t< Char >>> args)
template<typename OutputIt , typename S , typename... Args, bool enable = detail::is_output_iterator<OutputIt, char_t<S>>::value&& detail::is_string<S>::value>
auto	format_to (OutputIt out, const text_style &ts, const S &format_str, Args &&... args) -> typename std::enable_if< enable, OutputIt >::type
template<typename OutputIt , typename S , typename... Args, enable_if_t<(detail::is_compiled_string< S >::value), int > = 0>
format_to_n_result< OutputIt >	format_to_n (OutputIt out, size_t n, const S &format_str, Args &&... args)
template<typename S , typename... Args, enable_if_t<(detail::is_compiled_string< S >::value), int > = 0>
size_t	formatted_size (const S &format_str, const Args &... args)
template<typename S , typename... Args, enable_if_t<(detail::is_compiled_string< S >::value), int > = 0>
void	print (std::FILE *f, const S &format_str, const Args &... args)
template<typename S , typename... Args, enable_if_t<(detail::is_compiled_string< S >::value), int > = 0>
void	print (const S &format_str, const Args &... args)
template<typename Char , enable_if_t<(is_char< Char >::value), int > = 0>
auto	to_string_view (const Char *s) -> basic_string_view< Char >
template<typename Char , typename Traits , typename Alloc >
auto	to_string_view (const std::basic_string< Char, Traits, Alloc > &s) -> basic_string_view< Char >
template<typename Char >
constexpr auto	to_string_view (basic_string_view< Char > s) -> basic_string_view< Char >
template<typename Char , enable_if_t<(!std::is_empty< detail::std_string_view< Char >>::value), int > = 0>
auto	to_string_view (detail::std_string_view< Char > s) -> basic_string_view< Char >
template<typename S , enable_if_t<(is_compile_string< S >::value), int > = 0>
constexpr auto	to_string_view (const S &s) -> basic_string_view< typename S::char_type >
template<typename Visitor , typename Context >
auto	visit_format_arg (Visitor &&vis, const basic_format_arg< Context > &arg) -> decltype(vis(0))
template<typename Context = format_context, typename... Args>
constexpr auto	make_format_args (Args &&... args) -> format_arg_store< Context, remove_cvref_t< Args >... >
template<typename Char , typename T >
auto	arg (const Char *name, const T &arg) -> detail::named_arg< Char, T >
template<typename S >
auto	runtime (const S &s) -> basic_runtime< char_t< S >>
auto	vformat (string_view fmt, format_args args) -> std::string
template<typename... T>
auto	format (format_string< T... > fmt, T &&... args) -> std::string
template<typename OutputIt , enable_if_t<(detail::is_output_iterator< OutputIt, char >::value), int > = 0>
auto	vformat_to (OutputIt out, string_view fmt, format_args args) -> OutputIt
template<typename OutputIt , typename... T, enable_if_t<(detail::is_output_iterator< OutputIt, char >::value), int > = 0>
auto	format_to (OutputIt out, format_string< T... > fmt, T &&... args) -> OutputIt
template<typename OutputIt , typename... T, enable_if_t<(detail::is_output_iterator< OutputIt, char >::value), int > = 0>
auto	vformat_to_n (OutputIt out, size_t n, string_view fmt, format_args args) -> format_to_n_result< OutputIt >
template<typename OutputIt , typename... T, enable_if_t<(detail::is_output_iterator< OutputIt, char >::value), int > = 0>
auto	format_to_n (OutputIt out, size_t n, format_string< T... > fmt, T &&... args) -> format_to_n_result< OutputIt >
template<typename... T>
auto	formatted_size (format_string< T... > fmt, T &&... args) -> size_t
void	vprint (string_view fmt, format_args args)
void	vprint (std::FILE *f, string_view fmt, format_args args)
template<typename... T>
void	print (format_string< T... > fmt, T &&... args)
template<typename... T>
void	print (std::FILE *f, format_string< T... > fmt, T &&... args)
std::system_error	vsystem_error (int error_code, string_view format_str, format_args args)
void	format_system_error (detail::buffer< char > &out, int error_code, const char *message) throw ()
void	report_system_error (int error_code, const char *message) throw ()
template<typename... Args, typename S , typename Char = char_t<S>>
auto	make_args_checked (const S &fmt, const remove_reference_t< Args > &... args) -> format_arg_store< buffer_context< Char >, remove_reference_t< Args >... >
template<typename... T>
auto	system_error (int error_code, format_string< T... > fmt, T &&... args) -> std::system_error
template<typename T >
auto	ptr (T p) -> const void *
template<typename T >
auto	ptr (const std::unique_ptr< T > &p) -> const void *
template<typename T >
auto	ptr (const std::shared_ptr< T > &p) -> const void *
template<typename T >
auto	group_digits (T value) -> group_digits_view< T >
template<typename It , typename Sentinel >
auto	join (It begin, Sentinel end, string_view sep) -> join_view< It, Sentinel >
template<typename Range >
auto	join (Range &&range, string_view sep) -> join_view< detail::iterator_t< Range >, detail::sentinel_t< Range >>
template<typename T , enable_if_t<(!std::is_integral< T >::value), int > = 0>
auto	to_string (const T &value) -> std::string
template<typename T , enable_if_t<(std::is_integral< T >::value), int > = 0>
auto	to_string (T value) -> std::string
template<typename Char , size_t SIZE>
auto	to_string (const basic_memory_buffer< Char, SIZE > &buf) -> std::basic_string< Char >
template<typename Locale , enable_if_t<(detail::is_locale< Locale >::value), int > = 0>
auto	vformat (const Locale &loc, string_view fmt, format_args args) -> std::string
template<typename Locale , typename... T, enable_if_t<(detail::is_locale< Locale >::value), int > = 0>
auto	format (const Locale &loc, format_string< T... > fmt, T &&... args) -> std::string
template<typename... T, size_t SIZE, typename Allocator >
auto	format_to (basic_memory_buffer< char, SIZE, Allocator > &buf, format_string< T... > fmt, T &&... args) -> appender
template<typename OutputIt , typename Locale , enable_if_t<(detail::is_output_iterator< OutputIt, char >::value &&detail::is_locale< Locale >::value), int > = 0>
auto	vformat_to (OutputIt out, const Locale &loc, string_view fmt, format_args args) -> OutputIt
template<typename OutputIt , typename Locale , typename... T, enable_if_t<(detail::is_output_iterator< OutputIt, char >::value &&detail::is_locale< Locale >::value), int > = 0>
auto	format_to (OutputIt out, const Locale &loc, format_string< T... > fmt, T &&... args) -> OutputIt
const std::error_category &	system_category () throw ()
template<typename Char >
void	vprint (std::basic_ostream< Char > &os, basic_string_view< Char > format_str, basic_format_args< buffer_context< type_identity_t< Char >>> args)
template<typename S , typename... Args, typename Char = enable_if_t<detail::is_string<S>::value, char_t<S>>>
void	print (std::basic_ostream< Char > &os, const S &format_str, Args &&... args)
template<typename... T>
auto	make_printf_args (const T &... args) -> format_arg_store< printf_context, T... >
template<typename... T>
auto	make_wprintf_args (const T &... args) -> format_arg_store< wprintf_context, T... >
template<typename S , typename Char = char_t<S>>
auto	vsprintf (const S &fmt, basic_format_args< basic_printf_context_t< type_identity_t< Char >>> args) -> std::basic_string< Char >
template<typename S , typename... T, typename Char = enable_if_t<detail::is_string<S>::value, char_t<S>>>
auto	sprintf (const S &fmt, const T &... args) -> std::basic_string< Char >
template<typename S , typename Char = char_t<S>>
auto	vfprintf (std::FILE *f, const S &fmt, basic_format_args< basic_printf_context_t< type_identity_t< Char >>> args) -> int
template<typename S , typename... T, typename Char = char_t<S>>
auto	fprintf (std::FILE *f, const S &fmt, const T &... args) -> int
template<typename S , typename Char = char_t<S>>
auto	vprintf (const S &fmt, basic_format_args< basic_printf_context_t< type_identity_t< Char >>> args) -> int
template<typename S , typename... T, enable_if_t<(detail::is_string< S >::value), int > = 0>
auto	printf (const S &fmt, const T &... args) -> int
template<typename S , typename Char = char_t<S>>
auto	vfprintf (std::basic_ostream< Char > &os, const S &fmt, basic_format_args< basic_printf_context_t< type_identity_t< Char >>> args) -> int
template<typename S , typename... T, typename Char = char_t<S>>
auto	fprintf (std::basic_ostream< Char > &os, const S &fmt, const T &... args) -> int
template<typename... T>
auto	join (const std::tuple< T... > &tuple, string_view sep) -> tuple_join_view< char, T... >
template<typename... T>
auto	join (const std::tuple< T... > &tuple, basic_string_view< wchar_t > sep) -> tuple_join_view< wchar_t, T... >
template<typename T >
auto	join (std::initializer_list< T > list, string_view sep) -> join_view< const T *, const T * >
template<typename... Args>
constexpr format_arg_store< wformat_context, Args... >	make_wformat_args (const Args &... args)
constexpr auto	operator""_format (const wchar_t *s, size_t n) -> detail::udl_formatter< wchar_t >
template<typename It , typename Sentinel >
auto	join (It begin, Sentinel end, wstring_view sep) -> join_view< It, Sentinel, wchar_t >
template<typename Range >
auto	join (Range &&range, wstring_view sep) -> join_view< detail::iterator_t< Range >, detail::sentinel_t< Range >, wchar_t >
template<typename T >
auto	join (std::initializer_list< T > list, wstring_view sep) -> join_view< const T *, const T *, wchar_t >
template<typename Char , enable_if_t<(!std::is_same< Char, char >::value), int > = 0>
auto	vformat (basic_string_view< Char > format_str, basic_format_args< buffer_context< type_identity_t< Char >>> args) -> std::basic_string< Char >
template<typename S , typename... Args, typename Char = char_t<S>, enable_if_t<(!std::is_same< Char, char >::value), int > = 0>
auto	format (const S &format_str, Args &&... args) -> std::basic_string< Char >
template<typename Locale , typename S , typename Char = char_t<S>, enable_if_t<(detail::is_locale< Locale >::value &&detail::is_exotic_char< Char >::value), int > = 0>
auto	vformat (const Locale &loc, const S &format_str, basic_format_args< buffer_context< type_identity_t< Char >>> args) -> std::basic_string< Char >
template<typename Locale , typename S , typename... Args, typename Char = char_t<S>, enable_if_t<(detail::is_locale< Locale >::value &&detail::is_exotic_char< Char >::value), int > = 0>
auto	format (const Locale &loc, const S &format_str, Args &&... args) -> std::basic_string< Char >
template<typename OutputIt , typename S , typename Char = char_t<S>, enable_if_t<(detail::is_output_iterator< OutputIt, Char >::value &&detail::is_exotic_char< Char >::value), int > = 0>
auto	vformat_to (OutputIt out, const S &format_str, basic_format_args< buffer_context< type_identity_t< Char >>> args) -> OutputIt
template<typename OutputIt , typename S , typename... Args, typename Char = char_t<S>, enable_if_t<(detail::is_output_iterator< OutputIt, Char >::value &&detail::is_exotic_char< Char >::value), int > = 0>
auto	format_to (OutputIt out, const S &fmt, Args &&... args) -> OutputIt
template<typename S , typename... Args, typename Char , size_t SIZE, typename Allocator , enable_if_t<(detail::is_string< S >::value), int > = 0>
auto	format_to (basic_memory_buffer< Char, SIZE, Allocator > &buf, const S &format_str, Args &&... args) -> typename buffer_context< Char >::iterator
template<typename Locale , typename S , typename OutputIt , typename... Args, typename Char = char_t<S>, enable_if_t<(detail::is_output_iterator< OutputIt, Char >::value &&detail::is_locale< Locale >::value &&detail::is_exotic_char< Char >::value), int > = 0>
auto	vformat_to (OutputIt out, const Locale &loc, const S &format_str, basic_format_args< buffer_context< type_identity_t< Char >>> args) -> OutputIt
template<typename OutputIt , typename Locale , typename S , typename... Args, typename Char = char_t<S>, bool enable = detail::is_output_iterator<OutputIt, Char>::value&& detail::is_locale<Locale>::value&& detail::is_exotic_char<Char>::value>
auto	format_to (OutputIt out, const Locale &loc, const S &format_str, Args &&... args) -> typename std::enable_if< enable, OutputIt >::type
template<typename OutputIt , typename Char , typename... Args, enable_if_t<(detail::is_output_iterator< OutputIt, Char >::value &&detail::is_exotic_char< Char >::value), int > = 0>
auto	vformat_to_n (OutputIt out, size_t n, basic_string_view< Char > format_str, basic_format_args< buffer_context< type_identity_t< Char >>> args) -> format_to_n_result< OutputIt >
template<typename OutputIt , typename S , typename... Args, typename Char = char_t<S>, enable_if_t<(detail::is_output_iterator< OutputIt, Char >::value &&detail::is_exotic_char< Char >::value), int > = 0>
auto	format_to_n (OutputIt out, size_t n, const S &fmt, const Args &... args) -> format_to_n_result< OutputIt >
template<typename S , typename... Args, typename Char = char_t<S>, enable_if_t<(detail::is_exotic_char< Char >::value), int > = 0>
auto	formatted_size (const S &fmt, Args &&... args) -> size_t
void	vprint (std::FILE *f, wstring_view fmt, wformat_args args)
void	vprint (wstring_view fmt, wformat_args args)
template<typename... T>
void	print (std::FILE *f, wformat_string< T... > fmt, T &&... args)
template<typename... T>
void	print (wformat_string< T... > fmt, T &&... args)
template<typename T >
auto	to_wstring (const T &value) -> std::wstring

Typedef Documentation

align_t

using fmt::v8::align_t = typedef align::type

arg_join

template<typename It , typename Sentinel , typename Char >

using fmt::v8::arg_join = typedef join_view<It, Sentinel, Char>

basic_printf_context_t

template<typename Char >

using fmt::v8::basic_printf_context_t = typedef basic_printf_context<detail::buffer_appender<Char>, Char>

bool_constant

template<bool B>

using fmt::v8::bool_constant = typedef std::integral_constant<bool, B>

buffer_context

template<typename Char >

using fmt::v8::buffer_context = typedef basic_format_context<detail::buffer_appender<Char>, Char>

char_t

template<typename S >

using fmt::v8::char_t = typedef typename detail::char_t_impl<S>::type

String's character type.

conditional_t

template<bool B, typename T , typename F >

using fmt::v8::conditional_t = typedef typename std::conditional<B, T, F>::type

cstring_view

using fmt::v8::cstring_view = typedef basic_cstring_view<char>

enable_if_t

template<bool B, typename T = void>

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

format_args

using fmt::v8::format_args = typedef basic_format_args<format_context>

An alias to basic_format_args<format_context>.

format_context

using fmt::v8::format_context = typedef buffer_context<char>

format_parse_context

using fmt::v8::format_parse_context = typedef basic_format_parse_context<char>

format_specs

using fmt::v8::format_specs = typedef basic_format_specs<char>

format_string

template<typename... Args>

using fmt::v8::format_string = typedef basic_format_string<char, type_identity_t<Args>...>

has_formatter

template<typename T , typename Context >

using fmt::v8::has_formatter = typedef std::is_constructible<typename Context::template formatter_type<T> >

is_formattable

template<typename T , typename Char = char>

using fmt::v8::is_formattable = typedef bool_constant< !std::is_base_of<detail::unformattable, decltype(detail::arg_mapper<buffer_context<Char> >().map( std::declval<T>()))>::value && !detail::has_fallback_formatter<T, Char>::value>

memory_buffer

using fmt::v8::memory_buffer = typedef basic_memory_buffer<char>

printf_args

using fmt::v8::printf_args = typedef basic_format_args<printf_context>

printf_context

using fmt::v8::printf_context = typedef basic_printf_context_t<char>

remove_const_t

template<typename T >

using fmt::v8::remove_const_t = typedef typename std::remove_const<T>::type

remove_cvref_t

template<typename T >

using fmt::v8::remove_cvref_t = typedef typename std::remove_cv<remove_reference_t<T> >::type

remove_reference_t

template<typename T >

using fmt::v8::remove_reference_t = typedef typename std::remove_reference<T>::type

sign_t

using fmt::v8::sign_t = typedef sign::type

string_view

using fmt::v8::string_view = typedef basic_string_view<char>

tuple_arg_join

template<typename Char , typename... T>

using fmt::v8::tuple_arg_join = typedef tuple_join_view<Char, T...>

type_identity_t

template<typename T >

using fmt::v8::type_identity_t = typedef typename type_identity<T>::type

wcstring_view

using fmt::v8::wcstring_view = typedef basic_cstring_view<wchar_t>

wformat_args

using fmt::v8::wformat_args = typedef basic_format_args<wformat_context>

wformat_context

using fmt::v8::wformat_context = typedef buffer_context<wchar_t>

wformat_parse_context

using fmt::v8::wformat_parse_context = typedef basic_format_parse_context<wchar_t>

wformat_string

template<typename... Args>

using fmt::v8::wformat_string = typedef basic_format_string<wchar_t, type_identity_t<Args>...>

wmemory_buffer

using fmt::v8::wmemory_buffer = typedef basic_memory_buffer<wchar_t>

wprintf_args

using fmt::v8::wprintf_args = typedef basic_format_args<wprintf_context>

wprintf_context

using fmt::v8::wprintf_context = typedef basic_printf_context_t<wchar_t>

wstring_view

using fmt::v8::wstring_view = typedef basic_string_view<wchar_t>

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
inline_buffer_size

color

enum fmt::v8::color : uint32_t

strong

Enumerator
alice_blue
antique_white
aqua
aquamarine
azure
beige
bisque
black
blanched_almond
blue
blue_violet
brown
burly_wood
cadet_blue
chartreuse
chocolate
coral
cornflower_blue
cornsilk
crimson
cyan
dark_blue
dark_cyan
dark_golden_rod
dark_gray
dark_green
dark_khaki
dark_magenta
dark_olive_green
dark_orange
dark_orchid
dark_red
dark_salmon
dark_sea_green
dark_slate_blue
dark_slate_gray
dark_turquoise
dark_violet
deep_pink
deep_sky_blue
dim_gray
dodger_blue
fire_brick
floral_white
forest_green
fuchsia
gainsboro
ghost_white
gold
golden_rod
gray
green
green_yellow
honey_dew
hot_pink
indian_red
indigo
ivory
khaki
lavender
lavender_blush
lawn_green
lemon_chiffon
light_blue
light_coral
light_cyan
light_golden_rod_yellow
light_gray
light_green
light_pink
light_salmon
light_sea_green
light_sky_blue
light_slate_gray
light_steel_blue
light_yellow
lime
lime_green
linen
magenta
maroon
medium_aquamarine
medium_blue
medium_orchid
medium_purple
medium_sea_green
medium_slate_blue
medium_spring_green
medium_turquoise
medium_violet_red
midnight_blue
mint_cream
misty_rose
moccasin
navajo_white
navy
old_lace
olive
olive_drab
orange
orange_red
orchid
pale_golden_rod
pale_green
pale_turquoise
pale_violet_red
papaya_whip
peach_puff
peru
pink
plum
powder_blue
purple
rebecca_purple
red
rosy_brown
royal_blue
saddle_brown
salmon
sandy_brown
sea_green
sea_shell
sienna
silver
sky_blue
slate_blue
slate_gray
snow
spring_green
steel_blue
tan
teal
thistle
tomato
turquoise
violet
wheat
white
white_smoke
yellow
yellow_green

emphasis

enum fmt::v8::emphasis : uint8_t

strong

Enumerator
bold
faint
italic
underline
blink
reverse
conceal
strikethrough

presentation_type

enum fmt::v8::presentation_type : unsigned char

strong

Enumerator
none
dec
oct
hex_lower
hex_upper
bin_lower
bin_upper
hexfloat_lower
hexfloat_upper
exp_lower
exp_upper
fixed_lower
fixed_upper
general_lower
general_upper
chr
string
pointer

terminal_color

enum fmt::v8::terminal_color : uint8_t

strong

Enumerator
black
red
green
yellow
blue
magenta
cyan
white
bright_black
bright_red
bright_green
bright_yellow
bright_blue
bright_magenta
bright_cyan
bright_white

Function Documentation

arg()

template<typename Char , typename T >

auto fmt::v8::arg ( const Char *  name, const T &  arg  ) -> detail::named_arg<Char, T>

inline

\rst Returns a named argument to be used in a formatting function. It should only be used in a call to a formatting function or dynamic_format_arg_store::push_back.

Example**::

fmt::print("Elapsed time: {s:.2f} seconds", fmt::arg("s", 1.23)); \endrst

Here is the caller graph for this function:

bg()

text_style fmt::v8::bg ( detail::color_type  background ) throw ( )

inline

Creates a text style from the background color.

fg()

text_style fmt::v8::fg ( detail::color_type  foreground ) throw ( )

inline

Creates a text style from the foreground (text) color.

format() [1/5]

template<typename Locale , typename S , typename... Args, typename Char = char_t<S>, enable_if_t<(detail::is_locale< Locale >::value &&detail::is_exotic_char< Char >::value), int > = 0>

auto fmt::v8::format ( const Locale &  loc, const S &  format_str, Args &&...  args  ) -> std::basic_string<Char>

inline

Here is the call graph for this function:

Here is the caller graph for this function:

format() [2/5]

template<typename Locale , typename... T, enable_if_t<(detail::is_locale< Locale >::value), int > = 0>

auto fmt::v8::format ( const Locale &  loc, format_string< T... >  fmt, T &&...  args  ) -> std::string

inline

Here is the call graph for this function:

Here is the caller graph for this function:

format() [3/5]

template<typename S , typename... Args, typename Char = char_t<S>, enable_if_t<(!std::is_same< Char, char >::value), int > = 0>

auto fmt::v8::format	(	const S &	format_str,
		Args &&...	args
	)		-> std::basic_string<Char>

Here is the call graph for this function:

format() [4/5]

template<typename S , typename... Args, typename Char = char_t<S>>

std::basic_string<Char> fmt::v8::format ( const text_style &  ts, const S &  format_str, const Args &...  args  )

inline

\rst Formats arguments and returns the result as a string using ANSI escape sequences to specify text formatting.

Example**::

#include <fmt/color.h> std::string message = fmt::format(fmt::emphasis::bold | fg(fmt::color::red), "The answer is {}", 42); \endrst

Here is the call graph for this function:

Here is the caller graph for this function:

format() [5/5]

template<typename... T>

auto fmt::v8::format ( format_string< T... >  fmt, T &&...  args  ) -> std::string

inline

\rst Formats args according to specifications in fmt and returns the result as a string.

Example**::

#include <fmt/core.h> std::string message = fmt::format("The answer is {}.", 42); \endrst

Here is the call graph for this function:

format_system_error()

void fmt::v8::format_system_error	(	detail::buffer< char > &	out,
		int	error_code,
		const char *	message
	)
throw	(
	)

\rst Formats an error message for an error returned by an operating system or a language runtime, for example a file opening error, and writes it to out. The format is the same as the one used by std::system_error(ec, message) where ec is std::error_code(error_code, std::generic_category()}). It is implementation-defined but normally looks like:

.. parsed-literal:: <message>*: *<system-message>*

where *<message>* is the passed message and *<system-message>* is the system message corresponding to the error code. error_code* is a system error code as given by errno. \endrst

Here is the call graph for this function:

Here is the caller graph for this function:

format_to() [1/7]

template<typename S , typename... Args, typename Char , size_t SIZE, typename Allocator , enable_if_t<(detail::is_string< S >::value), int > = 0>

auto fmt::v8::format_to	(	basic_memory_buffer< Char, SIZE, Allocator > &	buf,
		const S &	format_str,
		Args &&...	args
	)		-> typename buffer_context<Char>::iterator

Here is the call graph for this function:

format_to() [2/7]

template<typename... T, size_t SIZE, typename Allocator >

auto fmt::v8::format_to	(	basic_memory_buffer< char, SIZE, Allocator > &	buf,
		format_string< T... >	fmt,
		T &&...	args
	)		-> appender

Here is the call graph for this function:

format_to() [3/7]

template<typename OutputIt , typename Locale , typename S , typename... Args, typename Char = char_t<S>, bool enable = detail::is_output_iterator<OutputIt, Char>::value&& detail::is_locale<Locale>::value&& detail::is_exotic_char<Char>::value>

auto fmt::v8::format_to ( OutputIt  out, const Locale &  loc, const S &  format_str, Args &&...  args  ) -> typename std::enable_if<enable, OutputIt>::type

inline

Here is the call graph for this function:

format_to() [4/7]

template<typename OutputIt , typename Locale , typename... T, enable_if_t<(detail::is_output_iterator< OutputIt, char >::value &&detail::is_locale< Locale >::value), int > = 0>

auto fmt::v8::format_to ( OutputIt  out, const Locale &  loc, format_string< T... >  fmt, T &&...  args  ) -> OutputIt

inline

Here is the call graph for this function:

format_to() [5/7]

template<typename OutputIt , typename S , typename... Args, typename Char = char_t<S>, enable_if_t<(detail::is_output_iterator< OutputIt, Char >::value &&detail::is_exotic_char< Char >::value), int > = 0>

auto fmt::v8::format_to ( OutputIt  out, const S &  fmt, Args &&...  args  ) -> OutputIt

inline

Here is the call graph for this function:

format_to() [6/7]

template<typename OutputIt , typename S , typename... Args, bool enable = detail::is_output_iterator<OutputIt, char_t<S>>::value&& detail::is_string<S>::value>

auto fmt::v8::format_to ( OutputIt  out, const text_style &  ts, const S &  format_str, Args &&...  args  ) -> typename std::enable_if<enable, OutputIt>::type

inline

\rst Formats arguments with the given text_style, writes the result to the output iterator out and returns the iterator past the end of the output range.

Example**::

std::vector<char> out; fmt::format_to(std::back_inserter(out), fmt::emphasis::bold | fg(fmt::color::red), "{}", 42); \endrst

Here is the call graph for this function:

Here is the caller graph for this function:

format_to() [7/7]

template<typename OutputIt , typename... T, enable_if_t<(detail::is_output_iterator< OutputIt, char >::value), int > = 0>

auto fmt::v8::format_to ( OutputIt  out, format_string< T... >  fmt, T &&...  args  ) -> OutputIt

inline

\rst Formats args according to specifications in fmt, writes the result to the output iterator out and returns the iterator past the end of the output range. format_to does not append a terminating null character.

Example**::

auto out = std::vector<char>(); fmt::format_to(std::back_inserter(out), "{}", 42); \endrst

Here is the call graph for this function:

format_to_n() [1/3]

template<typename OutputIt , typename S , typename... Args, typename Char = char_t<S>, enable_if_t<(detail::is_output_iterator< OutputIt, Char >::value &&detail::is_exotic_char< Char >::value), int > = 0>

auto fmt::v8::format_to_n ( OutputIt  out, size_t  n, const S &  fmt, const Args &...  args  ) -> format_to_n_result<OutputIt>

inline

Here is the call graph for this function:

format_to_n() [2/3]

template<typename OutputIt , typename S , typename... Args, enable_if_t<(detail::is_compiled_string< S >::value), int > = 0>

format_to_n_result<OutputIt> fmt::v8::format_to_n	(	OutputIt	out,
		size_t	n,
		const S &	format_str,
		Args &&...	args
	)

format_to_n() [3/3]

template<typename OutputIt , typename... T, enable_if_t<(detail::is_output_iterator< OutputIt, char >::value), int > = 0>

auto fmt::v8::format_to_n ( OutputIt  out, size_t  n, format_string< T... >  fmt, T &&...  args  ) -> format_to_n_result<OutputIt>

inline

\rst Formats args according to specifications in fmt, writes up to n characters of the result to the output iterator out and returns the total (not truncated) output size and the iterator past the end of the output range. format_to_n does not append a terminating null character. \endrst

Here is the call graph for this function:

formatted_size() [1/3]

template<typename S , typename... Args, typename Char = char_t<S>, enable_if_t<(detail::is_exotic_char< Char >::value), int > = 0>

auto fmt::v8::formatted_size ( const S &  fmt, Args &&...  args  ) -> size_t

inline

Here is the call graph for this function:

formatted_size() [2/3]

template<typename S , typename... Args, enable_if_t<(detail::is_compiled_string< S >::value), int > = 0>

size_t fmt::v8::formatted_size	(	const S &	format_str,
		const Args &...	args
	)

formatted_size() [3/3]

template<typename... T>

auto fmt::v8::formatted_size ( format_string< T... >  fmt, T &&...  args  ) -> size_t

inline

Returns the number of chars in the output of format(fmt, args...).

Here is the call graph for this function:

fprintf() [1/2]

template<typename S , typename... T, typename Char = char_t<S>>

auto fmt::v8::fprintf	(	std::basic_ostream< Char > &	os,
		const S &	fmt,
		const T &...	args
	)		-> int

Here is the call graph for this function:

fprintf() [2/2]

template<typename S , typename... T, typename Char = char_t<S>>

auto fmt::v8::fprintf ( std::FILE *  f, const S &  fmt, const T &...  args  ) -> int

inline

\rst Prints formatted data to the file f.

Example**::

fmt::fprintf(stderr, "Don't %s!", "panic"); \endrst

Here is the call graph for this function:

gmtime() [1/2]

std::tm fmt::v8::gmtime ( std::chrono::time_point< std::chrono::system_clock >  time_point )

inline

Here is the caller graph for this function:

gmtime() [2/2]

std::tm fmt::v8::gmtime ( std::time_t  time )

inline

Converts given time since epoch as std::time_t value into calendar time, expressed in Coordinated Universal Time (UTC). Unlike std::gmtime, this function is thread-safe on most platforms.

Here is the call graph for this function:

group_digits()

template<typename T >

auto fmt::v8::group_digits

(

T

value

)

-> group_digits_view<T>

\rst Returns a view that formats an integer value using ',' as a locale-independent thousands separator.

Example**::

fmt::print("{}", fmt::group_digits(12345)); Output: "12,345" \endrst

Here is the call graph for this function:

join() [1/8]

template<typename... T>

auto fmt::v8::join	(	const std::tuple< T... > &	tuple,
		basic_string_view< wchar_t >	sep
	)		-> tuple_join_view<wchar_t, T...>

join() [2/8]

template<typename... T>

auto fmt::v8::join	(	const std::tuple< T... > &	tuple,
		string_view	sep
	)		-> tuple_join_view<char, T...>

\rst Returns an object that formats tuple with elements separated by sep.

Example**::

std::tuple<int, char> t = {1, 'a'}; fmt::print("{}", fmt::join(t, ", ")); Output: "1, a" \endrst

join() [3/8]

template<typename It , typename Sentinel >

auto fmt::v8::join	(	It	begin,
		Sentinel	end,
		string_view	sep
	)		-> join_view<It, Sentinel>

Returns a view that formats the iterator range [begin, end) with elements separated by sep.

Here is the call graph for this function:

join() [4/8]

template<typename It , typename Sentinel >

auto fmt::v8::join	(	It	begin,
		Sentinel	end,
		wstring_view	sep
	)		-> join_view<It, Sentinel, wchar_t>

Here is the call graph for this function:

join() [5/8]

template<typename Range >

auto fmt::v8::join	(	Range &&	range,
		string_view	sep
	)		-> join_view<detail::iterator_t<Range>, detail::sentinel_t<Range>>

\rst Returns a view that formats range with elements separated by sep.

Example**::

std::vector<int> v = {1, 2, 3}; fmt::print("{}", fmt::join(v, ", ")); Output: "1, 2, 3"

fmt::join applies passed format specifiers to the range elements::

fmt::print("{:02}", fmt::join(v, ", ")); Output: "01, 02, 03" \endrst

Here is the call graph for this function:

join() [6/8]

template<typename Range >

auto fmt::v8::join	(	Range &&	range,
		wstring_view	sep
	)		-> join_view<detail::iterator_t<Range>, detail::sentinel_t<Range>, wchar_t>

Here is the call graph for this function:

join() [7/8]

template<typename T >

auto fmt::v8::join	(	std::initializer_list< T >	list,
		string_view	sep
	)		-> join_view<const T*, const T*>

\rst Returns an object that formats initializer_list with elements separated by sep.

Example**::

fmt::print("{}", fmt::join({1, 2, 3}, ", ")); Output: "1, 2, 3" \endrst

Here is the call graph for this function:

join() [8/8]

template<typename T >

auto fmt::v8::join	(	std::initializer_list< T >	list,
		wstring_view	sep
	)		-> join_view<const T*, const T*, wchar_t>

Here is the call graph for this function:

Here is the caller graph for this function:

localtime() [1/2]

std::tm fmt::v8::localtime ( std::chrono::time_point< std::chrono::system_clock >  time_point )

inline

Here is the caller graph for this function:

localtime() [2/2]

std::tm fmt::v8::localtime ( std::time_t  time )

inline

Converts given time since epoch as std::time_t value into calendar time, expressed in local time. Unlike std::localtime, this function is thread-safe on most platforms.

Here is the call graph for this function:

make_args_checked()

template<typename... Args, typename S , typename Char = char_t<S>>

auto fmt::v8::make_args_checked ( const S &  fmt, const remove_reference_t< Args > &...  args  ) -> format_arg_store<buffer_context<Char>, remove_reference_t<Args>...>

inline

\rst Constructs a ~fmt::format_arg_store object that contains references to arguments and can be implicitly converted to ~fmtformat_args. If fmt is a compile-time string then make_args_checked checks its validity at compile time. \endrst

Here is the call graph for this function:

make_format_args()

template<typename Context = format_context, typename... Args>

constexpr auto fmt::v8::make_format_args ( Args &&...  args ) -> format_arg_store<Context, remove_cvref_t<Args>...>

constexpr

\rst Constructs a ~fmt::format_arg_store object that contains references to arguments and can be implicitly converted to ~fmtformat_args. Context can be omitted in which case it defaults to ~fmt::context. See ~fmtarg for lifetime considerations. \endrst

make_printf_args()

template<typename... T>

auto fmt::v8::make_printf_args ( const T &...  args ) -> format_arg_store<printf_context, T...>

inline

\rst Constructs an ~fmt::format_arg_store object that contains references to arguments and can be implicitly converted to ~fmtprintf_args. \endrst

make_wformat_args()

template<typename... Args>

constexpr format_arg_store<wformat_context, Args...> fmt::v8::make_wformat_args ( const Args &...  args )

constexpr

make_wprintf_args()

template<typename... T>

auto fmt::v8::make_wprintf_args ( const T &...  args ) -> format_arg_store<wprintf_context, T...>

inline

\rst Constructs an ~fmt::format_arg_store object that contains references to arguments and can be implicitly converted to ~fmtwprintf_args. \endrst

operator|()

text_style fmt::v8::operator| ( emphasis  lhs, emphasis  rhs  ) throw ( )

inline

print() [1/9]

template<typename S , typename... Args, enable_if_t<(detail::is_compiled_string< S >::value), int > = 0>

void fmt::v8::print	(	const S &	format_str,
		const Args &...	args
	)

print() [2/9]

template<typename S , typename... Args, enable_if_t<(detail::is_string< S >::value), int > = 0>

void fmt::v8::print	(	const text_style &	ts,
		const S &	format_str,
		const Args &...	args
	)

\rst Formats a string and prints it to stdout using ANSI escape sequences to specify text formatting.

Example**::

fmt::print(fmt::emphasis::bold | fg(fmt::color::red), "Elapsed time: {0:.2f} seconds", 1.23); \endrst

print() [3/9]

template<typename... T>

void fmt::v8::print ( format_string< T... >  fmt, T &&...  args  )

inline

\rst Formats args according to specifications in fmt and writes the output to stdout.

Example**::

fmt::print("Elapsed time: {0:.2f} seconds", 1.23); \endrst

Here is the call graph for this function:

print() [4/9]

template<typename S , typename... Args, typename Char = enable_if_t<detail::is_string<S>::value, char_t<S>>>

void fmt::v8::print	(	std::basic_ostream< Char > &	os,
		const S &	format_str,
		Args &&...	args
	)

\rst Prints formatted data to the stream os.

Example**::

fmt::print(cerr, "Don't {}!", "panic"); \endrst

Here is the call graph for this function:

print() [5/9]

template<typename S , typename... Args, enable_if_t<(detail::is_compiled_string< S >::value), int > = 0>

void fmt::v8::print	(	std::FILE *	f,
		const S &	format_str,
		const Args &...	args
	)

print() [6/9]

template<typename S , typename... Args, enable_if_t<(detail::is_string< S >::value), int > = 0>

void fmt::v8::print	(	std::FILE *	f,
		const text_style &	ts,
		const S &	format_str,
		const Args &...	args
	)

\rst Formats a string and prints it to the specified file stream using ANSI escape sequences to specify text formatting.

Example**::

fmt::print(fmt::emphasis::bold | fg(fmt::color::red), "Elapsed time: {0:.2f} seconds", 1.23); \endrst

Here is the call graph for this function:

print() [7/9]

template<typename... T>

void fmt::v8::print ( std::FILE *  f, format_string< T... >  fmt, T &&...  args  )

inline

\rst Formats args according to specifications in fmt and writes the output to the file f.

Example**::

fmt::print(stderr, "Don't {}!", "panic"); \endrst

Here is the call graph for this function:

print() [8/9]

template<typename... T>

void fmt::v8::print	(	std::FILE *	f,
		wformat_string< T... >	fmt,
		T &&...	args
	)

Here is the call graph for this function:

print() [9/9]

template<typename... T>

void fmt::v8::print	(	wformat_string< T... >	fmt,
		T &&...	args
	)

Here is the call graph for this function:

printf()

template<typename S , typename... T, enable_if_t<(detail::is_string< S >::value), int > = 0>

auto fmt::v8::printf ( const S &  fmt, const T &...  args  ) -> int

inline

\rst Prints formatted data to stdout.

Example**::

fmt::printf("Elapsed time: %.2f seconds", 1.23); \endrst

Here is the call graph for this function:

ptr() [1/3]

template<typename T >

auto fmt::v8::ptr

(

const std::shared_ptr< T > &

p

)

-> const void*

Here is the caller graph for this function:

ptr() [2/3]

template<typename T >

auto fmt::v8::ptr

(

const std::unique_ptr< T > &

p

)

-> const void*

ptr() [3/3]

template<typename T >

auto fmt::v8::ptr

(

T

p

)

-> const void*

\rst Converts p to const void* for pointer formatting.

Example**::

auto s = fmt::format("{}", fmt::ptr(p)); \endrst

Here is the call graph for this function:

report_system_error()

void fmt::v8::report_system_error	(	int	error_code,
		const char *	message
	)
throw	(
	)

Here is the call graph for this function:

runtime()

template<typename S >

auto fmt::v8::runtime

(

const S &

s

)

-> basic_runtime<char_t<S>>

\rst Creates a runtime format string.

Example**::

Check format string at runtime instead of compile-time. fmt::print(fmt::runtime("{:d}"), "I am not a number"); \endrst

sprintf()

template<typename S , typename... T, typename Char = enable_if_t<detail::is_string<S>::value, char_t<S>>>

auto fmt::v8::sprintf ( const S &  fmt, const T &...  args  ) -> std::basic_string<Char>

inline

\rst Formats arguments and returns the result as a string.

Example**::

std::string message = fmt::sprintf("The answer is %d", 42); \endrst

Here is the call graph for this function:

system_category()

const std::error_category& fmt::v8::system_category ( ) throw ( )

inline

system_error()

template<typename... T>

auto fmt::v8::system_error	(	int	error_code,
		format_string< T... >	fmt,
		T &&...	args
	)		-> std::system_error

\rst Constructs :class:std::system_error with a message formatted with fmt::format(fmt, args...). error_code* is a system error code as given by errno.

Example**::

This throws std::system_error with the description cannot open file 'madeup': No such file or directory or similar (system message may vary). const char* filename = "madeup"; std::FILE* file = std::fopen(filename, "r"); if (!file) throw fmt::system_error(errno, "cannot open file '{}'", filename); \endrst

Here is the call graph for this function:

to_string() [1/3]

template<typename Char , size_t SIZE>

auto fmt::v8::to_string

(

const basic_memory_buffer< Char, SIZE > &

buf

)

-> std::basic_string<Char>

Here is the call graph for this function:

to_string() [2/3]

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

auto fmt::v8::to_string ( const T &  value ) -> std::string

inline

\rst Converts value to std::string using the default format for type T.

Example**::

#include <fmt/format.h>

std::string answer = fmt::to_string(42); \endrst

Here is the call graph for this function:

Here is the caller graph for this function:

to_string() [3/3]

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

auto fmt::v8::to_string ( T  value ) -> std::string

inline

Here is the call graph for this function:

to_string_view() [1/5]

template<typename Char >

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

constexpr

to_string_view() [2/5]

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

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

inline

to_string_view() [3/5]

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

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

constexpr

to_string_view() [4/5]

template<typename Char , typename Traits , typename Alloc >

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

inline

to_string_view() [5/5]

template<typename Char , enable_if_t<(!std::is_empty< detail::std_string_view< Char >>::value), int > = 0>

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

inline

to_wstring()

template<typename T >

auto fmt::v8::to_wstring ( const T &  value ) -> std::wstring

inline

Converts value to std::wstring using the default format for type T.

Here is the call graph for this function:

vformat() [1/5]

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

auto fmt::v8::vformat	(	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() [2/5]

template<typename Locale , typename S , typename Char = char_t<S>, enable_if_t<(detail::is_locale< Locale >::value &&detail::is_exotic_char< Char >::value), int > = 0>

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

inline

Here is the call graph for this function:

Here is the caller graph for this function:

vformat() [3/5]

template<typename Locale , enable_if_t<(detail::is_locale< Locale >::value), int > = 0>

auto fmt::v8::vformat ( const Locale &  loc, string_view  fmt, format_args  args  ) -> std::string

inline

Here is the caller graph for this function:

vformat() [4/5]

template<typename S , typename Char = char_t<S>>

std::basic_string<Char> fmt::v8::vformat ( const text_style &  ts, const S &  format_str, basic_format_args< buffer_context< type_identity_t< Char >>>  args  )

inline

Here is the call graph for this function:

Here is the caller graph for this function:

vformat() [5/5]

std::string fmt::v8::vformat	(	string_view	fmt,
		format_args	args
	)		-> std::string

Here is the call graph for this function:

Here is the caller graph for this function:

vformat_to() [1/5]

template<typename Locale , typename S , typename OutputIt , typename... Args, typename Char = char_t<S>, enable_if_t<(detail::is_output_iterator< OutputIt, Char >::value &&detail::is_locale< Locale >::value &&detail::is_exotic_char< Char >::value), int > = 0>

auto fmt::v8::vformat_to ( OutputIt  out, const Locale &  loc, const S &  format_str, basic_format_args< buffer_context< type_identity_t< Char >>>  args  ) -> OutputIt

inline

Here is the call graph for this function:

Here is the caller graph for this function:

vformat_to() [2/5]

template<typename OutputIt , typename Locale , enable_if_t<(detail::is_output_iterator< OutputIt, char >::value &&detail::is_locale< Locale >::value), int > = 0>

auto fmt::v8::vformat_to	(	OutputIt	out,
		const Locale &	loc,
		string_view	fmt,
		format_args	args
	)		-> OutputIt

Here is the call graph for this function:

Here is the caller graph for this function:

vformat_to() [3/5]

template<typename OutputIt , typename S , typename Char = char_t<S>, enable_if_t<(detail::is_output_iterator< OutputIt, Char >::value &&detail::is_exotic_char< Char >::value), int > = 0>

auto fmt::v8::vformat_to	(	OutputIt	out,
		const S &	format_str,
		basic_format_args< buffer_context< type_identity_t< Char >>>	args
	)		-> OutputIt

Here is the call graph for this function:

vformat_to() [4/5]

template<typename OutputIt , typename Char , enable_if_t<(detail::is_output_iterator< OutputIt, Char >::value), int > = 0>

OutputIt fmt::v8::vformat_to	(	OutputIt	out,
		const text_style &	ts,
		basic_string_view< Char >	format_str,
		basic_format_args< buffer_context< type_identity_t< Char >>>	args
	)

Formats a string with the given text_style and writes the output to out.

Here is the call graph for this function:

Here is the caller graph for this function:

vformat_to() [5/5]

template<typename OutputIt , enable_if_t<(detail::is_output_iterator< OutputIt, char >::value), int > = 0>

auto fmt::v8::vformat_to	(	OutputIt	out,
		string_view	fmt,
		format_args	args
	)		-> OutputIt

Formats a string and writes the output to out.

Here is the call graph for this function:

Here is the caller graph for this function:

vformat_to_n() [1/2]

template<typename OutputIt , typename Char , typename... Args, enable_if_t<(detail::is_output_iterator< OutputIt, Char >::value &&detail::is_exotic_char< Char >::value), int > = 0>

auto fmt::v8::vformat_to_n ( OutputIt  out, size_t  n, basic_string_view< Char >  format_str, basic_format_args< buffer_context< type_identity_t< Char >>>  args  ) -> format_to_n_result<OutputIt>

inline

Here is the call graph for this function:

Here is the caller graph for this function:

vformat_to_n() [2/2]

template<typename OutputIt , typename... T, enable_if_t<(detail::is_output_iterator< OutputIt, char >::value), int > = 0>

auto fmt::v8::vformat_to_n	(	OutputIt	out,
		size_t	n,
		string_view	fmt,
		format_args	args
	)		-> format_to_n_result<OutputIt>

Here is the call graph for this function:

Here is the caller graph for this function:

vfprintf() [1/2]

template<typename S , typename Char = char_t<S>>

auto fmt::v8::vfprintf	(	std::basic_ostream< Char > &	os,
		const S &	fmt,
		basic_format_args< basic_printf_context_t< type_identity_t< Char >>>	args
	)		-> int

Here is the call graph for this function:

Here is the caller graph for this function:

vfprintf() [2/2]

template<typename S , typename Char = char_t<S>>

auto fmt::v8::vfprintf ( std::FILE *  f, const S &  fmt, basic_format_args< basic_printf_context_t< type_identity_t< Char >>>  args  ) -> int

inline

Here is the call graph for this function:

visit_format_arg()

template<typename Visitor , typename Context >

auto fmt::v8::visit_format_arg ( Visitor &&  vis, const basic_format_arg< Context > &  arg  ) -> decltype(vis(0))

inline

\rst Visits an argument dispatching to the appropriate visit method based on the argument type. For example, if the argument type is double then vis(value) will be called with the value of type double. \endrst

Here is the call graph for this function:

vprint() [1/6]

template<typename Char >

void fmt::v8::vprint	(	std::basic_ostream< Char > &	os,
		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() [2/6]

template<typename S , typename Char = char_t<S>>

void fmt::v8::vprint	(	std::FILE *	f,
		const text_style &	ts,
		const S &	format,
		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() [3/6]

void fmt::v8::vprint	(	std::FILE *	f,
		string_view	fmt,
		format_args	args
	)

Here is the call graph for this function:

Here is the caller graph for this function:

vprint() [4/6]

void fmt::v8::vprint ( std::FILE *  f, wstring_view  fmt, wformat_args  args  )

inline

Here is the call graph for this function:

vprint() [5/6]

void fmt::v8::vprint	(	string_view	fmt,
		format_args	args
	)

Here is the call graph for this function:

vprint() [6/6]

void fmt::v8::vprint ( wstring_view  fmt, wformat_args  args  )

inline

Here is the caller graph for this function:

vprintf()

template<typename S , typename Char = char_t<S>>

auto fmt::v8::vprintf ( const S &  fmt, basic_format_args< basic_printf_context_t< type_identity_t< Char >>>  args  ) -> int

inline

Here is the call graph for this function:

Here is the caller graph for this function:

vsprintf()

template<typename S , typename Char = char_t<S>>

auto fmt::v8::vsprintf ( const S &  fmt, basic_format_args< basic_printf_context_t< type_identity_t< Char >>>  args  ) -> std::basic_string<Char>

inline

Here is the call graph for this function:

Here is the caller graph for this function:

vsystem_error()

auto fmt::v8::vsystem_error	(	int	error_code,
		string_view	format_str,
		format_args	args
	)

Here is the call graph for this function: