format.h File Reference

#include <cmath>
#include <cstdint>
#include <limits>
#include <memory>
#include <stdexcept>
#include <system_error>
#include <utility>
#include "core.h"

Include dependency graph for format.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	fmt::v8::detail::formatbuf< Streambuf >
struct	fmt::v8::detail::fallback_uintptr
class	fmt::v8::basic_memory_buffer< T, SIZE, Allocator >
struct	fmt::v8::is_contiguous< basic_memory_buffer< T, SIZE, Allocator > >
class	fmt::v8::format_error
struct	fmt::v8::detail::is_integral< T >
struct	fmt::v8::detail::is_integral< int128_t >
struct	fmt::v8::detail::is_integral< uint128_t >
struct	fmt::v8::detail::thousands_sep_result< Char >
struct	fmt::v8::detail::format_decimal_result< Iterator >
class	fmt::v8::detail::utf8_to_utf16
struct	fmt::v8::detail::dragonbox::float_info< T >
struct	fmt::v8::detail::dragonbox::float_info< float >
struct	fmt::v8::detail::dragonbox::float_info< double >
struct	fmt::v8::detail::dragonbox::decimal_fp< T >
struct	fmt::v8::detail::write_int_data< Char >
class	fmt::v8::detail::digit_grouping< Char >
struct	fmt::v8::detail::digit_grouping< Char >::next_state
struct	fmt::v8::detail::write_int_arg< UInt >
struct	fmt::v8::detail::big_decimal_fp
class	fmt::v8::detail::fallback_digit_grouping< Char >
struct	fmt::v8::detail::default_arg_formatter< Char >
struct	fmt::v8::detail::arg_formatter< Char >
struct	fmt::v8::detail::custom_formatter< Char >
class	fmt::v8::detail::width_checker< ErrorHandler >
class	fmt::v8::detail::precision_checker< ErrorHandler >
class	fmt::v8::detail::specs_handler< Char >
class	fmt::v8::format_int
struct	fmt::v8::formatter< signed char, Char >
struct	fmt::v8::formatter< unsigned char, Char >
struct	fmt::v8::formatter< short, Char >
struct	fmt::v8::formatter< unsigned short, Char >
struct	fmt::v8::formatter< long, Char >
struct	fmt::v8::formatter< unsigned long, Char >
struct	fmt::v8::formatter< Char *, Char >
struct	fmt::v8::formatter< std::basic_string< Char >, Char >
struct	fmt::v8::formatter< std::nullptr_t, Char >
struct	fmt::v8::formatter< detail::byte, Char >
struct	fmt::v8::formatter< detail::std_string_view< Char >, Char >
struct	fmt::v8::formatter< void *, Char >
struct	fmt::v8::formatter< Char[N], Char >
class	fmt::v8::dynamic_formatter< Char >
struct	fmt::v8::dynamic_formatter< Char >::null_handler
class	fmt::v8::bytes
struct	fmt::v8::formatter< bytes >
struct	fmt::v8::group_digits_view< T >
struct	fmt::v8::formatter< group_digits_view< T > >
struct	fmt::v8::join_view< It, Sentinel, Char >
struct	fmt::v8::formatter< join_view< It, Sentinel, Char >, Char >

Namespaces
	fmt
	fmt::v8
	fmt::v8::detail
	fmt::v8::detail_exported
	fmt::v8::detail::dragonbox

Macros
#define	FMT_GCC_VISIBILITY_HIDDEN
#define	FMT_CUDA_VERSION   0
#define	FMT_HAS_BUILTIN(x)   0
#define	FMT_NOINLINE
#define	FMT_MSC_DEFAULT
#define	FMT_THROW(x)   throw x
#define	FMT_TRY   try
#define	FMT_CATCH(x)   catch (x)
#define	FMT_MAYBE_UNUSED
#define	FMT_DEPRECATED_ALIAS   FMT_DEPRECATED
#define	FMT_USE_USER_DEFINED_LITERALS   0
#define	FMT_REDUCE_INT_INSTANTIATIONS   0
#define	FMT_HEADER_ONLY_CONSTEXPR20
#define	FMT_USE_FULL_CACHE_DRAGONBOX   0
#define	FMT_POWERS_OF_10(factor)
#define	FMT_STRING_IMPL(s, base, explicit)
#define	FMT_STRING(s)   FMT_STRING_IMPL(s, fmt::compile_string, )
#define	FMT_FORMAT_AS(Type, Base)
#define	FMT_FUNC

