format.h File Reference

#include <algorithm>
#include <cerrno>
#include <cmath>
#include <cstdint>
#include <limits>
#include <memory>
#include <stdexcept>
#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
struct	detail::fallback_uintptr
class	detail::counting_iterator
struct	detail::counting_iterator::value_type
class	detail::truncating_iterator_base< OutputIt >
class	detail::truncating_iterator< OutputIt, Enable >
class	detail::truncating_iterator< OutputIt, std::false_type >
class	detail::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	detail::uint128_wrapper
struct	detail::divtest_table_entry< T >
struct	detail::basic_data< T >
struct	detail::data
struct	detail::format_decimal_result< Iterator >
class	detail::utf8_to_utf16
struct	detail::null< T >
struct	detail::fill_t< Char >
struct	basic_format_specs< Char >
struct	detail::dragonbox::float_info< T >
struct	detail::dragonbox::float_info< float >
struct	detail::dragonbox::float_info< double >
struct	detail::dragonbox::decimal_fp< T >
struct	detail::float_specs
class	detail::int_type_checker< ErrorHandler >
class	detail::char_specs_checker< ErrorHandler >
class	detail::cstring_type_checker< ErrorHandler >
struct	detail::write_int_data< Char >
struct	detail::int_writer< OutputIt, Char, UInt >
struct	detail::big_decimal_fp
struct	detail::is_integral< T >
struct	detail::is_integral< int128_t >
struct	detail::is_integral< uint128_t >
struct	detail::default_arg_formatter< OutputIt, Char >
class	detail::arg_formatter_base< OutputIt, Char, ErrorHandler >
class	detail::arg_formatter< OutputIt, Char >
class	detail::custom_formatter< Context >
class	detail::width_checker< ErrorHandler >
class	detail::precision_checker< ErrorHandler >
class	detail::specs_setter< Char >
class	detail::numeric_specs_checker< ErrorHandler >
class	detail::specs_checker< Handler >
struct	detail::auto_id
class	detail::specs_handler< ParseContext, Context >
struct	detail::arg_ref< Char >
union	detail::arg_ref< Char >::value
struct	detail::dynamic_format_specs< Char >
class	detail::dynamic_specs_handler< ParseContext >
struct	detail::width_adapter< SpecHandler, Char >
struct	detail::precision_adapter< SpecHandler, Char >
struct	detail::id_adapter< Handler, Char >
struct	detail::format_handler< OutputIt, Char, Context >
class	detail::compile_parse_context< Char, ErrorHandler >
class	detail::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 >
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	detail::uintptr_t = fallback_uintptr
template<typename T >
using	detail::iterator_t = decltype(std::begin(std::declval< T & >()))
template<typename T >
using	detail::sentinel_t = decltype(std::end(std::declval< T & >()))
template<typename T >
using	detail::checked_ptr = T *
template<typename InputIt , typename OutChar >
using	detail::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	detail::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	detail::is_signed = std::integral_constant< bool, std::numeric_limits< T >::is_signed||std::is_same< T, int128_t >::value >
template<typename T >
using	detail::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	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	detail::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	align::type {   align::none, align::left, align::right, align::center,   align::numeric }
enum	sign::type { sign::none, sign::minus, sign::plus, sign::space }
enum	detail::float_format : unsigned char { detail::float_format::general, detail::float_format::exp, detail::float_format::fixed, detail::float_format::hex }
enum	detail::arg_id_kind { detail::arg_id_kind::none, detail::arg_id_kind::index, detail::arg_id_kind::name }

