Rosetta  2020.37
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Classes | Namespaces | Macros | Typedefs | Enumerations | Functions | Variables
format.h File Reference
#include <cassert>
#include <clocale>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <limits>
#include <memory>
#include <stdexcept>
#include <string>
#include <vector>
#include <utility>
#include <stdint.h>

Classes

struct  fmt::internal::DummyInt
 
class  std::numeric_limits< fmt::internal::DummyInt >
 
class  fmt::BasicWriter< Char >
 
class  fmt::ArgFormatter< Char >
 
class  fmt::BasicPrintfArgFormatter< Impl, Char, Spec >
 
class  fmt::BasicFormatter< CharType, ArgFormatter >
 
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 >
 
class  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::NoThousandsSep
 
class  fmt::internal::ThousandsSep
 
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::NamedArgWithType< Char, T >
 
struct  fmt::internal::Null< T >
 
struct  fmt::internal::WCharHelper< T, Char >
 
struct  fmt::internal::WCharHelper< T, wchar_t >
 
struct  fmt::internal::ConvertToIntImpl< T, ENABLE_CONVERSION >
 
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 >
 
struct  fmt::internal::FalseType< T >
 
struct  fmt::internal::LConvCheck< T, T >
 
class  fmt::internal::MakeValue< Formatter >
 
class  fmt::internal::MakeArg< Formatter >
 
struct  fmt::internal::NamedArg< Char >
 
struct  fmt::internal::NamedArgWithType< Char, T >
 
class  fmt::internal::RuntimeError
 
class  fmt::internal::ArgMap< Char >
 
class  fmt::ArgList
 
class  fmt::ArgVisitor< Impl, Result >
 
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, Spec >
 
class  fmt::internal::FormatterBase
 
class  fmt::BasicArgFormatter< Impl, Char, Spec >
 
class  fmt::ArgFormatter< Char >
 
class  fmt::BasicFormatter< CharType, ArgFormatter >
 
struct  fmt::internal::ArgArray< N, bool >
 
struct  fmt::internal::ArgArray< N, true >
 
struct  fmt::internal::ArgArray< N, false >
 
struct  fmt::internal::ArgType
 
class  fmt::SystemError
 
class  fmt::BasicWriter< Char >
 
class  fmt::BasicMemoryWriter< Char, Allocator >
 
class  fmt::BasicArrayWriter< Char >
 
class  fmt::FormatInt
 
struct  fmt::ArgJoin< Char, It >
 

Namespaces

 fmt
 
 fmt::internal
 

Macros

#define FMT_VERSION   30002
 
#define FMT_SECURE_SCL   0
 
#define FMT_MSC_VER   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_DETECTED_NOEXCEPT   throw()
 
#define FMT_NOEXCEPT   FMT_DETECTED_NOEXCEPT
 
#define FMT_DTOR_NOEXCEPT   FMT_NOEXCEPT
 
#define FMT_OVERRIDE
 
#define FMT_NULL   NULL
 
#define FMT_USE_DELETED_FUNCTIONS   0
 
#define FMT_DELETED_OR_UNDEFINED
 
#define FMT_DISALLOW_COPY_AND_ASSIGN(TypeName)
 
#define FMT_USE_DEFAULTED_FUNCTIONS   0
 
#define FMT_DEFAULTED_COPY_CTOR(TypeName)
 
#define FMT_USE_USER_DEFINED_LITERALS
 
#define FMT_USE_EXTERN_TEMPLATES
 
#define FMT_HAS_DECLTYPE_INCOMPLETE_RETURN_TYPES
 
#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_CONCAT(a, b)   a##b
 
#define FMT_UNUSED
 
#define FMT_USE_STATIC_ASSERT   0
 
#define FMT_CONCAT_(a, b)   FMT_CONCAT(a, b)
 
#define FMT_STATIC_ASSERT(cond, message)   typedef int FMT_CONCAT_(Assert, __LINE__)[(cond) ? 1 : -1] FMT_UNUSED
 
#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_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__)
 
#define FMT_FUNC
 

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::const_check (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 >
Tfmt::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 , typename ThousandsSep >
void fmt::internal::format_decimal (Char *buffer, UInt value, unsigned num_digits, ThousandsSep thousands_sep)
 
template<typename UInt , typename Char >
void fmt::internal::format_decimal (Char *buffer, UInt value, unsigned num_digits)
 
template<typename T >
Tfmt::internal::get ()
 
Yes & fmt::internal::convert (fmt::ULongLong)
 
No & fmt::internal::convert (...)
 
 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)
 
template<typename LConv >
StringRef fmt::internal::thousands_sep (LConv *lc, LConvCheck< char *LConv::*,&LConv::thousands_sep >=0)
 
