#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <limits>
#include <memory>
#include <stdexcept>
#include <string>
#include <vector>
#include <utility>
#include <ostream>
#include <stdint.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	fmt::internal::DummyInt

class	std::numeric_limits< fmt::internal::DummyInt >

class	fmt::BasicWriter< Char >

class	fmt::BasicFormatter< CharType >

class	fmt::BasicStringRef< Char >

class	fmt::BasicCStringRef< Char >

class	fmt::FormatError

struct	fmt::internal::MakeUnsigned< T >

class	fmt::Buffer< T >

class	fmt::internal::MemoryBuffer< T, SIZE, Allocator >

class	fmt::internal::FixedBuffer< Char >

class	fmt::internal::BasicCharTraits< Char >

singleton	fmt::internal::CharTraits< Char >

class	fmt::internal::CharTraits< char >

class	fmt::internal::CharTraits< wchar_t >

struct	fmt::internal::SignChecker< IsSigned >

struct	fmt::internal::SignChecker< false >

struct	fmt::internal::TypeSelector< FitsIn32Bits >

struct	fmt::internal::TypeSelector< false >

struct	fmt::internal::IntTraits< T >

struct	fmt::internal::BasicData< T >

struct	fmt::internal::Value

struct	fmt::internal::Value::StringValue< Char >

struct	fmt::internal::Value::CustomValue

struct	fmt::internal::Arg

struct	fmt::internal::NamedArg< Char >

struct	fmt::internal::Null< T >

struct	fmt::internal::WCharHelper< T, Char >

struct	fmt::internal::WCharHelper< T, wchar_t >

struct	fmt::internal::DummyStream

struct	fmt::internal::ConvertToIntImpl< T, ENABLE_CONVERSION >

struct	fmt::internal::ConvertToIntImpl< T, true >

struct	fmt::internal::ConvertToIntImpl2< T, ENABLE_CONVERSION >

struct	fmt::internal::ConvertToIntImpl2< T, true >

struct	fmt::internal::ConvertToInt< T >

struct	fmt::internal::EnableIf< B, T >

struct	fmt::internal::EnableIf< true, T >

struct	fmt::internal::Conditional< B, T, F >

struct	fmt::internal::Conditional< false, T, F >

struct	fmt::internal::Not< bool >

struct	fmt::internal::Not< false >

class	fmt::internal::MakeValue< Formatter >

class	fmt::internal::MakeArg< Formatter >

struct	fmt::internal::NamedArg< Char >

class	fmt::internal::ArgVisitor< Impl, Result >

class	fmt::internal::RuntimeError

singleton	fmt::internal::PrintfArgFormatter< Char >

class	fmt::internal::ArgMap< Char >

class	fmt::ArgList

struct	fmt::EmptySpec

struct	fmt::TypeSpec< TYPE >

struct	fmt::WidthSpec

struct	fmt::AlignSpec

struct	fmt::AlignTypeSpec< TYPE >

struct	fmt::FormatSpec

class	fmt::IntFormatSpec< T, SpecT, Char >

class	fmt::StrFormatSpec< Char >

class	fmt::internal::ArgMap< Char >

class	fmt::internal::ArgFormatterBase< Impl, Char >

class	fmt::internal::BasicArgFormatter< Char >

class	fmt::internal::FormatterBase

class	fmt::internal::PrintfFormatter< Char >

class	fmt::BasicFormatter< CharType >

struct	fmt::internal::ArgArray< N, bool >

struct	fmt::internal::ArgArray< N, true >

struct	fmt::internal::ArgArray< N, false >

struct	fmt::internal::ArgType

class	fmt::internal::FormatBuf< Char >

class	fmt::SystemError

class	fmt::BasicWriter< Char >

class	fmt::BasicMemoryWriter< Char, Allocator >

class	fmt::BasicArrayWriter< Char >

class	fmt::FormatInt

Namespaces
	fmt

	fmt::internal

Macros
#define	FMT_USE_IOSTREAMS 1

#define	FMT_SECURE_SCL 0

#define	FMT_API

#define	FMT_GCC_EXTENSION

#define	FMT_HAS_FEATURE(x) 0

#define	FMT_HAS_BUILTIN(x) 0

#define	FMT_HAS_CPP_ATTRIBUTE(x) 0

#define	FMT_USE_VARIADIC_TEMPLATES

#define	FMT_USE_RVALUE_REFERENCES

#define	FMT_EXCEPTIONS 1

