#include <algorithm>
#include <cerrno>
#include <cmath>
#include <cstdint>
#include <limits>
#include <memory>
#include <stdexcept>
#include "core.h"
#include "format-inl.h"

Classes
struct	fallback_uintptr

class	counting_iterator

struct	counting_iterator::value_type

class	truncating_iterator_base< OutputIt >

class	truncating_iterator< OutputIt, Enable >

class	truncating_iterator< OutputIt, std::false_type >

class	truncating_iterator< OutputIt, std::true_type >

class	basic_memory_buffer< T, SIZE, Allocator >

struct	is_contiguous< basic_memory_buffer< T, SIZE, Allocator > >

class	format_error

struct	uint128_wrapper

struct	divtest_table_entry< T >

struct	basic_data< T >

struct	data

struct	format_decimal_result< Iterator >

class	utf8_to_utf16

struct	null< T >

struct	fill_t< Char >

struct	basic_format_specs< Char >

struct	float_info< T >

struct	float_info< float >

struct	float_info< double >

struct	decimal_fp< T >

struct	float_specs

class	int_type_checker< ErrorHandler >

class	char_specs_checker< ErrorHandler >

class	cstring_type_checker< ErrorHandler >

struct	write_int_data< Char >

struct	int_writer< OutputIt, Char, UInt >

struct	big_decimal_fp

struct	is_integral< T >

struct	is_integral< int128_t >

struct	is_integral< uint128_t >

struct	default_arg_formatter< OutputIt, Char >

class	arg_formatter_base< OutputIt, Char, ErrorHandler >

struct	arg_formatter_base< OutputIt, Char, ErrorHandler >::char_spec_handler

struct	arg_formatter_base< OutputIt, Char, ErrorHandler >::cstring_spec_handler

class	arg_formatter< OutputIt, Char >

class	custom_formatter< Context >

class	width_checker< ErrorHandler >

class	precision_checker< ErrorHandler >

class	specs_setter< Char >

class	numeric_specs_checker< ErrorHandler >

class	specs_checker< Handler >

struct	auto_id

class	specs_handler< ParseContext, Context >

struct	arg_ref< Char >

union	arg_ref< Char >::value

struct	dynamic_format_specs< Char >

class	dynamic_specs_handler< ParseContext >

struct	width_adapter< SpecHandler, Char >

struct	precision_adapter< SpecHandler, Char >

struct	id_adapter< Handler, Char >

struct	format_handler< OutputIt, Char, Context >

class	compile_parse_context< Char, ErrorHandler >

class	format_string_checker< Char, ErrorHandler, Args >

class	system_error

class	format_int

struct	formatter< T, Char, enable_if_t< detail::type_constant< T, Char >::value !=detail::type::custom_type > >

struct	formatter< void *, Char >

struct	formatter< Char[N], Char >

class	dynamic_formatter< Char >

struct	dynamic_formatter< Char >::null_handler

class	bytes

struct	formatter< bytes >

struct	arg_join< It, Sentinel, Char >

struct	formatter< arg_join< It, Sentinel, Char >, Char >

Namespaces
	detail

	align

	sign

	detail::dragonbox

Macros
#define	FMT_ICC_VERSION 0

#define	FMT_CUDA_VERSION 0

#define	FMT_HAS_BUILTIN(x) 0

#define	FMT_NOINLINE

#define	FMT_FALLTHROUGH

#define	FMT_MAYBE_UNUSED

#define	FMT_THROW(x) throw x

#define	FMT_TRY try

#define	FMT_CATCH(x) catch (x)

#define	FMT_USE_USER_DEFINED_LITERALS 0

#define	FMT_USE_UDL_TEMPLATE 0

#define	FMT_USE_FLOAT 1

#define	FMT_USE_DOUBLE 1

#define	FMT_USE_LONG_DOUBLE 1

#define	FMT_REDUCE_INT_INSTANTIATIONS 0

#define	FMT_DEPRECATED_NUMERIC_ALIGN 0

#define	FMT_USE_FULL_CACHE_DRAGONBOX 0

#define	FMT_ALWAYS_INLINE inline

#define	FMT_SAFEBUFFERS

#define	FMT_STRING_IMPL(s, base)

#define	FMT_STRING(s) FMT_STRING_IMPL(s, fmt::compile_string)

#define	FMT_FORMAT_AS(Type, Base)

#define	FMT_FUNC

Typedefs
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 InputIt , typename OutChar >
using	needs_conversion = bool_constant< std::is_same< typename std::iterator_traits< InputIt >::value_type, char >::value &&std::is_same< OutChar, char8_type >::value >