Functions
template<typename Dest , typename Source >
Dest	detail::bit_cast (const Source &source)
bool	detail::is_big_endian ()
fallback_uintptr	detail::to_uintptr (const void *p)
template<typename T >
constexpr T	detail::max_value ()
template<typename T >
constexpr int	detail::num_bits ()
template<>
constexpr int	detail::num_bits< int128_t > ()
template<>
constexpr int	detail::num_bits< uint128_t > ()
template<>
constexpr int	detail::num_bits< fallback_uintptr > ()
FMT_INLINE void	detail::assume (bool condition)
template<typename Char >
Char *	detail::get_data (std::basic_string< Char > &s)
template<typename Container >
Container::value_type *	detail::get_data (Container &c)
template<typename T >
T *	detail::make_checked (T *p, size_t)
template<typename Container , FMT_ENABLE_IF(is_contiguous< Container >::value) >
checked_ptr< typename Container::value_type >	detail::reserve (std::back_insert_iterator< Container > it, size_t n)
template<typename T >
buffer_appender< T >	detail::reserve (buffer_appender< T > it, size_t n)
template<typename Iterator >
Iterator &	detail::reserve (Iterator &it, size_t)
template<typename T , typename OutputIt >
constexpr T *	detail::to_pointer (OutputIt, size_t)
template<typename T >
T *	detail::to_pointer (buffer_appender< T > it, size_t n)
template<typename Container , FMT_ENABLE_IF(is_contiguous< Container >::value) >
std::back_insert_iterator < Container >	detail::base_iterator (std::back_insert_iterator< Container > &it, checked_ptr< typename Container::value_type >)
template<typename Iterator >
Iterator	detail::base_iterator (Iterator, Iterator it)
template<typename Char >
size_t	detail::count_code_points (basic_string_view< Char > s)
size_t	detail::count_code_points (basic_string_view< char > s)
size_t	detail::count_code_points (basic_string_view< char8_type > s)
template<typename Char >
size_t	detail::code_point_index (basic_string_view< Char > s, size_t n)
size_t	detail::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	detail::copy_str (InputIt begin, InputIt end, OutputIt it)
template<typename Char , typename InputIt >
counting_iterator	detail::copy_str (InputIt begin, InputIt end, counting_iterator it)
template<typename T , FMT_ENABLE_IF(is_signed< T >::value) >
FMT_CONSTEXPR bool	detail::is_negative (T value)
template<typename T , FMT_ENABLE_IF(std::is_floating_point< T >::value) >
FMT_CONSTEXPR bool	detail::is_supported_floating_point (T)
FMT_INLINE uint16_t	detail::bsr2log10 (int bsr)
int	detail::count_digits (uint64_t n)
template<unsigned BITS, typename UInt >
int	detail::count_digits (UInt n)
template<>
int	detail::count_digits< 4 > (detail::fallback_uintptr n)
template<typename Int >
constexpr int	detail::digits10 () FMT_NOEXCEPT
template<>
constexpr int	detail::digits10< int128_t > () FMT_NOEXCEPT
template<>
constexpr int	detail::digits10< uint128_t > () FMT_NOEXCEPT
template<typename Char >
FMT_API std::string	detail::grouping_impl (locale_ref loc)
template<typename Char >
std::string	detail::grouping (locale_ref loc)
template<>
std::string	detail::grouping< wchar_t > (locale_ref loc)
template<typename Char >
FMT_API Char	detail::thousands_sep_impl (locale_ref loc)
template<typename Char >
Char	detail::thousands_sep (locale_ref loc)
template<>
wchar_t	detail::thousands_sep (locale_ref loc)
template<typename Char >
FMT_API Char	detail::decimal_point_impl (locale_ref loc)
template<typename Char >
Char	detail::decimal_point (locale_ref loc)
template<>
wchar_t	detail::decimal_point (locale_ref loc)
template<typename Char >
bool	detail::equal2 (const Char *lhs, const char *rhs)
bool	detail::equal2 (const char *lhs, const char *rhs)
template<typename Char >
void	detail::copy2 (Char *dst, const char *src)
FMT_INLINE void	detail::copy2 (char *dst, const char *src)
template<typename Char , typename UInt >
format_decimal_result< Char * >	detail::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 >	detail::format_decimal (Iterator out, UInt value, int size)
template<unsigned BASE_BITS, typename Char , typename UInt >
Char *	detail::format_uint (Char *buffer, UInt value, int num_digits, bool upper=false)
template<unsigned BASE_BITS, typename Char >
Char *	detail::format_uint (Char *buffer, detail::fallback_uintptr n, int num_digits, bool=false)
template<unsigned BASE_BITS, typename Char , typename It , typename UInt >
It	detail::format_uint (It out, UInt value, int num_digits, bool upper=false)
template<typename T >
FMT_API decimal_fp< T >	detail::dragonbox::to_decimal (T x) FMT_NOEXCEPT
template<typename T >
constexpr dragonbox::float_info< T > ::carrier_uint	detail::exponent_mask ()
template<typename Char , typename It >
It	detail::write_exponent (int exp, It it)
template<typename T >
int	detail::format_float (T value, int precision, float_specs specs, buffer< char > &buf)
template<typename T >
int	detail::snprintf_float (T value, int precision, float_specs specs, buffer< char > &buf)
template<typename T >
T	detail::promote_float (T value)
double	detail::promote_float (float value)
template<typename Handler >
FMT_CONSTEXPR void	detail::handle_int_type_spec (char spec, Handler &&handler)
template<typename ErrorHandler = error_handler, typename Char >
FMT_CONSTEXPR float_specs	detail::parse_float_type_spec (const basic_format_specs< Char > &specs, ErrorHandler &&eh={})
template<typename Char , typename Handler >
FMT_CONSTEXPR void	detail::handle_char_specs (const basic_format_specs< Char > *specs, Handler &&handler)
template<typename Char , typename Handler >
FMT_CONSTEXPR void	detail::handle_cstring_type_spec (Char spec, Handler &&handler)
template<typename Char , typename ErrorHandler >
FMT_CONSTEXPR void	detail::check_string_type_spec (Char spec, ErrorHandler &&eh)
template<typename Char , typename ErrorHandler >
FMT_CONSTEXPR void	detail::check_pointer_type_spec (Char spec, ErrorHandler &&eh)
template<typename OutputIt , typename Char >
FMT_NOINLINE OutputIt	detail::fill (OutputIt it, size_t n, const fill_t< Char > &fill)
template<align::type align = align::left, typename OutputIt , typename Char , typename F >
OutputIt	detail::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	detail::write_padded (OutputIt out, const basic_format_specs< Char > &specs, size_t size, F &&f)
template<typename Char , typename OutputIt >
OutputIt	detail::write_bytes (OutputIt out, string_view bytes, const basic_format_specs< Char > &specs)
template<typename OutputIt , typename Char , typename F >
OutputIt	detail::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	detail::write (OutputIt out, basic_string_view< StrChar > s, const basic_format_specs< Char > &specs)
template<typename Char , typename OutputIt >
OutputIt	detail::write_nonfinite (OutputIt out, bool isinf, const basic_format_specs< Char > &specs, const float_specs &fspecs)
int	detail::get_significand_size (const big_decimal_fp &fp)
template<typename T >
int	detail::get_significand_size (const dragonbox::decimal_fp< T > &fp)
template<typename Char , typename OutputIt >
OutputIt	detail::write_significand (OutputIt out, const char *significand, int &significand_size)
template<typename Char , typename OutputIt , typename UInt >
OutputIt	detail::write_significand (OutputIt out, UInt significand, int significand_size)
template<typename Char , typename UInt , FMT_ENABLE_IF(std::is_integral< UInt >::value) >
Char *	detail::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	detail::write_significand (OutputIt out, UInt significand, int significand_size, int integral_size, Char decimal_point)
template<typename OutputIt , typename Char >
OutputIt	detail::write_significand (OutputIt out, const char *significand, int significand_size, int integral_size, Char decimal_point)
template<typename OutputIt , typename DecimalFP , typename Char >
OutputIt	detail::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	detail::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	detail::write (OutputIt out, T value)
template<typename Char , typename OutputIt >
OutputIt	detail::write_char (OutputIt out, Char value, const basic_format_specs< Char > &specs)
template<typename Char , typename OutputIt , typename UIntPtr >
OutputIt	detail::write_ptr (OutputIt out, UIntPtr value, const basic_format_specs< Char > *specs)
template<typename Char , typename OutputIt >
OutputIt	detail::write (OutputIt out, monostate)
template<typename Char , typename OutputIt , FMT_ENABLE_IF(!std::is_same< Char, char >::value) >
OutputIt	detail::write (OutputIt out, string_view value)
template<typename Char , typename OutputIt >
OutputIt	detail::write (OutputIt out, basic_string_view< Char > value)
template<typename Char >
buffer_appender< Char >	detail::write (buffer_appender< Char > out, basic_string_view< Char > value)
template<typename Char , typename OutputIt >
OutputIt	detail::write (OutputIt out, bool value)
template<typename Char , typename OutputIt >
OutputIt	detail::write (OutputIt out, Char value)
template<typename Char , typename OutputIt >
OutputIt	detail::write (OutputIt out, const Char *value)
template<typename Char , typename OutputIt >
OutputIt	detail::write (OutputIt out, const void *value)
template<typename Char , typename OutputIt , typename T >
auto	detail::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	detail::is_name_start (Char c)
template<typename Char , typename ErrorHandler >
FMT_CONSTEXPR int	detail::parse_nonnegative_int (const Char *&begin, const Char *end, ErrorHandler &&eh)
template<template< typename > class Handler, typename FormatArg , typename ErrorHandler >
FMT_CONSTEXPR int	detail::get_dynamic_spec (FormatArg arg, ErrorHandler eh)
template<typename Context , typename ID >
FMT_CONSTEXPR Context::format_arg	detail::get_arg (Context &ctx, ID id)
template<typename Char , typename IDHandler >
FMT_CONSTEXPR const Char *	detail::parse_arg_id (const Char *begin, const Char *end, IDHandler &&handler)
template<typename Char >
FMT_CONSTEXPR int	detail::code_point_length (const Char *begin)
template<typename Char >
constexpr bool	detail::is_ascii_letter (Char c)
template<typename Char , FMT_ENABLE_IF(std::is_integral< Char >::value) >
constexpr Char	detail::to_ascii (Char value)
template<typename Char , FMT_ENABLE_IF(std::is_enum< Char >::value) >
constexpr std::underlying_type < Char >::type	detail::to_ascii (Char value)
template<typename Char , typename Handler >
FMT_CONSTEXPR const Char *	detail::parse_align (const Char *begin, const Char *end, Handler &&handler)
template<typename Char , typename Handler >
FMT_CONSTEXPR const Char *	detail::parse_width (const Char *begin, const Char *end, Handler &&handler)
template<typename Char , typename Handler >
FMT_CONSTEXPR const Char *	detail::parse_precision (const Char *begin, const Char *end, Handler &&handler)
template<typename Char , typename SpecHandler >
FMT_CONSTEXPR const Char *	detail::parse_format_specs (const Char *begin, const Char *end, SpecHandler &&handler)
template<bool IS_CONSTEXPR, typename T , typename Ptr = const T*>
FMT_CONSTEXPR bool	detail::find (Ptr first, Ptr last, T value, Ptr &out)
template<>
bool	detail::find< false, char > (const char *first, const char *last, char value, const char *&out)
template<typename Char , typename Handler >
FMT_CONSTEXPR const Char *	detail::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	detail::parse_format_string (basic_string_view< Char > format_str, Handler &&handler)
template<typename T , typename ParseContext >
FMT_CONSTEXPR const ParseContext::char_type *	detail::parse_format_specs (ParseContext &ctx)
template<typename Char , size_t N>
FMT_CONSTEXPR basic_string_view< Char >	detail::compile_string_to_view (const Char(&s)[N])
template<typename Char >
FMT_CONSTEXPR basic_string_view< Char >	detail::compile_string_to_view (const std_string_view< Char > &s)
template<typename... , typename S , FMT_ENABLE_IF(is_compile_string< S >::value) >
void	detail::check_format_string (S)
template<template< typename > class Handler, typename Context >
void	detail::handle_dynamic_spec (int &value, arg_ref< typename Context::char_type > ref, Context &ctx)
FMT_FUNC void	detail::format_error_code (detail::buffer< char > &out, int error_code, string_view message) FMT_NOEXCEPT
FMT_FUNC void	detail::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	detail::grouping_impl< char > (locale_ref loc)
template FMT_API std::string	detail::grouping_impl< wchar_t > (locale_ref loc)
template FMT_API char	detail::thousands_sep_impl< char > (locale_ref loc)
template FMT_API wchar_t	detail::thousands_sep_impl< wchar_t > (locale_ref loc)
template<typename Char >
FMT_FUNC Char	detail::decimal_point_impl (locale_ref loc)
template int	detail::format_float< double > (double value, int precision, float_specs specs, buffer< char > &buf)
template int	detail::format_float< long double > (long double value, int precision, float_specs specs, buffer< char > &buf)
int	detail::snprintf_float (float value, int precision, float_specs specs, buffer< char > &buf)=delete
template int	detail::snprintf_float< double > (double value, int precision, float_specs specs, buffer< char > &buf)
template int	detail::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	detail::basic_data< void >