#define	FMT_THROW(x) throw x

#define	FMT_USE_NOEXCEPT 0

#define	FMT_NOEXCEPT throw()

#define	FMT_USE_DELETED_FUNCTIONS 0

#define	FMT_DELETED_OR_UNDEFINED

#define	FMT_DISALLOW_COPY_AND_ASSIGN(TypeName)

#define	FMT_USE_USER_DEFINED_LITERALS

#define	FMT_ASSERT(condition, message) assert((condition) && message)

#define	FMT_SPECIALIZE_MAKE_UNSIGNED(T, U)

#define	FMT_USE_WINDOWS_H 0

#define	FMT_DISABLE_CONVERSION_TO_INT(Type)

#define	FMT_MAKE_VALUE_(Type, field, TYPE, rhs)

#define	FMT_MAKE_VALUE(Type, field, TYPE) FMT_MAKE_VALUE_(Type, field, TYPE, value)

#define	FMT_MAKE_STR_VALUE(Type, TYPE)

#define	FMT_MAKE_WSTR_VALUE(Type, TYPE)

#define	FMT_DISPATCH(call) static_cast<Impl*>(this)->call

#define	FMT_DEFINE_INT_FORMATTERS(TYPE)

#define	FMT_GEN(n, f) FMT_GEN##n(f)

#define	FMT_GEN1(f) f(0)

#define	FMT_GEN2(f) FMT_GEN1(f), f(1)

#define	FMT_GEN3(f) FMT_GEN2(f), f(2)

#define	FMT_GEN4(f) FMT_GEN3(f), f(3)

#define	FMT_GEN5(f) FMT_GEN4(f), f(4)

#define	FMT_GEN6(f) FMT_GEN5(f), f(5)

#define	FMT_GEN7(f) FMT_GEN6(f), f(6)

#define	FMT_GEN8(f) FMT_GEN7(f), f(7)

#define	FMT_GEN9(f) FMT_GEN8(f), f(8)

#define	FMT_GEN10(f) FMT_GEN9(f), f(9)

#define	FMT_GEN11(f) FMT_GEN10(f), f(10)

#define	FMT_GEN12(f) FMT_GEN11(f), f(11)

#define	FMT_GEN13(f) FMT_GEN12(f), f(12)

#define	FMT_GEN14(f) FMT_GEN13(f), f(13)

#define	FMT_GEN15(f) FMT_GEN14(f), f(14)

#define	FMT_ARG_TYPE_DEFAULT(n) ArgType t##n = ArgType()

#define	FMT_MAKE_TEMPLATE_ARG(n) typename T##n

#define	FMT_MAKE_ARG_TYPE(n) T##n

#define	FMT_MAKE_ARG(n) const T##n &v##n

#define	FMT_ASSIGN_char(n) arr[n] = fmt::internal::MakeValue< fmt::BasicFormatter<char> >(v##n)

#define	FMT_ASSIGN_wchar_t(n) arr[n] = fmt::internal::MakeValue< fmt::BasicFormatter<wchar_t> >(v##n)

#define	FMT_MAKE_REF(n) fmt::internal::MakeValue< fmt::BasicFormatter<Char> >(v##n)

#define	FMT_MAKE_REF2(n) v##n

#define	FMT_WRAP1(func, arg_type, n)

#define	FMT_VARIADIC_VOID(func, arg_type)

#define	FMT_CTOR(ctor, func, arg0_type, arg1_type, n)

#define	FMT_VARIADIC_CTOR(ctor, func, arg0_type, arg1_type)

#define	FMT_FOR_EACH1(f, x0) f(x0, 0)

#define	FMT_FOR_EACH2(f, x0, x1) FMT_FOR_EACH1(f, x0), f(x1, 1)

#define	FMT_FOR_EACH3(f, x0, x1, x2) FMT_FOR_EACH2(f, x0 ,x1), f(x2, 2)

#define	FMT_FOR_EACH4(f, x0, x1, x2, x3) FMT_FOR_EACH3(f, x0, x1, x2), f(x3, 3)

#define	FMT_FOR_EACH5(f, x0, x1, x2, x3, x4) FMT_FOR_EACH4(f, x0, x1, x2, x3), f(x4, 4)

#define	FMT_FOR_EACH6(f, x0, x1, x2, x3, x4, x5) FMT_FOR_EACH5(f, x0, x1, x2, x3, x4), f(x5, 5)

