Pyrogenesis  trunk
Classes | Namespaces | Macros | Typedefs | Enumerations | Functions | Variables
format.h File Reference
#include <stdint.h>
#include <cassert>
#include <cstddef>
#include <cstdio>
#include <algorithm>
#include <limits>
#include <stdexcept>
#include <string>
#include <sstream>
Include dependency graph for format.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

class  fmt::BasicWriter< Char >
 This template provides operations for formatting and writing data into a character stream. More...
 
class  fmt::BasicFormatter< Char >
 
class  fmt::BasicStringRef< Char >
 A string reference. More...
 
class  fmt::FormatError
 A formatting error such as invalid format string. More...
 
class  fmt::internal::Array< T, SIZE >
 
class  fmt::internal::BasicCharTraits< Char >
 
class  fmt::internal::CharTraits< Char >
 
class  fmt::internal::CharTraits< char >
 
class  fmt::internal::CharTraits< wchar_t >
 
struct  fmt::internal::TypeSelector< FitsIn32Bits >
 
struct  fmt::internal::TypeSelector< false >
 
struct  fmt::internal::SignChecker< IsSigned >
 
struct  fmt::internal::SignChecker< true >
 
struct  fmt::internal::IntTraits< T >
 
struct  fmt::internal::MakeUnsigned< T >
 
struct  fmt::internal::FormatErrorReporter< Char >
 
struct  fmt::internal::NonZero< Arg >
 
struct  fmt::internal::NonZero< 0 >
 
struct  fmt::internal::Arg
 
struct  fmt::internal::Arg::StringValue< Char >
 
struct  fmt::internal::Arg::CustomValue
 
class  fmt::internal::MakeArg< Char >
 
class  fmt::internal::ArgVisitor< Impl, Result >
 
class  fmt::internal::RuntimeError
 
class  fmt::internal::ArgFormatter< Char >
 
class  fmt::ArgList
 An argument list. More...
 
class  fmt::internal::FormatterBase
 
class  fmt::internal::PrintfFormatter< Char >
 
class  fmt::BasicFormatter< Char >
 
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< T >
 
class  fmt::SystemError
 An error returned by an operating system or a language runtime, for example a file opening error. More...
 
class  fmt::BasicWriter< Char >
 This template provides operations for formatting and writing data into a character stream. More...
 
class  fmt::FormatInt
 Fast integer formatter. More...
 

Namespaces

 fmt
 
 fmt::internal
 

Macros

#define FMT_GCC_EXTENSION
 
#define FMT_HAS_FEATURE(x)   0
 
#define FMT_HAS_BUILTIN(x)   0
 
#define FMT_USE_VARIADIC_TEMPLATES
 
#define FMT_USE_RVALUE_REFERENCES
 
#define FMT_NOEXCEPT(expr)
 
#define FMT_DISALLOW_COPY_AND_ASSIGN(TypeName)
 
#define FMT_SPECIALIZE_MAKE_UNSIGNED(T, U)
 
#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_MAKE_TEMPLATE_ARG(n)   typename T##n
 
#define FMT_MAKE_ARG(n)   const T##n &v##n
 
#define FMT_MAKE_REF_char(n)   fmt::internal::MakeArg<char>(v##n)
 
#define FMT_MAKE_REF_wchar_t(n)   fmt::internal::MakeArg<wchar_t>(v##n)
 
#define FMT_MAKE_REF(n)   fmt::internal::MakeArg<Char>(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__)
 Defines a variadic function with the specified return type, function name and argument types passed as variable arguments to this macro. More...
 
#define FMT_VARIADIC_W(ReturnType, func, ...)   FMT_VARIADIC_(wchar_t, ReturnType, func, return func, __VA_ARGS__)
 

Typedefs

typedef BasicWriter< char > fmt::Writer
 
typedef BasicWriter< wchar_tfmt::WWriter
 
typedef BasicStringRef< char > fmt::StringRef
 
typedef BasicStringRef< wchar_tfmt::WStringRef
 

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

template<typename Char , typename T >
void fmt::format (BasicFormatter< Char > &f, const Char *format_str, const T &value)
 
template<typename T >
Tfmt::internal::make_ptr (T *ptr, std::size_t)
 