Typedefs
using	fmt::v8::detail::uintptr_t = fallback_uintptr
template<typename T >
using	fmt::v8::detail::iterator_t = decltype(std::begin(std::declval< T & >()))
template<typename T >
using	fmt::v8::detail::sentinel_t = decltype(std::end(std::declval< T & >()))
template<typename T >
using	fmt::v8::detail::checked_ptr = T *
template<typename OutputIt >
using	fmt::v8::detail::reserve_iterator = remove_reference_t< decltype(reserve(std::declval< OutputIt & >(), 0))>
using	fmt::v8::memory_buffer = basic_memory_buffer< char >
template<typename T >
using	fmt::v8::detail::is_signed = std::integral_constant< bool, std::numeric_limits< T >::is_signed||std::is_same< T, int128_t >::value >
template<typename T >
using	fmt::v8::detail::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	fmt::v8::detail::uint64_or_128_t = conditional_t< num_bits< T >()<=64, uint64_t, uint128_t >
template<typename T >
using	fmt::v8::detail::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	fmt::v8::detail::format_func = void(*)(detail::buffer< char > &, int, const char *)
template<typename It , typename Sentinel , typename Char >
using	fmt::v8::arg_join = join_view< It, Sentinel, Char >

Enumerations
enum	fmt::v8::detail::char8_type : unsigned char
enum	{ fmt::v8::inline_buffer_size = 500 }