#define	FMT_FOR_EACH7(f, x0, x1, x2, x3, x4, x5, x6) FMT_FOR_EACH6(f, x0, x1, x2, x3, x4, x5), f(x6, 6)

#define	FMT_FOR_EACH8(f, x0, x1, x2, x3, x4, x5, x6, x7) FMT_FOR_EACH7(f, x0, x1, x2, x3, x4, x5, x6), f(x7, 7)

#define	FMT_FOR_EACH9(f, x0, x1, x2, x3, x4, x5, x6, x7, x8) FMT_FOR_EACH8(f, x0, x1, x2, x3, x4, x5, x6, x7), f(x8, 8)

#define	FMT_FOR_EACH10(f, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) FMT_FOR_EACH9(f, x0, x1, x2, x3, x4, x5, x6, x7, x8), f(x9, 9)

#define	FMT_EXPAND(args) args

#define	FMT_NARG(...) FMT_NARG_(__VA_ARGS__, FMT_RSEQ_N())

#define	FMT_NARG_(...) FMT_EXPAND(FMT_ARG_N(__VA_ARGS__))

#define	FMT_ARG_N(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N,...) N

#define	FMT_RSEQ_N() 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0

#define	FMT_CONCAT(a, b) a##b

#define	FMT_FOR_EACH_(N, f,...) FMT_EXPAND(FMT_CONCAT(FMT_FOR_EACH, N)(f, __VA_ARGS__))

#define	FMT_FOR_EACH(f,...) FMT_EXPAND(FMT_FOR_EACH_(FMT_NARG(__VA_ARGS__), f, __VA_ARGS__))

#define	FMT_ADD_ARG_NAME(type, index) type arg##index

#define	FMT_GET_ARG_NAME(type, index) arg##index

#define	FMT_WRAP(Char, ReturnType, func, call, n,...)

#define	FMT_VARIADIC_(Char, ReturnType, func, call,...)

#define	FMT_VARIADIC(ReturnType, func,...) FMT_VARIADIC_(char, ReturnType, func, return func, __VA_ARGS__)

#define	FMT_VARIADIC_W(ReturnType, func,...) FMT_VARIADIC_(wchar_t, ReturnType, func, return func, __VA_ARGS__)

#define	FMT_CAPTURE_ARG_(id, index) ::fmt::arg(#id, id)

#define	FMT_CAPTURE_ARG_W_(id, index) ::fmt::arg(L###id, id)

#define	FMT_CAPTURE(...) FMT_FOR_EACH(FMT_CAPTURE_ARG_, __VA_ARGS__)

#define	FMT_CAPTURE_W(...) FMT_FOR_EACH(FMT_CAPTURE_ARG_W_, __VA_ARGS__)

Typedefs
typedef std::numeric_limits < fmt::internal::DummyInt >	fmt::internal::FPUtil

typedef BasicWriter< char >	fmt::Writer

typedef BasicWriter< wchar_t >	fmt::WWriter

typedef BasicStringRef< char >	fmt::StringRef

typedef BasicStringRef< wchar_t >	fmt::WStringRef

typedef BasicCStringRef< char >	fmt::CStringRef

typedef BasicCStringRef< wchar_t >	fmt::WCStringRef

typedef BasicData	fmt::internal::Data

typedef char	fmt::internal::Yes [1]

typedef char	fmt::internal::No [2]

typedef BasicMemoryWriter< char >	fmt::MemoryWriter

typedef BasicMemoryWriter < wchar_t >	fmt::WMemoryWriter

typedef BasicArrayWriter< char >	fmt::ArrayWriter

typedef BasicArrayWriter< wchar_t >	fmt::WArrayWriter

Enumerations
enum	{ fmt::internal::INLINE_BUFFER_SIZE = 500 }

enum	fmt::Alignment { fmt::ALIGN_DEFAULT, fmt::ALIGN_LEFT, fmt::ALIGN_RIGHT, fmt::ALIGN_CENTER, fmt::ALIGN_NUMERIC }

enum	{ fmt::SIGN_FLAG = 1, fmt::PLUS_FLAG = 2, fmt::MINUS_FLAG = 4, fmt::HASH_FLAG = 8, fmt::CHAR_FLAG = 0x10 }

enum	fmt::Color { fmt::BLACK, fmt::RED, fmt::GREEN, fmt::YELLOW, fmt::BLUE, fmt::MAGENTA, fmt::CYAN, fmt::WHITE }

Functions
DummyInt	fmt::internal::signbit (...)