template<typename T >
bool fmt::internal::is_negative (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)
 
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)
 
int fmt::internal::safe_strerror (int error_code, char *&buffer, std::size_t buffer_size) FMT_NOEXCEPT(true)
 
void fmt::internal::format_system_error (fmt::Writer &out, int error_code, fmt::StringRef message)
 
IntFormatSpec< int, TypeSpec<'b'> > fmt::bin (int value)
 Returns an integer format specifier to format the value in base 2. More...
 
IntFormatSpec< int, TypeSpec<'o'> > fmt::oct (int value)
 Returns an integer format specifier to format the value in base 8. More...
 
IntFormatSpec< int, TypeSpec<'x'> > fmt::hex (int value)
 Returns an integer format specifier to format the value in base 16 using lower-case letters for the digits above 9. More...
 
IntFormatSpec< int, TypeSpec<'X'> > fmt::hexu (int value)
 Returns an integer formatter format specifier to format in base 16 using upper-case letters for the digits above 9. More...
 
template<char TYPE_CODE, typename Char >
IntFormatSpec< int, AlignTypeSpec< TYPE_CODE >, Char > fmt::pad (int value, unsigned width, Char fill= ' ')
 Returns an integer format specifier to pad the formatted argument with the fill character to the specified width using the default (right) numeric alignment. More...
 
template<typename Char >
StrFormatSpec< Char > fmt::pad (const Char *str, unsigned width, Char fill= ' ')
 Returns a string formatter that pads the formatted argument with the fill character to the specified width using the default (left) string alignment. More...
 
StrFormatSpec< wchar_tfmt::pad (const wchar_t *str, unsigned width, char fill= ' ')
 
void fmt::report_system_error (int error_code, StringRef message) FMT_NOEXCEPT(true)
 
void fmt::print_colored (Color c, StringRef format, const ArgList &args)
 Formats a string and prints it to stdout using ANSI escape sequences to specify color (experimental). More...
 
std::string fmt::format (StringRef format_str, const ArgList &args)
 Formats arguments and returns the result as a string. More...
 
std::wstring fmt::format (WStringRef format_str, const ArgList &args)
 
void fmt::print (std::FILE *f, StringRef format_str, const ArgList &args)
 Prints formatted data to the file f. More...
 
void fmt::print (StringRef format_str, const ArgList &args)
 Prints formatted data to stdout. More...
 
void fmt::print (std::ostream &os, StringRef format_str, const ArgList &args)
 Prints formatted data to the stream os. More...
 
template<typename Char >
void fmt::printf (BasicWriter< Char > &w, BasicStringRef< Char > format, const ArgList &args)
 
std::string fmt::sprintf (StringRef format, const ArgList &args)
 Formats arguments and returns the result as a string. More...
 
int fmt::fprintf (std::FILE *f, StringRef format, const ArgList &args)
 Prints formatted data to the file f. More...
 
int fmt::printf (StringRef format, const ArgList &args)
 Prints formatted data to stdout. More...
 
template<typename T >
void fmt::format_decimal (char *&buffer, T value)
 

Variables

FMT_GCC_EXTENSION typedef long long fmt::LongLong
 
FMT_GCC_EXTENSION typedef unsigned long long fmt::ULongLong
 
const uint32_t fmt::internal::POWERS_OF_10_32 [] = {0, FMT_POWERS_OF_10(1)}
 
const uint64_t fmt::internal::POWERS_OF_10_64 []
 
const char fmt::internal::DIGITS []
 

Macro Definition Documentation