Functions
template<typename To , typename From >
auto	fmt::v8::detail::bit_cast (const From &from) -> To
auto	fmt::v8::detail::is_big_endian () -> bool
auto	fmt::v8::detail::to_uintptr (const void *p) -> fallback_uintptr
template<typename T >
constexpr auto	fmt::v8::detail::max_value () -> T
template<typename T >
constexpr auto	fmt::v8::detail::num_bits () -> int
template<>
constexpr auto	fmt::v8::detail::num_bits< int128_t > () -> int
template<>
constexpr auto	fmt::v8::detail::num_bits< uint128_t > () -> int
template<>
constexpr auto	fmt::v8::detail::num_bits< fallback_uintptr > () -> int
void	fmt::v8::detail::assume (bool condition)
template<typename Char >
auto	fmt::v8::detail::get_data (std::basic_string< Char > &s) -> Char *
template<typename Container >
auto	fmt::v8::detail::get_data (Container &c) -> typename Container::value_type *
template<typename T >
constexpr auto	fmt::v8::detail::make_checked (T *p, size_t) -> T *
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 >
template<typename T >
auto	fmt::v8::detail::reserve (buffer_appender< T > it, size_t n) -> buffer_appender< T >
template<typename Iterator >
constexpr auto	fmt::v8::detail::reserve (Iterator &it, size_t) -> Iterator &
template<typename T , typename OutputIt >
constexpr auto	fmt::v8::detail::to_pointer (OutputIt, size_t) -> T *
template<typename T >
auto	fmt::v8::detail::to_pointer (buffer_appender< T > it, size_t n) -> T *
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 >
template<typename Iterator >
constexpr auto	fmt::v8::detail::base_iterator (Iterator, Iterator it) -> Iterator
template<typename OutputIt , typename Size , typename T >
auto	fmt::v8::detail::fill_n (OutputIt out, Size count, const T &value) -> OutputIt
template<typename T , typename Size >
auto	fmt::v8::detail::fill_n (T *out, Size count, char value) -> T *
template<typename OutChar , typename InputIt , typename OutputIt >
auto	fmt::v8::detail::copy_str_noinline (InputIt begin, InputIt end, OutputIt out) -> OutputIt
auto	fmt::v8::detail::utf8_decode (const char *s, uint32_t *c, int *e) -> const char *
template<typename F >
void	fmt::v8::detail::for_each_codepoint (string_view s, F f)
template<typename Char >
auto	fmt::v8::detail::compute_width (basic_string_view< Char > s) -> size_t
size_t	fmt::v8::detail::compute_width (string_view s)
auto	fmt::v8::detail::compute_width (basic_string_view< char8_type > s) -> size_t
template<typename Char >
auto	fmt::v8::detail::code_point_index (basic_string_view< Char > s, size_t n) -> size_t
auto	fmt::v8::detail::code_point_index (basic_string_view< char8_type > s, size_t n) -> size_t
void	fmt::v8::detail::print (std::FILE *f, string_view text)
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 >... >
template<typename Char , size_t N>
constexpr auto	fmt::v8::detail_exported::compile_string_to_view (const Char(&s)[N]) -> basic_string_view< Char >
template<typename Char >
constexpr auto	fmt::v8::detail_exported::compile_string_to_view (detail::std_string_view< Char > s) -> basic_string_view< Char >
template<typename T , enable_if_t<(is_signed< T >::value), int > = 0>
auto	fmt::v8::detail::is_negative (T value) -> bool
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
constexpr const char *	fmt::v8::detail::digits2 (size_t value)
template<typename Char , typename Sign >
constexpr Char	fmt::v8::detail::sign (Sign s)
template<typename T >
auto	fmt::v8::detail::count_digits_fallback (T n) -> int
auto	fmt::v8::detail::count_digits (uint64_t n) -> int
template<int BITS, typename UInt >
auto	fmt::v8::detail::count_digits (UInt n) -> int
template<>
int	fmt::v8::detail::count_digits< 4 > (detail::fallback_uintptr n)
auto	fmt::v8::detail::count_digits (uint32_t n) -> int
template<typename Int >
constexpr auto	fmt::v8::detail::digits10 () -> int throw ()
template<>
constexpr auto	fmt::v8::detail::digits10< int128_t > () -> int throw ()
template<>
constexpr auto	fmt::v8::detail::digits10< uint128_t > () -> int throw ()
template<typename Char >
auto	fmt::v8::detail::thousands_sep_impl (locale_ref loc) -> thousands_sep_result< Char >
template<typename Char >
auto	fmt::v8::detail::thousands_sep (locale_ref loc) -> thousands_sep_result< Char >
template<>
auto	fmt::v8::detail::thousands_sep (locale_ref loc) -> thousands_sep_result< wchar_t >
template<typename Char >
auto	fmt::v8::detail::decimal_point_impl (locale_ref loc) -> Char
template<typename Char >
auto	fmt::v8::detail::decimal_point (locale_ref loc) -> Char
template<>
auto	fmt::v8::detail::decimal_point (locale_ref loc) -> wchar_t
template<typename Char >
auto	fmt::v8::detail::equal2 (const Char *lhs, const char *rhs) -> bool
auto	fmt::v8::detail::equal2 (const char *lhs, const char *rhs) -> bool
template<typename Char >
void	fmt::v8::detail::copy2 (Char *dst, const char *src)
template<typename Char , typename UInt >
auto	fmt::v8::detail::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	fmt::v8::detail::format_decimal (Iterator out, UInt value, int size) -> format_decimal_result< Iterator >
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 *
template<unsigned BASE_BITS, typename Char >
auto	fmt::v8::detail::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	fmt::v8::detail::format_uint (It out, UInt value, int num_digits, bool upper=false) -> It
template<typename T >
auto	fmt::v8::detail::dragonbox::to_decimal (T x) -> decimal_fp< T > throw ()
template<typename T >
constexpr auto	fmt::v8::detail::exponent_mask () -> typename dragonbox::float_info< T >::carrier_uint
template<typename Char , typename It >
auto	fmt::v8::detail::write_exponent (int exp, It it) -> It
template<typename T >
auto	fmt::v8::detail::format_float (T value, int precision, float_specs specs, buffer< char > &buf) -> int
template<typename T >
auto	fmt::v8::detail::snprintf_float (T value, int precision, float_specs specs, buffer< char > &buf) -> int
template<typename T >
constexpr auto	fmt::v8::detail::promote_float (T value) -> T
constexpr auto	fmt::v8::detail::promote_float (float value) -> double
template<typename OutputIt , typename Char >
auto	fmt::v8::detail::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	fmt::v8::detail::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	fmt::v8::detail::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	fmt::v8::detail::write_bytes (OutputIt out, string_view bytes, const basic_format_specs< Char > &specs) -> OutputIt
template<typename Char , typename OutputIt , typename UIntPtr >
auto	fmt::v8::detail::write_ptr (OutputIt out, UIntPtr value, const basic_format_specs< Char > *specs) -> OutputIt
template<typename Char , typename OutputIt >
auto	fmt::v8::detail::write_char (OutputIt out, Char value, const basic_format_specs< Char > &specs) -> OutputIt
template<typename Char , typename OutputIt >
auto	fmt::v8::detail::write (OutputIt out, Char value, const basic_format_specs< Char > &specs, locale_ref loc={}) -> OutputIt
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
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
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
void	fmt::v8::detail::prefix_append (unsigned &prefix, unsigned value)
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 >>
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
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
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
template<typename Char , typename OutputIt >
auto	fmt::v8::detail::write (OutputIt out, basic_string_view< Char > s, const basic_format_specs< Char > &specs) -> OutputIt
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
template<typename Char , typename OutputIt >
auto	fmt::v8::detail::write (OutputIt out, const Char *s, const basic_format_specs< Char > &specs, locale_ref) -> OutputIt
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
constexpr auto	fmt::v8::detail::get_significand_size (const big_decimal_fp &fp) -> int
template<typename T >
auto	fmt::v8::detail::get_significand_size (const dragonbox::decimal_fp< T > &fp) -> int
template<typename Char , typename OutputIt >
constexpr auto	fmt::v8::detail::write_significand (OutputIt out, const char *significand, int significand_size) -> OutputIt
template<typename Char , typename OutputIt , typename UInt >
auto	fmt::v8::detail::write_significand (OutputIt out, UInt significand, int significand_size) -> OutputIt
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
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 *
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
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
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
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
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
template<typename T , enable_if_t<(std::is_floating_point< T >::value), int > = 0>
bool	fmt::v8::detail::isinf (T value)
template<typename T , enable_if_t<(std::is_integral< T >::value), int > = 0>
bool	fmt::v8::detail::isfinite (T)
template<typename T , enable_if_t<(std::is_floating_point< T >::value), int > = 0>
bool	fmt::v8::detail::signbit (T value)
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
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
template<typename Char , typename OutputIt >
auto	fmt::v8::detail::write (OutputIt out, monostate, basic_format_specs< Char >={}, locale_ref={}) -> OutputIt
template<typename Char , typename OutputIt >
auto	fmt::v8::detail::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	fmt::v8::detail::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	fmt::v8::detail::write (OutputIt out, T value) -> OutputIt
template<typename Char , typename OutputIt >
auto	fmt::v8::detail::write (OutputIt out, Char value) -> OutputIt
template<typename Char , typename OutputIt >
auto	fmt::v8::detail::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	fmt::v8::detail::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	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 >
template<template< typename > class Handler, typename FormatArg , typename ErrorHandler >
auto	fmt::v8::detail::get_dynamic_spec (FormatArg arg, ErrorHandler eh) -> int
template<typename Context , typename ID >
auto	fmt::v8::detail::get_arg (Context &ctx, ID id) -> typename Context::format_arg
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)
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 >
void	fmt::v8::detail::format_error_code (detail::buffer< char > &out, int error_code, string_view message) throw ()
void	fmt::v8::detail::report_error (format_func func, int error_code, const char *message) throw ()
std::system_error	fmt::v8::vsystem_error (int error_code, string_view format_str, format_args args)
template<typename... T>
auto	fmt::v8::system_error (int error_code, format_string< T... > fmt, T &&... args) -> std::system_error
void	fmt::v8::format_system_error (detail::buffer< char > &out, int error_code, const char *message) throw ()
void	fmt::v8::report_system_error (int error_code, const char *message) throw ()
template<typename T >
auto	fmt::v8::ptr (T p) -> const void *
template<typename T >
auto	fmt::v8::ptr (const std::unique_ptr< T > &p) -> const void *
template<typename T >
auto	fmt::v8::ptr (const std::shared_ptr< T > &p) -> const void *
template<typename T >
auto	fmt::v8::group_digits (T value) -> group_digits_view< T >
template<typename It , typename Sentinel >
auto	fmt::v8::join (It begin, Sentinel end, string_view sep) -> join_view< It, Sentinel >
template<typename Range >
auto	fmt::v8::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	fmt::v8::to_string (const T &value) -> std::string
template<typename T , enable_if_t<(std::is_integral< T >::value), int > = 0>
auto	fmt::v8::to_string (T value) -> std::string
template<typename Char , size_t SIZE>
auto	fmt::v8::to_string (const basic_memory_buffer< Char, SIZE > &buf) -> std::basic_string< Char >
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={})
template auto	fmt::v8::detail::thousands_sep_impl< char > (locale_ref) -> thousands_sep_result< char >
template auto	fmt::v8::detail::thousands_sep_impl< wchar_t > (locale_ref) -> thousands_sep_result< wchar_t >
template<typename Char >
Char	fmt::v8::detail::decimal_point_impl (locale_ref loc)
template auto	fmt::v8::detail::format_float< double > (double value, int precision, float_specs specs, buffer< char > &buf) -> int
template auto	fmt::v8::detail::format_float< long double > (long double value, int precision, float_specs specs, buffer< char > &buf) -> int
void	fmt::v8::detail::snprintf_float (float, int, float_specs, buffer< char > &)=delete
template auto	fmt::v8::detail::snprintf_float< double > (double value, int precision, float_specs specs, buffer< char > &buf) -> int
template auto	fmt::v8::detail::snprintf_float< long double > (long double value, int precision, float_specs specs, buffer< char > &buf) -> int
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
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
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
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
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

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