DummyInt	fmt::internal::_ecvt_s (...)

DummyInt	fmt::internal::isinf (...)

DummyInt	fmt::internal::_finite (...)

DummyInt	fmt::internal::isnan (...)

DummyInt	fmt::internal::_isnan (...)

template<typename T >
T	fmt::internal::check (T value)

template<typename Char , typename T >
void	fmt::format (BasicFormatter< Char > &f, const Char *&format_str, const T &value)

	fmt::internal::FMT_SPECIALIZE_MAKE_UNSIGNED (char, unsigned char)

	fmt::internal::FMT_SPECIALIZE_MAKE_UNSIGNED (signed char, unsigned char)

	fmt::internal::FMT_SPECIALIZE_MAKE_UNSIGNED (short, unsigned short)

	fmt::internal::FMT_SPECIALIZE_MAKE_UNSIGNED (int, unsigned)

	fmt::internal::FMT_SPECIALIZE_MAKE_UNSIGNED (long, unsigned long)

	fmt::internal::FMT_SPECIALIZE_MAKE_UNSIGNED (LongLong, ULongLong)

template<typename Int >
MakeUnsigned< Int >::Type	fmt::internal::to_unsigned (Int value)

template<typename T >
T *	fmt::internal::make_ptr (T *ptr, std::size_t)

template<typename T >
bool	fmt::internal::is_negative (T value)

FMT_API void	fmt::internal::report_unknown_type (char code, const char *type)

unsigned	fmt::internal::count_digits (uint64_t n)

template<typename UInt , typename Char >
void	fmt::internal::format_decimal (Char *buffer, UInt value, unsigned num_digits)

FMT_API void	fmt::internal::format_system_error (fmt::Writer &out, int error_code, fmt::StringRef message) FMT_NOEXCEPT

Yes &	fmt::internal::convert (fmt::ULongLong)

Yes &	fmt::internal::convert (std::ostream &)

No &	fmt::internal::convert (...)

template<typename T >
T &	fmt::internal::get ()

No &	fmt::internal::operator<< (std::ostream &, int)

	fmt::internal::FMT_DISABLE_CONVERSION_TO_INT (float)

	fmt::internal::FMT_DISABLE_CONVERSION_TO_INT (double)

	fmt::internal::FMT_DISABLE_CONVERSION_TO_INT (long double)

IntFormatSpec< int, TypeSpec<'b'> >	fmt::bin (int value)

IntFormatSpec< int, TypeSpec<'o'> >	fmt::oct (int value)

IntFormatSpec< int, TypeSpec<'x'> >	fmt::hex (int value)

IntFormatSpec< int, TypeSpec<'X'> >	fmt::hexu (int value)

template<char TYPE_CODE, typename Char >
IntFormatSpec< int, AlignTypeSpec< TYPE_CODE > , Char >	fmt::pad (int value, unsigned width, Char fill= ' ')

template<typename Char >
StrFormatSpec< Char >	fmt::pad (const Char *str, unsigned width, Char fill= ' ')

StrFormatSpec< wchar_t >	fmt::pad (const wchar_t *str, unsigned width, char fill= ' ')

uint64_t	fmt::internal::make_type ()

template<typename T >
uint64_t	fmt::internal::make_type (const T &arg)

uint64_t	fmt::internal::make_type (FMT_GEN15(FMT_ARG_TYPE_DEFAULT))

FMT_API void	fmt::report_system_error (int error_code, StringRef message) FMT_NOEXCEPT

FMT_API void	fmt::print_colored (Color c, CStringRef format, ArgList args)

std::string	fmt::format (CStringRef format_str, ArgList args)

std::wstring	fmt::format (WCStringRef format_str, ArgList args)

FMT_API void	fmt::print (std::FILE *f, CStringRef format_str, ArgList args)

FMT_API void	fmt::print (CStringRef format_str, ArgList args)

template<typename Char >
void	fmt::printf (BasicWriter< Char > &w, BasicCStringRef< Char > format, ArgList args)

std::string	fmt::sprintf (CStringRef format, ArgList args)

std::wstring	fmt::sprintf (WCStringRef format, ArgList args)

FMT_API int	fmt::fprintf (std::FILE *f, CStringRef format, ArgList args)

int	fmt::printf (CStringRef format, ArgList args)

template<typename T >
void	fmt::format_decimal (char *&buffer, T value)

template<typename T >
internal::NamedArg< char >	fmt::arg (StringRef name, const T &arg)