#define FMT_ADD_ARG_NAME (   type,
  index 
)    type arg##index
#define FMT_ARG_N (   _1,
  _2,
  _3,
  _4,
  _5,
  _6,
  _7,
  _8,
  _9,
  _10,
  N,
  ... 
)    N
#define FMT_CONCAT (   a,
 
)    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)) { \
const fmt::internal::Arg args[] = {FMT_GEN(n, FMT_MAKE_REF)}; \
func(arg0, arg1, fmt::ArgList(args, sizeof(args) / sizeof(*args))); \
}
Definition: format.h:583
An argument list.
Definition: format.h:836
#define FMT_GEN(n, f)
Definition: format.h:1142
#define FMT_MAKE_ARG(n)
Definition: format.h:1155
#define FMT_MAKE_REF(n)
Definition: format.h:1184
#define FMT_DEFINE_INT_FORMATTERS (   TYPE)
#define FMT_DISALLOW_COPY_AND_ASSIGN (   TypeName)
Value:
TypeName(const TypeName&); \
void operator=(const TypeName&)
#define FMT_DISPATCH (   call)    static_cast<Impl*>(this)->call
#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,
 
)    FMT_GEN##n(f)
#define FMT_GEN1 (   f)    f(0)
#define FMT_GEN10 (   f)    FMT_GEN9(f), f(9)
#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_FEATURE (   x)    0
#define FMT_MAKE_ARG (   n)    const T##n &v##n
#define FMT_MAKE_REF (   n)    fmt::internal::MakeArg<Char>(v##n)
#define FMT_MAKE_REF_char (   n)    fmt::internal::MakeArg<char>(v##n)
#define FMT_MAKE_REF_wchar_t (   n)    fmt::internal::MakeArg<wchar_t>(v##n)
#define FMT_MAKE_TEMPLATE_ARG (   n)    typename T##n
#define FMT_NARG (   ...)    FMT_NARG_(__VA_ARGS__, FMT_RSEQ_N())
#define FMT_NARG_ (   ...)    FMT_EXPAND(FMT_ARG_N(__VA_ARGS__))
#define FMT_NOEXCEPT (   expr)
#define FMT_RSEQ_N ( )    10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0
#define FMT_SPECIALIZE_MAKE_UNSIGNED (   T,
 
)
Value:
template <> \
struct MakeUnsigned<T> { typedef U Type; }
Definition: cache.cpp:318
#define FMT_USE_RVALUE_REFERENCES
Value:
(FMT_HAS_FEATURE(cxx_rvalue_references) || \
(FMT_GCC_VERSION >= 403 && __cplusplus >= 201103) || (defined(_MSC_VER) && _MSC_VER >= 1600))
#define FMT_HAS_FEATURE(x)
Definition: format.h:71
#define FMT_USE_VARIADIC_TEMPLATES
Value:
(FMT_HAS_FEATURE(cxx_variadic_templates) || \
(FMT_GCC_VERSION >= 404 && __cplusplus >= 201103) || (defined(_MSC_VER) && _MSC_VER >= 1800))
#define FMT_HAS_FEATURE(x)
Definition: format.h:71
#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, const 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__)
#define FMT_GET_ARG_NAME(type, index)
Definition: format.h:1985
#define FMT_WRAP(Char, ReturnType, func, call, n,...)
Definition: format.h:2002
An argument list.
Definition: format.h:836
#define FMT_FOR_EACH(f,...)
Definition: format.h:1981
#define FMT_ADD_ARG_NAME(type, index)
Definition: format.h:1984
#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:1202
#define FMT_VARIADIC_VOID (   func,
  arg_type 
)
Value:
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_WRAP1(func, arg_type, n)
Definition: format.h:1187
#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__), \
const fmt::internal::Arg args[] = {FMT_GEN(n, FMT_MAKE_REF_##Char)}; \
call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), \
fmt::ArgList(args, sizeof(args) / sizeof(*args))); \
}
#define FMT_GET_ARG_NAME(type, index)
Definition: format.h:1985
Definition: format.h:583
An argument list.
Definition: format.h:836
#define FMT_FOR_EACH(f,...)
Definition: format.h:1981
#define FMT_GEN(n, f)
Definition: format.h:1142
#define FMT_ADD_ARG_NAME(type, index)
Definition: format.h:1984
#define FMT_MAKE_ARG(n)
Definition: format.h:1155
#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)) { \
const fmt::internal::Arg args[] = {FMT_GEN(n, FMT_MAKE_REF)}; \
func(arg1, fmt::ArgList(args, sizeof(args) / sizeof(*args))); \
}
Definition: format.h:583
An argument list.
Definition: format.h:836
#define FMT_GEN(n, f)
Definition: format.h:1142
#define FMT_MAKE_ARG(n)
Definition: format.h:1155
#define FMT_MAKE_REF(n)
Definition: format.h:1184