template<typename T >
using	is_fast_float = bool_constant< std::numeric_limits< T >::is_iec559 &&sizeof(T)<=sizeof(double)>

using	memory_buffer = basic_memory_buffer< char >

using	wmemory_buffer = basic_memory_buffer< wchar_t >

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 &&!FMT_REDUCE_INT_INSTANTIATIONS, uint32_t, conditional_t< num_bits< T >()<=64, uint64_t, uint128_t > >

using	align_t = align::type

using	sign_t = sign::type

using	format_specs = basic_format_specs< char >

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, string_view)

using	FMT_DEPRECATED_ALIAS = detail::arg_formatter< OutputIt, Char >

template<typename OutputIt , typename Char = char>
using	format_context_t = basic_format_context< OutputIt, Char >

template<typename OutputIt , typename Char = char>
using	format_args_t = basic_format_args< format_context_t< OutputIt, Char > >

Enumerations
enum	{ inline_buffer_size = 500 }

enum	type { none, left, right, center, numeric }

enum	type { none, minus, plus, space }

enum	float_format : unsigned char { general, exp, fixed, hex }

enum	arg_id_kind { none, index, name }

Functions
template<typename Dest , typename Source >
Dest	bit_cast (const Source &source)

bool	is_big_endian ()

fallback_uintptr	to_uintptr (const void *p)

template<typename T >
constexpr T	max_value ()

template<typename T >
constexpr int	num_bits ()

template<>
constexpr int	num_bits< int128_t > ()

template<>
constexpr int	num_bits< uint128_t > ()

template<>
constexpr int	num_bits< fallback_uintptr > ()

FMT_INLINE void	assume (bool condition)

template<typename Char >
Char *	get_data (std::basic_string< Char > &s)

template<typename Container >
Container::value_type *	get_data (Container &c)

template<typename T >
T *	make_checked (T *p, size_t)

template<typename Container , FMT_ENABLE_IF(is_contiguous< Container >::value) >
checked_ptr< typename Container::value_type >	reserve (std::back_insert_iterator< Container > it, size_t n)

template<typename T >
buffer_appender< T >	reserve (buffer_appender< T > it, size_t n)

template<typename Iterator >
Iterator &	reserve (Iterator &it, size_t)

template<typename T , typename OutputIt >
constexpr T *	to_pointer (OutputIt, size_t)

template<typename T >
T *	to_pointer (buffer_appender< T > it, size_t n)

template<typename Container , FMT_ENABLE_IF(is_contiguous< Container >::value) >
std::back_insert_iterator< Container >	base_iterator (std::back_insert_iterator< Container > &it, checked_ptr< typename Container::value_type >)

template<typename Iterator >
Iterator	base_iterator (Iterator, Iterator it)

template<typename Char >
size_t	count_code_points (basic_string_view< Char > s)

size_t	count_code_points (basic_string_view< char > s)

size_t	count_code_points (basic_string_view< char8_type > s)

template<typename Char >
size_t	code_point_index (basic_string_view< Char > s, size_t n)

size_t	code_point_index (basic_string_view< char8_type > s, size_t n)

template<typename OutChar , typename InputIt , typename OutputIt , FMT_ENABLE_IF(!needs_conversion< InputIt, OutChar >::value) >
OutputIt	copy_str (InputIt begin, InputIt end, OutputIt it)

template<typename Char , typename InputIt >
counting_iterator	copy_str (InputIt begin, InputIt end, counting_iterator it)

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

template<typename T , FMT_ENABLE_IF(std::is_floating_point< T >::value) >
FMT_CONSTEXPR bool	is_supported_floating_point (T)

FMT_INLINE uint16_t	bsr2log10 (int bsr)

int	count_digits (uint64_t n)

template<unsigned BITS, typename UInt >
int	count_digits (UInt n)

template<>
int	count_digits< 4 > (detail::fallback_uintptr n)

template<typename Int >
constexpr int	digits10 () FMT_NOEXCEPT

template<>
constexpr int	digits10< int128_t > () FMT_NOEXCEPT

template<>
constexpr int	digits10< uint128_t > () FMT_NOEXCEPT

template<typename Char >
FMT_API std::string	grouping_impl (locale_ref loc)

template<typename Char >
std::string	grouping (locale_ref loc)

template<>
std::string	grouping< wchar_t > (locale_ref loc)

template<typename Char >
FMT_API Char	thousands_sep_impl (locale_ref loc)

template<typename Char >
Char	thousands_sep (locale_ref loc)

template<>
wchar_t	thousands_sep (locale_ref loc)

template<typename Char >
FMT_API Char	decimal_point_impl (locale_ref loc)

template<typename Char >
Char	decimal_point (locale_ref loc)