template<typename T >
internal::NamedArg< wchar_t >	fmt::arg (WStringRef name, const T &arg)

template<typename Char >
void	fmt::arg (StringRef, const internal::NamedArg< Char > &) FMT_DELETED_OR_UNDEFINED

template<typename Char >
void	fmt::arg (WStringRef, const internal::NamedArg< Char > &) FMT_DELETED_OR_UNDEFINED

FMT_API void	fmt::print (std::ostream &os, CStringRef format_str, ArgList args)

FMT_API int	fmt::fprintf (std::ostream &os, CStringRef format_str, ArgList args)

template<typename Char >
bool	fmt::internal::is_name_start (Char c)

template<typename Char >
unsigned	fmt::internal::parse_nonnegative_int (const Char *&s)

void	fmt::internal::require_numeric_argument (const Arg &arg, char spec)

template<typename Char >
void	fmt::internal::check_sign (const Char *&s, const Arg &arg)

Variables
FMT_GCC_EXTENSION typedef long long	fmt::LongLong

FMT_GCC_EXTENSION typedef unsigned long long	fmt::ULongLong

Macro Definition Documentation

#define FMT_ADD_ARG_NAME	(	type,
		index
	)	type arg##index

#define FMT_API

#define FMT_ARG_N	(	_1,
		_2,
		_3,
		_4,
		_5,
		_6,
		_7,
		_8,
		_9,
		_10,
		N,
		...
	)	N

#define FMT_ARG_TYPE_DEFAULT ( n ) ArgType t##n = ArgType()

#define FMT_ASSERT	(	condition,
		message
	)	assert((condition) && message)

#define FMT_ASSIGN_char ( n ) arr[n] = fmt::internal::MakeValue< fmt::BasicFormatter<char> >(v##n)

#define FMT_ASSIGN_wchar_t ( n ) arr[n] = fmt::internal::MakeValue< fmt::BasicFormatter<wchar_t> >(v##n)

#define FMT_CAPTURE ( ... ) FMT_FOR_EACH(FMT_CAPTURE_ARG_, __VA_ARGS__)

Convenient macro to capture the arguments' names and values into several fmt::arg(name, value).

Example**::

int x = 1, y = 2; print("point: ({x}, {y})", FMT_CAPTURE(x, y)); same as: print("point: ({x}, {y})", arg("x", x), arg("y", y));

#define FMT_CAPTURE_ARG_	(	id,
		index
	)	::fmt::arg(#id, id)

#define FMT_CAPTURE_ARG_W_	(	id,
		index
	)	::fmt::arg(L###id, id)

#define FMT_CAPTURE_W ( ... ) FMT_FOR_EACH(FMT_CAPTURE_ARG_W_, __VA_ARGS__)

#define FMT_CONCAT	(	a,
		b
	)	a##b

#define FMT_CTOR	(	ctor,
		func,
		arg0_type,
		arg1_type,
		n
	)

Value:

template <FMT_GEN(n, FMT_MAKE_TEMPLATE_ARG)> \
 ctor(arg0_type arg0, arg1_type arg1, FMT_GEN(n, FMT_MAKE_ARG)) { \
 const fmt::internal::ArgArray<n>::Type array = {FMT_GEN(n, FMT_MAKE_REF)}; \
 func(arg0, arg1, fmt::ArgList( \
 fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), array)); \
 }

#define FMT_DEFINE_INT_FORMATTERS ( TYPE )

#define FMT_DELETED_OR_UNDEFINED

#define FMT_DISABLE_CONVERSION_TO_INT ( Type )

Value:

template <> \

struct ConvertToInt<Type> { enum { value = 0 }; }

fmt::internal::ConvertToInt

Definition: format.h:1053

google::protobuf::value

const FieldDescriptor value

Definition: descriptor.h:1522

#define FMT_DISALLOW_COPY_AND_ASSIGN ( TypeName )

Value:

TypeName(const TypeName&); \

TypeName& operator=(const TypeName&)

G3D::operator=

Vector2int16 & operator=(const Any &a)

#define FMT_DISPATCH ( call ) static_cast<Impl*>(this)->call

#define FMT_EXCEPTIONS 1

#define FMT_EXPAND ( args ) args

#define FMT_FOR_EACH	(	f,
		...
	)	FMT_EXPAND(FMT_FOR_EACH_(FMT_NARG(__VA_ARGS__), f, __VA_ARGS__))