fmt::StringRef fmt::internal::thousands_sep (...)
 
template<typename Formatter , typename Char , typename T >
void fmt::internal::format_arg (Formatter &, const Char *, const T &)
 
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_FUNC void fmt::format_system_error (Writer &out, int error_code, StringRef message) FMT_NOEXCEPT
 
FMT_FUNC void fmt::report_system_error (int error_code, fmt::StringRef message) FMT_NOEXCEPT
 
FMT_FUNC 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_FUNC void fmt::print (std::FILE *f, CStringRef format_str, ArgList args)
 
FMT_FUNC void fmt::print (CStringRef format_str, ArgList args)
 
template<typename T >
void fmt::format_decimal (char *&buffer, T value)
 
template<typename T >
internal::NamedArgWithType
< char, T
fmt::arg (StringRef name, const T &arg)
 
template<typename T >
internal::NamedArgWithType
< wchar_t, 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
 
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)
 
template<typename It >
ArgJoin< char, It > fmt::join (It first, It last, const BasicCStringRef< char > &sep)
 
template<typename It >
ArgJoin< wchar_t, It > fmt::join (It first, It last, const BasicCStringRef< wchar_t > &sep)
 
template<typename ArgFormatter , typename Char , typename It >
void fmt::format_arg (fmt::BasicFormatter< Char, ArgFormatter > &f, const Char *&format_str, const ArgJoin< Char, It > &e)
 

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,
 
)    a##b
#define FMT_CONCAT_ (   a,
 
)    FMT_CONCAT(a, b)
#define FMT_CTOR (   ctor,
  func,
  arg0_type,
  arg1_type,
 
)
Value:
template <FMT_GEN(n, FMT_MAKE_TEMPLATE_ARG)> \
ctor(arg0_type arg0, arg1_type arg1, FMT_GEN(n, FMT_MAKE_ARG)) { \
func(arg0, arg1, fmt::ArgList( \
}
Definition: format.h:1469
Definition: format.h:2227
uint64_t make_type()
Definition: format.h:2219
#define FMT_MAKE_REF2(n)
Definition: format.h:2316
#define FMT_GEN(n, f)
Definition: format.h:2201
#define FMT_MAKE_ARG(n)
Definition: format.h:2285
#define FMT_MAKE_REF(n)
Definition: format.h:2314
#define FMT_DEFAULTED_COPY_CTOR (   TypeName)
#define FMT_DEFINE_INT_FORMATTERS (   TYPE)
#define FMT_DELETED_OR_UNDEFINED
#define FMT_DETECTED_NOEXCEPT   throw()
#define FMT_DISABLE_CONVERSION_TO_INT (   Type)
Value:
template <> \
struct ConvertToInt<Type> { enum { value = 0 }; }
member1 value
Definition: Tag.cc:495
Definition: format.h:1183
#define FMT_DISALLOW_COPY_AND_ASSIGN (   TypeName)
Value:
TypeName(const TypeName&); \
TypeName& operator=(const TypeName&)
#define FMT_DISPATCH (   call)    static_cast<Impl*>(this)->call
#define FMT_DTOR_NOEXCEPT   FMT_NOEXCEPT
#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_FUNC
#define FMT_GCC_EXTENSION
#define FMT_GEN (   n,
 
)    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_DECLTYPE_INCOMPLETE_RETURN_TYPES
Value:
(FMT_HAS_FEATURE(cxx_decltype_incomplete_return_types) || \
(FMT_GCC_VERSION >= 407 && FMT_HAS_GXX_CXX11) || \
FMT_MSC_VER >= 1900 || \
FMT_ICC_VERSION >= 1200)
#define FMT_MSC_VER
Definition: format.h:59
#define FMT_HAS_FEATURE(x)
Definition: format.h:122
#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; }
float Type
Definition: constants.hh:32
string type
Definition: DRRAFTER.py:977
member1 value
Definition: Tag.cc:495
UINT64 uint64_t
Definition: types.hh:27
Definition: format.h:1267
#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; }
float Type
Definition: constants.hh:32
string type
Definition: DRRAFTER.py:977
member1 value
Definition: Tag.cc:495
UINT64 uint64_t
Definition: types.hh:27
Definition: format.h:1267
#define FMT_MAKE_WSTR_VALUE (   Type,
  TYPE 
)
Value:
set_string(value); \
} \
static uint64_t type(Type) { return Arg::TYPE; }
float Type
Definition: constants.hh:32
string type
Definition: DRRAFTER.py:977
member1 value
Definition: Tag.cc:495
UINT64 uint64_t
Definition: types.hh:27
Definition: format.h:1138
Definition: format.h:1267
#define FMT_MSC_VER   0
#define FMT_NARG (   ...)    FMT_NARG_(__VA_ARGS__, FMT_RSEQ_N())
#define FMT_NARG_ (   ...)    FMT_EXPAND(FMT_ARG_N(__VA_ARGS__))
#define FMT_NOEXCEPT   FMT_DETECTED_NOEXCEPT
#define FMT_NULL   NULL
#define FMT_OVERRIDE
#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,
 
)
Value:
template <> \
struct MakeUnsigned<T> { typedef U Type; }
float Type
Definition: constants.hh:32
Definition: format.h:626
#define FMT_STATIC_ASSERT (   cond,
  message 
)    typedef int FMT_CONCAT_(Assert, __LINE__)[(cond) ? 1 : -1] FMT_UNUSED
#define FMT_THROW (   x)    throw x
#define FMT_UNUSED
#define FMT_USE_DEFAULTED_FUNCTIONS   0
#define FMT_USE_DELETED_FUNCTIONS   0
#define FMT_USE_EXTERN_TEMPLATES
Value:
((__clang__ && FMT_USE_VARIADIC_TEMPLATES) || \
(FMT_GCC_VERSION >= 303 && FMT_HAS_GXX_CXX11))
#define FMT_USE_VARIADIC_TEMPLATES
Definition: format.h:141
#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) || FMT_MSC_VER >= 1600)
#define FMT_MSC_VER
Definition: format.h:59
#define FMT_HAS_FEATURE(x)
Definition: format.h:122
#define FMT_USE_STATIC_ASSERT   0
#define FMT_USE_USER_DEFINED_LITERALS
Value:
(FMT_HAS_FEATURE(cxx_user_literals) || \
(FMT_GCC_VERSION >= 407 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900) && \
(!defined(FMT_ICC_VERSION) || FMT_ICC_VERSION >= 1500)
#define FMT_MSC_VER
Definition: format.h:59
#define FMT_HAS_FEATURE(x)
Definition: format.h:122
#define FMT_USE_RVALUE_REFERENCES
Definition: format.h:152
#define FMT_USE_VARIADIC_TEMPLATES
Definition: format.h:141
#define FMT_USE_VARIADIC_TEMPLATES
Value:
(FMT_HAS_FEATURE(cxx_variadic_templates) || \
(FMT_GCC_VERSION >= 404 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1800)
#define FMT_MSC_VER
Definition: format.h:59
#define FMT_HAS_FEATURE(x)
Definition: format.h:122
#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_GET_ARG_NAME(type, index)
Definition: format.h:3491
Definition: format.h:1469
#define FMT_WRAP(Char, ReturnType, func, call, n,...)
Definition: format.h:3507
#define FMT_FOR_EACH(f,...)
Definition: format.h:3487
#define FMT_ADD_ARG_NAME(type, index)
Definition: format.h:3490
#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_CTOR(ctor, func, arg0_type, arg1_type, n)
Definition: format.h:2337
#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)
Definition: format.h:1469
void arg(WStringRef, const internal::NamedArg< Char > &) FMT_DELETED_OR_UNDEFINED
#define FMT_WRAP1(func, arg_type, n)
Definition: format.h:2320
#define FMT_VARIADIC_W (   ReturnType,
  func,
  ... 
)    FMT_VARIADIC_(wchar_t, ReturnType, func, return func, __VA_ARGS__)
#define FMT_VERSION   30002
#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_ASSIGN_##Char); \
}
#define inline
Definition: mt19937.hh:117
#define FMT_GET_ARG_NAME(type, index)
Definition: format.h:3491
float Type
Definition: constants.hh:32
Definition: format.h:1469
uint64_t make_type()
Definition: format.h:2219
#define FMT_MAKE_REF2(n)
Definition: format.h:2316
#define FMT_FOR_EACH(f,...)
Definition: format.h:3487
#define FMT_GEN(n, f)
Definition: format.h:2201
#define FMT_ADD_ARG_NAME(type, index)
Definition: format.h:3490
#define FMT_MAKE_ARG(n)
Definition: format.h:2285
#define FMT_WRAP1 (   func,
  arg_type,
 
)
Value:
template <FMT_GEN(n, FMT_MAKE_TEMPLATE_ARG)> \
inline void func(arg_type arg1, FMT_GEN(n, FMT_MAKE_ARG)) { \
func(arg1, fmt::ArgList( \
}
#define inline
Definition: mt19937.hh:117
Definition: format.h:1469
Definition: format.h:2227
uint64_t make_type()
Definition: format.h:2219
#define FMT_MAKE_REF2(n)
Definition: format.h:2316
#define FMT_GEN(n, f)
Definition: format.h:2201
#define FMT_MAKE_ARG(n)
Definition: format.h:2285
#define FMT_MAKE_REF(n)
Definition: format.h:2314