template<>
wchar_t	decimal_point (locale_ref loc)

template<typename Char >
bool	equal2 (const Char lhs, const char rhs)

bool	equal2 (const char lhs, const char rhs)

template<typename Char >
void	copy2 (Char dst, const char src)

FMT_INLINE void	copy2 (char dst, const char src)

template<typename Char , typename UInt >
format_decimal_result< Char * >	format_decimal (Char *out, UInt value, int size)

template<typename Char , typename UInt , typename Iterator , FMT_ENABLE_IF(!std::is_pointer< remove_cvref_t< Iterator >>::value) >
format_decimal_result< Iterator >	format_decimal (Iterator out, UInt value, int size)

template<unsigned BASE_BITS, typename Char , typename UInt >
Char *	format_uint (Char *buffer, UInt value, int num_digits, bool upper=false)

template<unsigned BASE_BITS, typename Char >
Char *	format_uint (Char *buffer, detail::fallback_uintptr n, int num_digits, bool=false)

template<unsigned BASE_BITS, typename Char , typename It , typename UInt >
It	format_uint (It out, UInt value, int num_digits, bool upper=false)

template<typename T >
FMT_API decimal_fp< T >	to_decimal (T x) FMT_NOEXCEPT

template<typename T >
constexpr dragonbox::float_info< T >::carrier_uint	exponent_mask ()

template<typename Char , typename It >
It	write_exponent (int exp, It it)

template<typename T >
int	format_float (T 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)

template<typename T >
T	promote_float (T value)

double	promote_float (float value)

template<typename Handler >
FMT_CONSTEXPR void	handle_int_type_spec (char spec, Handler &&handler)

template<typename ErrorHandler = error_handler, typename Char >
FMT_CONSTEXPR float_specs	parse_float_type_spec (const basic_format_specs< Char > &specs, ErrorHandler &&eh={})

template<typename Char , typename Handler >
FMT_CONSTEXPR void	handle_char_specs (const basic_format_specs< Char > *specs, Handler &&handler)

template<typename Char , typename Handler >
FMT_CONSTEXPR void	handle_cstring_type_spec (Char spec, Handler &&handler)

template<typename Char , typename ErrorHandler >
FMT_CONSTEXPR void	check_string_type_spec (Char spec, ErrorHandler &&eh)

template<typename Char , typename ErrorHandler >
FMT_CONSTEXPR void	check_pointer_type_spec (Char spec, ErrorHandler &&eh)

template<typename OutputIt , typename Char >
FMT_NOINLINE OutputIt	fill (OutputIt it, size_t n, const fill_t< Char > &fill)

template<align::type align = align::left, typename OutputIt , typename Char , typename F >
OutputIt	write_padded (OutputIt out, const basic_format_specs< Char > &specs, size_t size, size_t width, F &&f)

template<align::type align = align::left, typename OutputIt , typename Char , typename F >
OutputIt	write_padded (OutputIt out, const basic_format_specs< Char > &specs, size_t size, F &&f)

template<typename Char , typename OutputIt >
OutputIt	write_bytes (OutputIt out, string_view bytes, const basic_format_specs< Char > &specs)

template<typename OutputIt , typename Char , typename F >
OutputIt	write_int (OutputIt out, int num_digits, string_view prefix, const basic_format_specs< Char > &specs, F f)

template<typename StrChar , typename Char , typename OutputIt >
OutputIt	write (OutputIt out, basic_string_view< StrChar > s, const basic_format_specs< Char > &specs)

template<typename Char , typename OutputIt >
OutputIt	write_nonfinite (OutputIt out, bool isinf, const basic_format_specs< Char > &specs, const float_specs &fspecs)

int	get_significand_size (const big_decimal_fp &fp)

template<typename T >
int	get_significand_size (const dragonbox::decimal_fp< T > &fp)

template<typename Char , typename OutputIt >
OutputIt	write_significand (OutputIt out, const char *significand, int &significand_size)

template<typename Char , typename OutputIt , typename UInt >
OutputIt	write_significand (OutputIt out, UInt significand, int significand_size)

template<typename Char , typename UInt , FMT_ENABLE_IF(std::is_integral< UInt >::value) >
Char *	write_significand (Char *out, UInt significand, int significand_size, int integral_size, Char decimal_point)

template<typename OutputIt , typename UInt , typename Char , FMT_ENABLE_IF(!std::is_pointer< remove_cvref_t< OutputIt >>::value) >
OutputIt	write_significand (OutputIt out, UInt significand, int significand_size, int integral_size, Char decimal_point)