#define FMT_FOR_EACH1	(	f,
		x0
	)	f(x0, 0)

#define FMT_FOR_EACH10	(	f,
		x0,
		x1,
		x2,
		x3,
		x4,
		x5,
		x6,
		x7,
		x8,
		x9
	)	FMT_FOR_EACH9(f, x0, x1, x2, x3, x4, x5, x6, x7, x8), f(x9, 9)

#define FMT_FOR_EACH2	(	f,
		x0,
		x1
	)	FMT_FOR_EACH1(f, x0), f(x1, 1)

#define FMT_FOR_EACH3	(	f,
		x0,
		x1,
		x2
	)	FMT_FOR_EACH2(f, x0 ,x1), f(x2, 2)

#define FMT_FOR_EACH4	(	f,
		x0,
		x1,
		x2,
		x3
	)	FMT_FOR_EACH3(f, x0, x1, x2), f(x3, 3)

#define FMT_FOR_EACH5	(	f,
		x0,
		x1,
		x2,
		x3,
		x4
	)	FMT_FOR_EACH4(f, x0, x1, x2, x3), f(x4, 4)

#define FMT_FOR_EACH6	(	f,
		x0,
		x1,
		x2,
		x3,
		x4,
		x5
	)	FMT_FOR_EACH5(f, x0, x1, x2, x3, x4), f(x5, 5)

#define FMT_FOR_EACH7	(	f,
		x0,
		x1,
		x2,
		x3,
		x4,
		x5,
		x6
	)	FMT_FOR_EACH6(f, x0, x1, x2, x3, x4, x5), f(x6, 6)

#define FMT_FOR_EACH8	(	f,
		x0,
		x1,
		x2,
		x3,
		x4,
		x5,
		x6,
		x7
	)	FMT_FOR_EACH7(f, x0, x1, x2, x3, x4, x5, x6), f(x7, 7)

#define FMT_FOR_EACH9	(	f,
		x0,
		x1,
		x2,
		x3,
		x4,
		x5,
		x6,
		x7,
		x8
	)	FMT_FOR_EACH8(f, x0, x1, x2, x3, x4, x5, x6, x7), f(x8, 8)

#define FMT_FOR_EACH_	(	N,
		f,
		...
	)	FMT_EXPAND(FMT_CONCAT(FMT_FOR_EACH, N)(f, __VA_ARGS__))

#define FMT_GCC_EXTENSION

#define FMT_GEN	(	n,
		f
	)	FMT_GEN##n(f)

#define FMT_GEN1 ( f ) f(0)

#define FMT_GEN10 ( f ) FMT_GEN9(f), f(9)

#define FMT_GEN11 ( f ) FMT_GEN10(f), f(10)

#define FMT_GEN12 ( f ) FMT_GEN11(f), f(11)

#define FMT_GEN13 ( f ) FMT_GEN12(f), f(12)

#define FMT_GEN14 ( f ) FMT_GEN13(f), f(13)

#define FMT_GEN15 ( f ) FMT_GEN14(f), f(14)

#define FMT_GEN2 ( f ) FMT_GEN1(f), f(1)

#define FMT_GEN3 ( f ) FMT_GEN2(f), f(2)

#define FMT_GEN4 ( f ) FMT_GEN3(f), f(3)

#define FMT_GEN5 ( f ) FMT_GEN4(f), f(4)

#define FMT_GEN6 ( f ) FMT_GEN5(f), f(5)

#define FMT_GEN7 ( f ) FMT_GEN6(f), f(6)

#define FMT_GEN8 ( f ) FMT_GEN7(f), f(7)

#define FMT_GEN9 ( f ) FMT_GEN8(f), f(8)

#define FMT_GET_ARG_NAME	(	type,
		index
	)	arg##index

#define FMT_HAS_BUILTIN ( x ) 0

#define FMT_HAS_CPP_ATTRIBUTE ( x ) 0

#define FMT_HAS_FEATURE ( x ) 0

#define FMT_MAKE_ARG ( n ) const T##n &v##n

#define FMT_MAKE_ARG_TYPE ( n ) T##n

#define FMT_MAKE_REF ( n ) fmt::internal::MakeValue< fmt::BasicFormatter<Char> >(v##n)

#define FMT_MAKE_REF2 ( n ) v##n

#define FMT_MAKE_STR_VALUE	(	Type,
		TYPE
	)

Value:

MakeValue(Type value) { set_string(value); } \