Macro Definition Documentation

#define FMT_ALWAYS_INLINE   inline

Definition at line 977 of file format.h.

#define FMT_CATCH

(

x

)

catch (x)

Definition at line 126 of file format.h.

#define FMT_CUDA_VERSION   0

Definition at line 57 of file format.h.

#define FMT_DEPRECATED_NUMERIC_ALIGN   0

Definition at line 272 of file format.h.

#define FMT_FALLTHROUGH

Definition at line 87 of file format.h.

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

#define FMT_FUNC

Definition at line 3957 of file format.h.

#define FMT_HAS_BUILTIN

(

x

)

0

Definition at line 63 of file format.h.

#define FMT_ICC_VERSION   0

Definition at line 51 of file format.h.

#define FMT_MAYBE_UNUSED

Definition at line 94 of file format.h.

#define FMT_NOINLINE

Definition at line 69 of file format.h.

#define FMT_REDUCE_INT_INSTANTIATIONS   0

Definition at line 174 of file format.h.

#define FMT_SAFEBUFFERS

Definition at line 984 of file format.h.

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

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

#define FMT_THROW

(

x

)

throw x

Definition at line 113 of file format.h.

#define FMT_TRY   try

Definition at line 125 of file format.h.

#define FMT_USE_DOUBLE   1

Definition at line 162 of file format.h.

#define FMT_USE_FLOAT   1

Definition at line 158 of file format.h.

#define FMT_USE_FULL_CACHE_DRAGONBOX   0

Definition at line 595 of file format.h.

#define FMT_USE_LONG_DOUBLE   1

Definition at line 166 of file format.h.

#define FMT_USE_UDL_TEMPLATE   0

Definition at line 153 of file format.h.

#define FMT_USE_USER_DEFINED_LITERALS   0

Definition at line 139 of file format.h.

Typedef Documentation

using align_t = align::type

Definition at line 1177 of file format.h.

using FMT_DEPRECATED_ALIAS = basic_format_args<buffer_context<Char>>

Definition at line 3260 of file format.h.

template<typename OutputIt , typename Char = char>

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

Definition at line 3829 of file format.h.

template<typename OutputIt , typename Char = char>

using format_context_t = basic_format_context<OutputIt, Char>

Definition at line 3826 of file format.h.

using format_specs = basic_format_specs<char>

Definition at line 1203 of file format.h.

using memory_buffer = basic_memory_buffer<char>

Definition at line 761 of file format.h.

using sign_t = sign::type

Definition at line 1182 of file format.h.

using wmemory_buffer = basic_memory_buffer<wchar_t>

Definition at line 762 of file format.h.

Enumeration Type Documentation

anonymous enum

Enumerator
inline_buffer_size

Definition at line 621 of file format.h.

Function Documentation

template<typename Char , typename ErrorHandler >

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

Definition at line 3589 of file format.h.

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

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.

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  )

inline

Definition at line 3818 of file format.h.

template<typename It , typename Sentinel >

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.

template<typename It , typename Sentinel >

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

Definition at line 3686 of file format.h.

template<typename Range >

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.

template<typename Range >

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.

template<typename OutputIt , typename Char , typename... 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.

template<typename T >

const void* ptr ( const T *  p )

inline

Converts p to const void* for pointer formatting.

Example**::

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

Examples:

standalone/tiledevice.C.

Definition at line 3603 of file format.h.

template<typename T >

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

inline

Definition at line 3604 of file format.h.

template<typename T >

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

inline

Definition at line 3607 of file format.h.

FMT_API void report_system_error	(	int	error_code,
		string_view	message
	)

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

std::string to_string ( const T &  value )

inline

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.

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

std::string to_string ( T  value )

inline

Definition at line 3737 of file format.h.

template<typename Char , size_t SIZE>

std::basic_string<Char> to_string

(

const basic_memory_buffer< Char, SIZE > &

buf

)

Definition at line 3754 of file format.h.

template<typename T >

std::wstring to_wstring ( const T &  value )

inline

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

Definition at line 3749 of file format.h.

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  )

inline

Definition at line 3810 of file format.h.

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
	)

Definition at line 3854 of file format.h.

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

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

Definition at line 3864 of file format.h.