template<typename OutputIt , typename Char >
OutputIt	write_significand (OutputIt out, const char *significand, int significand_size, int integral_size, Char decimal_point)

template<typename OutputIt , typename DecimalFP , typename Char >
OutputIt	write_float (OutputIt out, const DecimalFP &fp, const basic_format_specs< Char > &specs, float_specs fspecs, Char decimal_point)

template<typename Char , typename OutputIt , typename T , FMT_ENABLE_IF(std::is_floating_point< T >::value) >
OutputIt	write (OutputIt out, T value, basic_format_specs< Char > specs, locale_ref loc={})

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

template<typename Char , typename OutputIt >
OutputIt	write_char (OutputIt out, Char value, const basic_format_specs< Char > &specs)

template<typename Char , typename OutputIt , typename UIntPtr >
OutputIt	write_ptr (OutputIt out, UIntPtr value, const basic_format_specs< Char > *specs)

template<typename Char , typename OutputIt >
OutputIt	write (OutputIt out, monostate)

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

template<typename Char , typename OutputIt >
OutputIt	write (OutputIt out, basic_string_view< Char > value)

template<typename Char >
buffer_appender< Char >	write (buffer_appender< Char > out, basic_string_view< Char > value)

template<typename Char , typename OutputIt >
OutputIt	write (OutputIt out, bool value)

template<typename Char , typename OutputIt >
OutputIt	write (OutputIt out, Char value)

template<typename Char , typename OutputIt >
OutputIt	write (OutputIt out, const Char *value)

template<typename Char , typename OutputIt >
OutputIt	write (OutputIt out, const void *value)

template<typename Char , typename OutputIt , typename T >
auto	write (OutputIt out, const T &value) -> typename std::enable_if< mapped_type_constant< T, basic_format_context< OutputIt, Char >>::value==type::custom_type, OutputIt >::type

template<typename Char >
FMT_CONSTEXPR bool	is_name_start (Char c)

template<typename Char , typename ErrorHandler >
FMT_CONSTEXPR int	parse_nonnegative_int (const Char &begin, const Char end, ErrorHandler &&eh)

template<template< typename > class Handler, typename FormatArg , typename ErrorHandler >
FMT_CONSTEXPR int	get_dynamic_spec (FormatArg arg, ErrorHandler eh)

template<typename Context , typename ID >
FMT_CONSTEXPR Context::format_arg	get_arg (Context &ctx, ID id)

template<typename Char , typename IDHandler >
FMT_CONSTEXPR const Char *	parse_arg_id (const Char begin, const Char end, IDHandler &&handler)

template<typename Char >
FMT_CONSTEXPR int	code_point_length (const Char *begin)

template<typename Char >
constexpr bool	is_ascii_letter (Char c)

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

template<typename Char , FMT_ENABLE_IF(std::is_enum< Char >::value) >
constexpr std::underlying_type< Char >::type	to_ascii (Char value)

template<typename Char , typename Handler >
FMT_CONSTEXPR const Char *	parse_align (const Char begin, const Char end, Handler &&handler)

template<typename Char , typename Handler >
FMT_CONSTEXPR const Char *	parse_width (const Char begin, const Char end, Handler &&handler)

template<typename Char , typename Handler >
FMT_CONSTEXPR const Char *	parse_precision (const Char begin, const Char end, Handler &&handler)

template<typename Char , typename SpecHandler >
FMT_CONSTEXPR const Char *	parse_format_specs (const Char begin, const Char end, SpecHandler &&handler)

template<bool IS_CONSTEXPR, typename T , typename Ptr = const T*>
FMT_CONSTEXPR bool	find (Ptr first, Ptr last, T value, Ptr &out)

template<>
bool	find< false, char > (const char first, const char last, char value, const char *&out)

template<typename Char , typename Handler >
FMT_CONSTEXPR const Char *	parse_replacement_field (const Char begin, const Char end, Handler &&handler)

template<bool IS_CONSTEXPR, typename Char , typename Handler >
FMT_CONSTEXPR_DECL FMT_INLINE void	parse_format_string (basic_string_view< Char > format_str, Handler &&handler)

template<typename T , typename ParseContext >
FMT_CONSTEXPR const ParseContext::char_type *	parse_format_specs (ParseContext &ctx)

template<typename Char , size_t N>
FMT_CONSTEXPR basic_string_view< Char >	compile_string_to_view (const Char(&s)[N])

template<typename Char >
FMT_CONSTEXPR basic_string_view< Char >	compile_string_to_view (const std_string_view< Char > &s)

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

template<template< typename > class Handler, typename Context >
void	handle_dynamic_spec (int &value, arg_ref< typename Context::char_type > ref, Context &ctx)

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