static uint64_t type(Type) { return Arg::TYPE; }

TYPE

Definition: inflate.h:32

uint64_t

unsigned __int64 uint64_t

Definition: stdint.h:90

google::protobuf::value

const FieldDescriptor value

Definition: descriptor.h:1522

Type

Type of JSON value.

Definition: rapidjson.h:642

fmt::internal::MakeValue

Definition: format.h:1088

#define FMT_MAKE_TEMPLATE_ARG ( n ) typename T##n

#define FMT_MAKE_VALUE	(	Type,
		field,
		TYPE
	)	FMT_MAKE_VALUE_(Type, field, TYPE, value)

#define FMT_MAKE_VALUE_	(	Type,
		field,
		TYPE,
		rhs
	)

Value:

MakeValue(Type value) { field = rhs; } \

static uint64_t type(Type) { return Arg::TYPE; }

TYPE

Definition: inflate.h:32

uint64_t

unsigned __int64 uint64_t

Definition: stdint.h:90

google::protobuf::value

const FieldDescriptor value

Definition: descriptor.h:1522

Type

Type of JSON value.

Definition: rapidjson.h:642

fmt::internal::MakeValue

Definition: format.h:1088

#define FMT_MAKE_WSTR_VALUE	(	Type,
		TYPE
	)

Value:

MakeValue(typename WCharHelper<Type, Char>::Supported value) { \
 set_string(value); \
 } \
 static uint64_t type(Type) { return Arg::TYPE; }

#define FMT_NARG ( ... ) FMT_NARG_(__VA_ARGS__, FMT_RSEQ_N())

#define FMT_NARG_ ( ... ) FMT_EXPAND(FMT_ARG_N(__VA_ARGS__))

#define FMT_NOEXCEPT throw()

#define FMT_RSEQ_N ( ) 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0

#define FMT_SECURE_SCL 0

#define FMT_SPECIALIZE_MAKE_UNSIGNED	(	T,
		U
	)

Value:

template <> \

struct MakeUnsigned<T> { typedef U Type; }

fmt::internal::MakeUnsigned

Definition: format.h:539

Type

Type of JSON value.

Definition: rapidjson.h:642

#define FMT_THROW ( x ) throw x

#define FMT_USE_DELETED_FUNCTIONS 0

#define FMT_USE_IOSTREAMS 1

#define FMT_USE_NOEXCEPT 0

#define FMT_USE_RVALUE_REFERENCES

Value:

(FMT_HAS_FEATURE(cxx_rvalue_references) || \

(FMT_GCC_VERSION >= 403 && FMT_HAS_GXX_CXX11) || _MSC_VER >= 1600)

FMT_HAS_FEATURE

#define FMT_HAS_FEATURE(x)

Definition: format.h:113

#define FMT_USE_USER_DEFINED_LITERALS

Value:

FMT_USE_VARIADIC_TEMPLATES && FMT_USE_RVALUE_REFERENCES && \
 (FMT_HAS_FEATURE(cxx_user_literals) || \
 (FMT_GCC_VERSION >= 407 && FMT_HAS_GXX_CXX11) || _MSC_VER >= 1900)

#define FMT_USE_VARIADIC_TEMPLATES

Value:

(FMT_HAS_FEATURE(cxx_variadic_templates) || \

(FMT_GCC_VERSION >= 404 && FMT_HAS_GXX_CXX11) || _MSC_VER >= 1800)

FMT_HAS_FEATURE

#define FMT_HAS_FEATURE(x)

Definition: format.h:113

#define FMT_USE_WINDOWS_H 0

#define FMT_VARIADIC	(	ReturnType,
		func,
		...
	)	FMT_VARIADIC_(char, ReturnType, func, return func, __VA_ARGS__)

Defines a variadic function with the specified return type, function name and argument types passed as variable arguments to this macro.

Example**::

void print_error(const char *file, int line, const char *format, fmt::ArgList args) { fmt::print("{}: {}: ", file, line); fmt::print(format, args); } FMT_VARIADIC(void, print_error, const char *, int, const char *)

FMT_VARIADIC is used for compatibility with legacy C++ compilers that don't implement variadic templates. You don't have to use this macro if you don't need legacy compiler support and can use variadic templates directly::

template <typename... Args> void print_error(const char *file, int line, const char *format, const Args & ... args) { fmt::print("{}: {}: ", file, line); fmt::print(format, args...); }