Macro Definition Documentation

FMT_CATCH

#define FMT_CATCH

(

x

)

catch (x)

FMT_CUDA_VERSION

#define FMT_CUDA_VERSION   0

FMT_DEPRECATED_ALIAS

#define FMT_DEPRECATED_ALIAS   FMT_DEPRECATED

FMT_FORMAT_AS

#define FMT_FORMAT_AS	(		Type,
			Base
	)

Value:

  template <typename Char>                                               \
  struct formatter<Type, Char> : formatter<Base, Char> {                 \
    template <typename FormatContext>                                    \
    auto format(Type const& val, FormatContext& ctx) const               \
        -> decltype(ctx.out()) {                                         \
      return formatter<Base, Char>::format(static_cast<Base>(val), ctx); \
    }                                                                    \
  }

FMT_FUNC

#define FMT_FUNC

FMT_GCC_VISIBILITY_HIDDEN

#define FMT_GCC_VISIBILITY_HIDDEN

FMT_HAS_BUILTIN

#define FMT_HAS_BUILTIN

(

x

)

0

FMT_HEADER_ONLY_CONSTEXPR20

#define FMT_HEADER_ONLY_CONSTEXPR20

FMT_MAYBE_UNUSED

#define FMT_MAYBE_UNUSED

FMT_MSC_DEFAULT

#define FMT_MSC_DEFAULT

FMT_NOINLINE

#define FMT_NOINLINE

FMT_POWERS_OF_10

#define FMT_POWERS_OF_10

(

factor

)

Value:

  factor * 10, (factor)*100, (factor)*1000, (factor)*10000, (factor)*100000, \
      (factor)*1000000, (factor)*10000000, (factor)*100000000,               \
      (factor)*1000000000

FMT_REDUCE_INT_INSTANTIATIONS

#define FMT_REDUCE_INT_INSTANTIATIONS   0

FMT_STRING

#define FMT_STRING

(

s

)

FMT_STRING_IMPL(s, fmt::compile_string, )

\rst Constructs a compile-time format string from a string literal s.

Example**::

A compile-time error because 'd' is an invalid specifier for strings. std::string s = fmt::format(FMT_STRING("{:d}"), "foo"); \endrst

FMT_STRING_IMPL

#define FMT_STRING_IMPL	(		s,
			base,
			explicit
	)

Value:

  [] {                                                                     \
    /* Use the hidden visibility as a workaround for a GCC bug (#1973). */ \
    /* Use a macro-like name to avoid shadowing warnings. */               \
    struct FMT_GCC_VISIBILITY_HIDDEN FMT_COMPILE_STRING : base {           \
      using char_type = fmt::remove_cvref_t<decltype(s[0])>;               \
      FMT_MAYBE_UNUSED FMT_CONSTEXPR explicit                              \
      operator fmt::basic_string_view<char_type>() const {                 \
        return fmt::detail_exported::compile_string_to_view<char_type>(s); \
      }                                                                    \
    };                                                                     \
    return FMT_COMPILE_STRING();                                           \
  }()

FMT_THROW

#define FMT_THROW

(

x

)

throw x

FMT_TRY

#define FMT_TRY   try

FMT_USE_FULL_CACHE_DRAGONBOX

#define FMT_USE_FULL_CACHE_DRAGONBOX   0

FMT_USE_USER_DEFINED_LITERALS

#define FMT_USE_USER_DEFINED_LITERALS   0