FMT_FUNC void	report_error (format_func func, int error_code, string_view message) FMT_NOEXCEPT

FMT_API void	format_system_error (detail::buffer< char > &out, int error_code, string_view message) FMT_NOEXCEPT

FMT_API void	report_system_error (int error_code, string_view message) FMT_NOEXCEPT

	FMT_FORMAT_AS (signed char, int)

	FMT_FORMAT_AS (unsigned char, unsigned)

	FMT_FORMAT_AS (short, int)

	FMT_FORMAT_AS (long, long long)

	FMT_FORMAT_AS (unsigned long, unsigned long long)

	FMT_FORMAT_AS (Char , const Char )

	FMT_FORMAT_AS (std::basic_string< Char >, basic_string_view< Char >)

	FMT_FORMAT_AS (std::nullptr_t, const void *)

	FMT_FORMAT_AS (detail::std_string_view< Char >, basic_string_view< Char >)

template<typename Char , typename ErrorHandler >
FMT_CONSTEXPR void	advance_to (basic_format_parse_context< Char, ErrorHandler > &ctx, const Char *p)

template<typename T >
const void *	ptr (const T *p)

template<typename T >
const void *	ptr (const std::unique_ptr< T > &p)

template<typename T >
const void *	ptr (const std::shared_ptr< T > &p)

template<typename It , typename Sentinel >
arg_join< It, Sentinel, char >	join (It begin, Sentinel end, string_view sep)

template<typename It , typename Sentinel >
arg_join< It, Sentinel, wchar_t >	join (It begin, Sentinel end, wstring_view sep)

template<typename Range >
arg_join< detail::iterator_t< Range >, detail::sentinel_t< Range >, char >	join (Range &&range, string_view sep)

template<typename Range >
arg_join< detail::iterator_t< Range >, detail::sentinel_t< Range >, wchar_t >	join (Range &&range, wstring_view sep)

template<typename T , FMT_ENABLE_IF(!std::is_integral< T >::value) >
std::string	to_string (const T &value)

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

template<typename T >
std::wstring	to_wstring (const T &value)

template<typename Char , size_t SIZE>
std::basic_string< Char >	to_string (const basic_memory_buffer< Char, SIZE > &buf)

template FMT_API std::string	grouping_impl< char > (locale_ref loc)

template FMT_API std::string	grouping_impl< wchar_t > (locale_ref loc)

template FMT_API char	thousands_sep_impl< char > (locale_ref loc)

template FMT_API wchar_t	thousands_sep_impl< wchar_t > (locale_ref loc)

template<typename Char >
FMT_FUNC Char	decimal_point_impl (locale_ref loc)

template int	format_float< double > (double value, int precision, float_specs specs, buffer< char > &buf)

template int	format_float< long double > (long double value, int precision, float_specs specs, buffer< char > &buf)

int	snprintf_float (float value, int precision, float_specs specs, buffer< char > &buf)=delete

template int	snprintf_float< double > (double value, int precision, float_specs specs, buffer< char > &buf)

template int	snprintf_float< long double > (long double value, int precision, float_specs specs, buffer< char > &buf)

template<typename S , typename Char = char_t<S>, FMT_ENABLE_IF(detail::is_string< S >::value) >
void	vformat_to (detail::buffer< Char > &buf, const S &format_str, basic_format_args< FMT_BUFFER_CONTEXT(type_identity_t< Char >)> args)

template<typename S , typename... Args, size_t SIZE = inline_buffer_size, typename Char = enable_if_t<detail::is_string<S>::value, char_t<S>>>
buffer_context< Char >::iterator	format_to (basic_memory_buffer< Char, SIZE > &buf, const S &format_str, Args &&... args)

template<typename OutputIt , typename Char , typename... Args>
FMT_DEPRECATED format_arg_store< buffer_context< Char >, Args... >	make_format_to_n_args (const Args &... args)

template<typename Char , FMT_ENABLE_IF(std::is_same< Char, wchar_t >::value) >
void	vprint (std::FILE *f, basic_string_view< Char > format_str, wformat_args args)

template<typename Char , FMT_ENABLE_IF(std::is_same< Char, wchar_t >::value) >
void	vprint (basic_string_view< Char > format_str, wformat_args args)

Variables
FMT_EXTERN template struct	basic_data< void >

Macro Definition Documentation

◆ FMT_ALWAYS_INLINE

#define FMT_ALWAYS_INLINE inline

Definition at line 977 of file format.h.

◆ FMT_CATCH

#define FMT_CATCH ( x ) catch (x)

Definition at line 126 of file format.h.

Referenced by format_system_error().

◆ FMT_CUDA_VERSION

#define FMT_CUDA_VERSION 0

Definition at line 57 of file format.h.

◆ FMT_DEPRECATED_NUMERIC_ALIGN

#define FMT_DEPRECATED_NUMERIC_ALIGN 0

Definition at line 272 of file format.h.

◆ FMT_FALLTHROUGH

#define FMT_FALLTHROUGH

Definition at line 87 of file format.h.

Referenced by detail::parse_float_type_spec().

◆ 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) -> decltype(ctx.out()) { \
      return formatter<Base, Char>::format(val, ctx);                         \
    }                                                                         \
  }

Definition at line 3481 of file format.h.

◆ FMT_FUNC

#define FMT_FUNC

Definition at line 3957 of file format.h.

Referenced by detail::decimal_point_impl(), and vprint().

◆ FMT_HAS_BUILTIN

#define FMT_HAS_BUILTIN ( x ) 0

Definition at line 63 of file format.h.

◆ FMT_ICC_VERSION

#define FMT_ICC_VERSION 0

Definition at line 51 of file format.h.

◆ FMT_MAYBE_UNUSED

#define FMT_MAYBE_UNUSED

Definition at line 94 of file format.h.

Referenced by detail::safe_strerror().

◆ FMT_NOINLINE

#define FMT_NOINLINE

Definition at line 69 of file format.h.

◆ FMT_REDUCE_INT_INSTANTIATIONS

#define FMT_REDUCE_INT_INSTANTIATIONS 0

Definition at line 174 of file format.h.

Referenced by detail::is_supported_floating_point().

◆ FMT_SAFEBUFFERS

#define FMT_SAFEBUFFERS

Definition at line 984 of file format.h.

◆ FMT_STRING

#define FMT_STRING ( s ) FMT_STRING_IMPL(s, fmt::compile_string)

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");

Definition at line 3219 of file format.h.

Referenced by vprint().

◆ FMT_STRING_IMPL

#define FMT_STRING_IMPL	(	s,
		base
	)

Value:

[] {                                                            \
    /* Use a macro-like name to avoid shadowing warnings. */      \
    struct FMT_COMPILE_STRING : base {                            \
      using char_type = fmt::remove_cvref_t<decltype(s[0])>;      \
      FMT_MAYBE_UNUSED FMT_CONSTEXPR                              \
      operator fmt::basic_string_view<char_type>() const {        \
        return fmt::detail::compile_string_to_view<char_type>(s); \
      }                                                           \
    };                                                            \
    return FMT_COMPILE_STRING();                                  \
  }()

Definition at line 3196 of file format.h.

◆ FMT_THROW

#define FMT_THROW ( x ) throw x

◆ FMT_TRY

#define FMT_TRY try

Definition at line 125 of file format.h.

Referenced by format_system_error().

◆ FMT_USE_DOUBLE

#define FMT_USE_DOUBLE 1

Definition at line 162 of file format.h.

Referenced by detail::is_supported_floating_point(), and formatter< T, Char, enable_if_t< detail::type_constant< T, Char >::value !=detail::type::custom_type > >::parse().

◆ FMT_USE_FLOAT

#define FMT_USE_FLOAT 1

Definition at line 158 of file format.h.

Referenced by detail::is_supported_floating_point(), and formatter< T, Char, enable_if_t< detail::type_constant< T, Char >::value !=detail::type::custom_type > >::parse().

◆ FMT_USE_FULL_CACHE_DRAGONBOX

#define FMT_USE_FULL_CACHE_DRAGONBOX 0

Definition at line 595 of file format.h.

◆ FMT_USE_LONG_DOUBLE

#define FMT_USE_LONG_DOUBLE 1

Definition at line 166 of file format.h.

Referenced by detail::is_supported_floating_point(), and formatter< T, Char, enable_if_t< detail::type_constant< T, Char >::value !=detail::type::custom_type > >::parse().

◆ FMT_USE_UDL_TEMPLATE

#define FMT_USE_UDL_TEMPLATE 0

Definition at line 153 of file format.h.

◆ FMT_USE_USER_DEFINED_LITERALS

#define FMT_USE_USER_DEFINED_LITERALS 0

Definition at line 139 of file format.h.

Typedef Documentation

◆ align_t

using align_t = align::type

Definition at line 1177 of file format.h.

◆ FMT_DEPRECATED_ALIAS

using FMT_DEPRECATED_ALIAS = basic_format_args<buffer_context<Char> >

Definition at line 3260 of file format.h.

◆ format_args_t

using format_args_t = basic_format_args<format_context_t<OutputIt, Char> >

Definition at line 3829 of file format.h.

◆ format_context_t

using format_context_t = basic_format_context<OutputIt, Char>

Definition at line 3826 of file format.h.

◆ format_specs

using format_specs = basic_format_specs<char>

Definition at line 1203 of file format.h.

◆ memory_buffer

using memory_buffer = basic_memory_buffer<char>

Definition at line 761 of file format.h.

◆ sign_t

using sign_t = sign::type

Definition at line 1182 of file format.h.

◆ wmemory_buffer

using wmemory_buffer = basic_memory_buffer<wchar_t>

Definition at line 762 of file format.h.

Enumeration Type Documentation

◆ anonymous enum

anonymous enum

Enumerator
inline_buffer_size

Definition at line 621 of file format.h.

Function Documentation

◆ advance_to()

FMT_CONSTEXPR void advance_to	(	basic_format_parse_context< Char, ErrorHandler > &	ctx,
		const Char *	p
	)

Definition at line 3589 of file format.h.

References basic_format_parse_context< Char, ErrorHandler >::advance_to(), and basic_format_parse_context< Char, ErrorHandler >::begin().

Referenced by format_handler< OutputIt, Char, Context >::on_format_specs(), format_string_checker< Char, ErrorHandler, Args >::on_format_specs(), arg_formatter< OutputIt, Char >::operator()(), and detail::cf::vformat_to().

◆ FMT_FORMAT_AS() [1/9]

FMT_FORMAT_AS	(	signed	char,
		int
	)

◆ FMT_FORMAT_AS() [2/9]

FMT_FORMAT_AS	(	unsigned	char,
		unsigned
	)

◆ FMT_FORMAT_AS() [3/9]

FMT_FORMAT_AS	(	short	,
		int
	)

◆ FMT_FORMAT_AS() [4/9]

FMT_FORMAT_AS	(	long	,
		long	long
	)

◆ FMT_FORMAT_AS() [5/9]

FMT_FORMAT_AS	(	unsigned	long,
		unsigned long	long
	)

◆ FMT_FORMAT_AS() [6/9]

FMT_FORMAT_AS	(	Char *	,
		const Char *
	)

◆ FMT_FORMAT_AS() [7/9]

FMT_FORMAT_AS	(	std::basic_string< Char >	,
		basic_string_view< Char >
	)

◆ FMT_FORMAT_AS() [8/9]

FMT_FORMAT_AS	(	std::nullptr_t	,
		const void *
	)

◆ FMT_FORMAT_AS() [9/9]

FMT_FORMAT_AS	(	detail::std_string_view< Char >	,
		basic_string_view< Char >
	)

◆ format_system_error()

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

Formats an error returned by an operating system or a language runtime, for example a file opening error, and writes it to out in the following form:

.. 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. If error_code is not a valid error code such as -1, the system message may look like "Unknown error -1" and is platform-dependent.

Definition at line 2713 of file format-inl.h.

References FMT_CATCH, FMT_TRY, detail::format_error_code(), format_to(), inline_buffer_size, basic_memory_buffer< T, SIZE, Allocator >::resize(), detail::safe_strerror(), and buffer< T >::size().

Referenced by system_error::error_code(), system_error::init(), and report_system_error().

◆ format_to()

buffer_context<Char>::iterator format_to	(	basic_memory_buffer< Char, SIZE > &	buf,
		const S &	format_str,
		Args &&...	args
	)

Definition at line 3818 of file format.h.

References make_args_checked(), detail::to_string_view(), and detail::vformat_to().

◆ join() [1/4]

arg_join<It, Sentinel, char> join	(	It	begin,
		Sentinel	end,
		string_view	sep
	)

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

Definition at line 3681 of file format.h.

Referenced by join().

◆ join() [2/4]

arg_join<It, Sentinel, wchar_t> join	(	It	begin,
		Sentinel	end,
		wstring_view	sep
	)

Definition at line 3686 of file format.h.

◆ join() [3/4]

arg_join<detail::iterator_t<Range>, detail::sentinel_t<Range>, char> join	(	Range &&	range,
		string_view	sep
	)

Returns an object 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"

Definition at line 3707 of file format.h.

References join().

◆ join() [4/4]

arg_join<detail::iterator_t<Range>, detail::sentinel_t<Range>, wchar_t> join	(	Range &&	range,
		wstring_view	sep
	)

Definition at line 3713 of file format.h.

References join().

◆ make_format_to_n_args()

FMT_DEPRECATED format_arg_store<buffer_context<Char>, Args...> make_format_to_n_args ( const Args &... args )

Definition at line 3840 of file format.h.

◆ ptr() [1/3]

const void* ptr ( const T * p )

Converts p to const void* for pointer formatting.

Example**::

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

Definition at line 3603 of file format.h.

Referenced by detail::format_uint(), format_string_compiler< Char, PartHandler >::on_replacement_field(), detail::parse_chrono_format(), and detail::write().

◆ ptr() [2/3]

const void* ptr ( const std::unique_ptr< T > & p )

Definition at line 3604 of file format.h.

◆ ptr() [3/3]

const void* ptr ( const std::shared_ptr< T > & p )

Definition at line 3607 of file format.h.

◆ report_system_error()

FMT_API void report_system_error	(	int	error_code,
		string_view	message
	)

Referenced by system_error::error_code().

◆ to_string() [1/3]

std::string to_string ( const T & value )

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

Example**::

#include <fmt/format.h>

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

Definition at line 3730 of file format.h.

Referenced by compile(), format(), system_error::init(), stringifier::operator()(), vformat(), detail::vformat(), and vsprintf().

◆ to_string() [2/3]

std::string to_string ( T value )

Definition at line 3737 of file format.h.

◆ to_string() [3/3]

std::basic_string<Char> to_string ( const basic_memory_buffer< Char, SIZE > & buf )

◆ to_wstring()

std::wstring to_wstring ( const T & value )

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

Definition at line 3749 of file format.h.

References format().

◆ vformat_to()

void vformat_to	(	detail::buffer< Char > &	buf,
		const S &	format_str,
		basic_format_args< FMT_BUFFER_CONTEXT(type_identity_t< Char >)>	args
	)

Definition at line 3810 of file format.h.

References inline_buffer_size, detail::to_string_view(), and detail::vformat_to().

◆ vprint() [1/2]

void vprint	(	std::FILE *	f,
		basic_string_view< Char >	format_str,
		wformat_args	args
	)

Definition at line 3854 of file format.h.

References buffer< T >::data(), FMT_THROW, buffer< T >::push_back(), and detail::vformat_to().

Referenced by vprint().

◆ vprint() [2/2]

void vprint	(	basic_string_view< Char >	format_str,
		wformat_args	args
	)

Definition at line 3864 of file format.h.

References FMT_CONSTEXPR, FMT_CONSTEXPR_DECL, FMT_END_NAMESPACE, FMT_STRING, format(), and vprint().

SoPlex

Classes

Namespaces

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ FMT_ALWAYS_INLINE

◆ FMT_CATCH

◆ FMT_CUDA_VERSION

◆ FMT_DEPRECATED_NUMERIC_ALIGN

◆ FMT_FALLTHROUGH

◆ FMT_FORMAT_AS

◆ FMT_FUNC

◆ FMT_HAS_BUILTIN

◆ FMT_ICC_VERSION

◆ FMT_MAYBE_UNUSED

◆ FMT_NOINLINE

◆ FMT_REDUCE_INT_INSTANTIATIONS

◆ FMT_SAFEBUFFERS

◆ FMT_STRING

◆ FMT_STRING_IMPL

◆ FMT_THROW

◆ FMT_TRY

◆ FMT_USE_DOUBLE

◆ FMT_USE_FLOAT

◆ FMT_USE_FULL_CACHE_DRAGONBOX

◆ FMT_USE_LONG_DOUBLE

◆ FMT_USE_UDL_TEMPLATE

◆ FMT_USE_USER_DEFINED_LITERALS

Typedef Documentation

◆ align_t

◆ FMT_DEPRECATED_ALIAS

◆ format_args_t

◆ format_context_t

◆ format_specs

◆ memory_buffer

◆ sign_t

◆ wmemory_buffer

Enumeration Type Documentation

◆ anonymous enum

Function Documentation

◆ advance_to()

◆ FMT_FORMAT_AS() [1/9]

◆ FMT_FORMAT_AS() [2/9]

◆ FMT_FORMAT_AS() [3/9]

◆ FMT_FORMAT_AS() [4/9]

◆ FMT_FORMAT_AS() [5/9]

◆ FMT_FORMAT_AS() [6/9]

◆ FMT_FORMAT_AS() [7/9]

◆ FMT_FORMAT_AS() [8/9]

◆ FMT_FORMAT_AS() [9/9]

◆ format_system_error()

◆ format_to()

◆ join() [1/4]

◆ join() [2/4]

◆ join() [3/4]

◆ join() [4/4]

◆ make_format_to_n_args()

◆ ptr() [1/3]

◆ ptr() [2/3]

◆ ptr() [3/3]

◆ report_system_error()

◆ to_string() [1/3]

◆ to_string() [2/3]

◆ to_string() [3/3]

◆ to_wstring()

◆ vformat_to()

◆ vprint() [1/2]

◆ vprint() [2/2]