#define FMT_VARIADIC_	(	Char,
		ReturnType,
		func,
		call,
		...
	)

Value:

inline ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__)) { \
 call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), fmt::ArgList()); \
 } \
 FMT_WRAP(Char, ReturnType, func, call, 1, __VA_ARGS__) \
 FMT_WRAP(Char, ReturnType, func, call, 2, __VA_ARGS__) \
 FMT_WRAP(Char, ReturnType, func, call, 3, __VA_ARGS__) \
 FMT_WRAP(Char, ReturnType, func, call, 4, __VA_ARGS__) \
 FMT_WRAP(Char, ReturnType, func, call, 5, __VA_ARGS__) \
 FMT_WRAP(Char, ReturnType, func, call, 6, __VA_ARGS__) \
 FMT_WRAP(Char, ReturnType, func, call, 7, __VA_ARGS__) \
 FMT_WRAP(Char, ReturnType, func, call, 8, __VA_ARGS__) \
 FMT_WRAP(Char, ReturnType, func, call, 9, __VA_ARGS__) \
 FMT_WRAP(Char, ReturnType, func, call, 10, __VA_ARGS__) \
 FMT_WRAP(Char, ReturnType, func, call, 11, __VA_ARGS__) \
 FMT_WRAP(Char, ReturnType, func, call, 12, __VA_ARGS__) \
 FMT_WRAP(Char, ReturnType, func, call, 13, __VA_ARGS__) \
 FMT_WRAP(Char, ReturnType, func, call, 14, __VA_ARGS__) \
 FMT_WRAP(Char, ReturnType, func, call, 15, __VA_ARGS__)

#define FMT_VARIADIC_CTOR	(	ctor,
		func,
		arg0_type,
		arg1_type
	)

Value:

FMT_CTOR(ctor, func, arg0_type, arg1_type, 1) \
 FMT_CTOR(ctor, func, arg0_type, arg1_type, 2) \
 FMT_CTOR(ctor, func, arg0_type, arg1_type, 3) \
 FMT_CTOR(ctor, func, arg0_type, arg1_type, 4) \
 FMT_CTOR(ctor, func, arg0_type, arg1_type, 5) \
 FMT_CTOR(ctor, func, arg0_type, arg1_type, 6) \
 FMT_CTOR(ctor, func, arg0_type, arg1_type, 7) \
 FMT_CTOR(ctor, func, arg0_type, arg1_type, 8) \
 FMT_CTOR(ctor, func, arg0_type, arg1_type, 9) \
 FMT_CTOR(ctor, func, arg0_type, arg1_type, 10)

#define FMT_VARIADIC_VOID	(	func,
		arg_type
	)

Value:

inline void func(arg_type arg) { func(arg, fmt::ArgList()); } \
 FMT_WRAP1(func, arg_type, 1) FMT_WRAP1(func, arg_type, 2) \
 FMT_WRAP1(func, arg_type, 3) FMT_WRAP1(func, arg_type, 4) \
 FMT_WRAP1(func, arg_type, 5) FMT_WRAP1(func, arg_type, 6) \
 FMT_WRAP1(func, arg_type, 7) FMT_WRAP1(func, arg_type, 8) \
 FMT_WRAP1(func, arg_type, 9) FMT_WRAP1(func, arg_type, 10)

#define FMT_VARIADIC_W	(	ReturnType,
		func,
		...
	)	FMT_VARIADIC_(wchar_t, ReturnType, func, return func, __VA_ARGS__)

#define FMT_WRAP	(	Char,
		ReturnType,
		func,
		call,
		n,
		...
	)

Value:

template <FMT_GEN(n, FMT_MAKE_TEMPLATE_ARG)> \
 inline ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__), \
 FMT_GEN(n, FMT_MAKE_ARG)) { \
 fmt::internal::ArgArray<n>::Type arr; \
 FMT_GEN(n, FMT_ASSIGN_##Char); \
 call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), fmt::ArgList( \
 fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), arr)); \
 }

#define FMT_WRAP1	(	func,
		arg_type,
		n
	)

Value:

template <FMT_GEN(n, FMT_MAKE_TEMPLATE_ARG)> \
 inline void func(arg_type arg1, FMT_GEN(n, FMT_MAKE_ARG)) { \
 const fmt::internal::ArgArray<n>::Type array = {FMT_GEN(n, FMT_MAKE_REF)}; \
 func(arg1, fmt::ArgList( \
 fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), array)); \
 }

Classes

Namespaces

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation