16 #include <type_traits>
19 #define FMT_VERSION 50202
22 # define FMT_HAS_FEATURE(x) __has_feature(x)
24 # define FMT_HAS_FEATURE(x) 0
27 #if defined(__has_include) && !defined(__INTELLISENSE__) && \
28 !(defined(__INTEL_COMPILER) && __INTEL_COMPILER < 1600)
29 # define FMT_HAS_INCLUDE(x) __has_include(x)
31 # define FMT_HAS_INCLUDE(x) 0
34 #ifdef __has_cpp_attribute
35 # define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
37 # define FMT_HAS_CPP_ATTRIBUTE(x) 0
40 #if defined(__GNUC__) && !defined(__clang__)
41 # define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
43 # define FMT_GCC_VERSION 0
46 #if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__)
47 # define FMT_HAS_GXX_CXX11 FMT_GCC_VERSION
49 # define FMT_HAS_GXX_CXX11 0
53 # define FMT_MSC_VER _MSC_VER
55 # define FMT_MSC_VER 0
60 #ifndef FMT_USE_CONSTEXPR
61 # define FMT_USE_CONSTEXPR \
62 (FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VER >= 1910 || \
63 (FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L))
66 # define FMT_CONSTEXPR constexpr
67 # define FMT_CONSTEXPR_DECL constexpr
69 # define FMT_CONSTEXPR inline
70 # define FMT_CONSTEXPR_DECL
73 #ifndef FMT_USE_CONSTEXPR11
74 # define FMT_USE_CONSTEXPR11 \
75 (FMT_USE_CONSTEXPR || FMT_GCC_VERSION >= 406 || FMT_MSC_VER >= 1900)
77 #if FMT_USE_CONSTEXPR11
78 # define FMT_CONSTEXPR11 constexpr
80 # define FMT_CONSTEXPR11
84 # if FMT_HAS_FEATURE(cxx_override) || \
85 (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900
86 # define FMT_OVERRIDE override
92 #if FMT_HAS_FEATURE(cxx_explicit_conversions) || \
93 FMT_GCC_VERSION >= 405 || FMT_MSC_VER >= 1800
94 # define FMT_USE_EXPLICIT 1
95 # define FMT_EXPLICIT explicit
97 # define FMT_USE_EXPLICIT 0
102 # if FMT_HAS_FEATURE(cxx_nullptr) || \
103 (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1600
104 # define FMT_NULL nullptr
105 # define FMT_USE_NULLPTR 1
107 # define FMT_NULL NULL
110 #ifndef FMT_USE_NULLPTR
111 # define FMT_USE_NULLPTR 0
115 #if (defined(__GNUC__) && !defined(__EXCEPTIONS)) || \
116 FMT_MSC_VER && !_HAS_EXCEPTIONS
117 # define FMT_EXCEPTIONS 0
119 # define FMT_EXCEPTIONS 1
123 #ifndef FMT_USE_NOEXCEPT
124 # define FMT_USE_NOEXCEPT 0
127 #if FMT_USE_NOEXCEPT || FMT_HAS_FEATURE(cxx_noexcept) || \
128 (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900
129 # define FMT_DETECTED_NOEXCEPT noexcept
130 # define FMT_HAS_CXX11_NOEXCEPT 1
132 # define FMT_DETECTED_NOEXCEPT throw()
133 # define FMT_HAS_CXX11_NOEXCEPT 0
137 # if FMT_EXCEPTIONS || FMT_HAS_CXX11_NOEXCEPT
138 # define FMT_NOEXCEPT FMT_DETECTED_NOEXCEPT
140 # define FMT_NOEXCEPT
144 #ifndef FMT_BEGIN_NAMESPACE
145 # if FMT_HAS_FEATURE(cxx_inline_namespaces) || FMT_GCC_VERSION >= 404 || \
147 # define FMT_INLINE_NAMESPACE inline namespace
148 # define FMT_END_NAMESPACE }}
150 # define FMT_INLINE_NAMESPACE namespace
151 # define FMT_END_NAMESPACE } using namespace v5; }
153 # define FMT_BEGIN_NAMESPACE namespace fmt { FMT_INLINE_NAMESPACE v5 {
156 #if !defined(FMT_HEADER_ONLY) && defined(_WIN32)
158 # define FMT_API __declspec(dllexport)
159 # elif defined(FMT_SHARED)
160 # define FMT_API __declspec(dllimport)
168 # define FMT_ASSERT(condition, message) assert((condition) && message)
172 #if (FMT_HAS_INCLUDE(<string_view>) && \
173 (__cplusplus > 201402L || defined(_LIBCPP_VERSION))) || \
174 (defined(_MSVC_LANG) && _MSVC_LANG > 201402L && _MSC_VER >= 1910)
175 # include <string_view>
176 # define FMT_STRING_VIEW std::basic_string_view
177 #elif FMT_HAS_INCLUDE(<experimental/string_view>) && __cplusplus >= 201402L
178 # include <experimental/string_view>
179 # define FMT_STRING_VIEW std::experimental::basic_string_view
183 #if FMT_GCC_VERSION && FMT_GCC_VERSION <= 404
184 # include <functional>
191 template <
typename T>
197 template <
typename F,
typename... Args>
200 typedef typename std::result_of<
205 template <
typename Int>
212 template <
typename T>
220 std::size_t capacity_;
232 capacity_ = buf_capacity;
272 if (new_capacity > capacity_)
278 ptr_[size_++] =
value;
282 template <
typename U>
293 template <
typename Container>
296 Container &container_;
310 template <
typename Container>
312 typedef std::back_insert_iterator<Container> bi_iterator;
313 struct accessor: bi_iterator {
314 accessor(bi_iterator iter) : bi_iterator(iter) {}
315 using bi_iterator::container;
317 return *accessor(it).container;
328 template <
typename T>
332 #if FMT_GCC_VERSION && FMT_GCC_VERSION < 405
333 template <
typename...
T>
336 template <
typename...
T>
347 template <
typename Char>
361 : data_(
s), size_(
count) {}
370 : data_(s), size_(std::char_traits<Char>::
length(s)) {}
373 template <
typename Alloc>
376 : data_(
s.data()), size_(
s.size()) {}
378 #ifdef FMT_STRING_VIEW
380 : data_(
s.data()), size_(
s.size()) {}
399 size_t str_size = size_ < other.size_ ? size_ : other.size_;
402 result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1);
451 template <
typename Char>
455 template <
typename Char>
459 template <
typename Char>
462 #ifdef FMT_STRING_VIEW
463 template <
typename Char>
472 template <
typename S>
481 template <
typename Context>
484 template <
typename Context>
488 template <
typename T,
typename Char =
char,
typename Enable =
void>
491 "don't know how to format the type, include fmt/ostream.h if it provides "
492 "an operator<< that should be used");
495 template <
typename ParseContext>
496 typename ParseContext::iterator
parse(ParseContext &);
497 template <
typename FormatContext>
498 auto format(
const T &
val, FormatContext &ctx) -> decltype(ctx.out());
501 template <
typename T,
typename Char,
typename Enable =
void>
503 bool, !std::is_arithmetic<T>::value && std::is_convertible<T, int>::value> {};
512 template <
typename S>
513 struct is_string : std::integral_constant<bool, !std::is_same<
514 dummy_string_view, decltype(to_string_view(declval<S>()))>::value> {};
516 template <
typename S>
522 template <typename Char>
525 template <typename T, typename Char>
548 template <
typename Char>
554 template <
typename Context>
561 template <
typename Context>
589 "incompatible string types");
594 "incompatible string types");
598 string.value = val.
data();
599 string.size = val.
size();
603 template <
typename T>
606 custom.format = &format_custom_arg<T>;
615 template <
typename T>
616 static void format_custom_arg(
const void *
arg,
Context &ctx) {
621 auto &&parse_ctx = ctx.parse_context();
622 parse_ctx.advance_to(f.parse(parse_ctx));
623 ctx.advance_to(f.format(*static_cast<const T*>(arg), ctx));
628 template <
typename Context,
typename T, type TYPE>
631 static const type type_tag = TYPE;
637 template <
typename Context,
typename T>
640 #define FMT_MAKE_VALUE(TAG, ArgType, ValueType) \
641 template <typename C> \
642 FMT_CONSTEXPR init<C, ValueType, TAG> make_value(ArgType val) { \
643 return static_cast<ValueType>(val); \
646 #define FMT_MAKE_VALUE_SAME(TAG, Type) \
647 template <typename C> \
648 FMT_CONSTEXPR init<C, Type, TAG> make_value(Type val) { return val; }
658 typedef std::conditional<sizeof(
long) == sizeof(
int),
int,
long long>::
type
662 typedef std::conditional<sizeof(
unsigned long) == sizeof(
unsigned),
663 unsigned,
unsigned long long>::
type ulong_type;
665 (sizeof(
unsigned long) == sizeof(
unsigned) ? uint_type :
ulong_long_type),
666 unsigned long, ulong_type)
674 template <typename C, typename Char>
679 template <
typename C>
691 const typename C::char_type*)
693 const typename C::char_type*)
716 template <
typename C,
typename T>
719 static_assert(!
sizeof(
T),
"formatting of non-void pointers is disallowed");
722 template <
typename C,
typename T>
723 inline typename std::enable_if<
725 init<C, int, int_type>>
::type
728 template <
typename C,
typename T,
typename Char =
typename C::
char_type>
729 inline typename std::enable_if<
732 init<C, basic_string_view<Char>, string_type>>
::type
735 template <
typename C,
typename T,
typename Char =
typename C::
char_type>
736 inline typename std::enable_if<
738 !std::is_convertible<T, basic_string_view<Char>>
::value &&
743 init<C, const T &, custom_type>>
::type
746 template <
typename C,
typename T>
747 init<C, const void*, named_arg_type>
750 std::memcpy(val.
data, &arg,
sizeof(arg));
751 return static_cast<const void*
>(&
val);
754 template <
typename C,
typename S>
757 init<C, basic_string_view<typename C::char_type>, string_type>>
::type
760 static_assert(std::is_same<
762 "mismatch between char-types of context and argument");
769 template <
typename Context>
775 template <
typename Context>
781 template <
typename ContextType,
typename T>
785 template <
typename Visitor,
typename Ctx>
826 template <
typename Visitor,
typename Context>
837 return vis(arg.value_.int_value);
839 return vis(arg.value_.uint_value);
841 return vis(arg.value_.long_long_value);
843 return vis(arg.value_.ulong_long_value);
845 return vis(arg.value_.int_value != 0);
847 return vis(static_cast<char_type>(arg.value_.int_value));
849 return vis(arg.value_.double_value);
851 return vis(arg.value_.long_double_value);
853 return vis(arg.value_.string.value);
856 arg.value_.string.value, arg.value_.string.size));
858 return vis(arg.value_.pointer);
865 template <
typename Visitor,
typename Context>
873 template <
typename Char,
typename ErrorHandler =
internal::error_handler>
885 :
ErrorHandler(eh), format_str_(format_str), next_arg_id_(0) {}
890 return format_str_.begin();
905 if (next_arg_id_ > 0) {
906 on_error(
"cannot switch from automatic to manual argument indexing");
915 ErrorHandler::on_error(message);
930 template <
typename Context>
934 void operator=(
const arg_map &) =
delete;
948 map_[size_] = entry{named.
name, named.template deserialize<Context>()};
959 for (entry *it = map_, *
end = map_ + size_; it !=
end; ++it) {
960 if (it->name == name)
976 template <
typename Locale>
979 template <
typename Locale>
983 template <
typename OutputIt,
typename Context,
typename Char>
1001 : parse_context_(format_str), out_(out), args_(ctx_args), loc_(loc) {}
1007 parse_context_.on_error(
"argument index out of range");
1038 template <
typename Context,
typename T>
1040 typedef decltype(make_value<Context>(
1048 template <
typename Context,
typename Arg,
typename... Args>
1053 template <
typename Context,
typename T>
1057 arg.value_ = make_value<Context>(
value);
1061 template <
bool IS_PACKED,
typename Context,
typename T>
1062 inline typename std::enable_if<IS_PACKED, value<Context>>
::type
1064 return make_value<Context>(
value);
1067 template <
bool IS_PACKED,
typename Context,
typename T>
1068 inline typename std::enable_if<!IS_PACKED, basic_format_arg<Context>>
::type
1070 return make_arg<Context>(
value);
1075 template <
typename OutputIt,
typename Char>
1078 OutputIt, basic_format_context<OutputIt, Char>, Char> {
1084 template <
typename T>
1095 using base::get_arg;
1107 :
base(out, format_str, ctx_args, loc) {}
1110 return this->do_get_arg(this->
parse_context().next_arg_id());
1119 template <
typename Char>
1122 std::back_insert_iterator<internal::basic_buffer<Char>>, Char>
type;
1134 template <
typename Context,
typename ...Args>
1137 static const size_t NUM_ARGS =
sizeof...(Args);
1142 typedef typename std::conditional<IS_PACKED,
1146 static const size_t DATA_SIZE =
1147 NUM_ARGS + (IS_PACKED && NUM_ARGS != 0 ? 0 : 1);
1148 value_type data_[DATA_SIZE];
1155 -static_cast<long long>(NUM_ARGS);
1159 #if FMT_USE_CONSTEXPR11
1165 #if (FMT_GCC_VERSION && FMT_GCC_VERSION <= 405) || \
1166 (FMT_MSC_VER && FMT_MSC_VER <= 1800)
1169 value_type
init[DATA_SIZE] =
1170 {internal::make_arg<IS_PACKED, Context>(
args)...};
1171 std::memcpy(data_, init,
sizeof(init));
1175 : data_{internal::make_arg<IS_PACKED, Context>(
args)...} {}
1179 #if !FMT_USE_CONSTEXPR11
1180 template <
typename Context,
typename ...Args>
1196 template <
typename Context>
1205 unsigned long long types_;
1217 unsigned shift = index * 4;
1218 unsigned long long mask = 0xf;
1226 void set_data(
const format_arg *args) { args_ =
args; }
1228 format_arg do_get(size_type
index)
const {
1230 long long signed_types =
static_cast<long long>(types_);
1231 if (signed_types < 0) {
1232 unsigned long long num_args =
1233 static_cast<unsigned long long>(-signed_types);
1234 if (index < num_args)
1240 arg.type_ =
type(index);
1244 val = values_[
index];
1256 template <
typename... Args>
1258 : types_(static_cast<unsigned long long>(store.TYPES)) {
1259 set_data(store.data_);
1268 : types_(-static_cast<int64_t>(count)) {
1276 arg = arg.value_.as_named_arg().template deserialize<Context>();
1281 long long signed_types =
static_cast<long long>(types_);
1282 return static_cast<unsigned>(
1291 template <
typename ...Args>
1296 template <
typename ...Args>
1301 #ifndef FMT_USE_ALIAS_TEMPLATES
1302 # define FMT_USE_ALIAS_TEMPLATES FMT_HAS_FEATURE(cxx_alias_templates)
1304 #if FMT_USE_ALIAS_TEMPLATES
1306 template <
typename S>
1309 #define FMT_CHAR(S) fmt::char_t<S>
1311 template <
typename S,
typename T>
1312 using enable_if_string_t =
1314 #define FMT_ENABLE_IF_STRING(S, T) enable_if_string_t<S, T>
1316 template <
typename S>
1318 internal::is_string<S>::value, typename internal::char_t<S>::type> {};
1319 #define FMT_CHAR(S) typename char_t<S>::type
1321 #define FMT_ENABLE_IF_STRING(S, T) \
1322 typename std::enable_if<internal::is_string<S>::value, T>::type
1325 namespace internal {
1326 template <
typename Char>
1327 struct named_arg_base {
1336 template <
typename Context>
1344 template <
typename T,
typename Char>
1345 struct named_arg : named_arg_base<Char> {
1352 template <
typename... Args,
typename S>
1355 template <
typename... Args,
typename S>
1359 template <
typename S,
typename... Args>
1361 typename buffer_context<FMT_CHAR(S)>::type, Args...> {
1372 template <
typename Char>
1373 std::basic_string<Char>
vformat(
1377 template <
typename Char>
1392 template <
typename T>
1397 template <
typename T>
1403 template <
typename S,
typename T,
typename Char>
1406 template <
typename Container>
1409 template <
typename Char>
1412 template <
typename Char>
1416 template <
typename Container,
typename S>
1417 typename std::enable_if<
1420 std::back_insert_iterator<Container> out,
1421 const S &format_str,
1428 template <
typename Container,
typename S,
typename... Args>
1429 inline typename std::enable_if<
1431 std::back_insert_iterator<Container>>::type
1432 format_to(std::back_insert_iterator<Container> out,
const S &format_str,
1433 const Args &... args) {
1438 template <
typename S,
typename Char = FMT_CHAR(S)>
1440 const S &format_str,
1455 template <
typename S,
typename... Args>
1456 inline std::basic_string<FMT_CHAR(S)>
format(
1457 const S &format_str,
const Args &... args) {
1477 template <
typename S,
typename... Args>
1496 template <
typename S,
typename... Args>
1504 #endif // FMT_CORE_H_
T & operator[](std::size_t index)
FMT_CONSTEXPR bool check_arg_id(unsigned)
value(const signed char *val)
format_arg get_arg(unsigned arg_id)
Container & get_container(std::back_insert_iterator< Container > it)
const T & const_reference
GLuint const GLchar * name
FMT_CONSTEXPR basic_string_view() FMT_NOEXCEPT
std::conditional< sizeof(long)==sizeof(int), int, long long >::type long_type
basic_parse_context< wchar_t > wformat_parse_context
value(const unsigned char *val)
FMT_CONSTEXPR auto begin(const C &c) -> decltype(c.begin())
checked_args(const S &format_str, const Args &...args)
FMT_API void on_error(const char *message)
format_arg do_get_arg(unsigned arg_id)
GLuint const GLfloat * val
basic_string_view< Char >::iterator iterator
internal::named_arg< T, char > arg(string_view name, const T &arg)
const named_arg_base< char_type > & as_named_arg()
void append(const U *begin, const U *end)
basic_format_arg< Context > format_arg
const T & operator[](std::size_t index) const
FMT_CONSTEXPR error_handler(const error_handler &)
GLint GLsizei const GLuint64 * values
void on_error(const char *message)
basic_buffer(T *p=FMT_NULL, std::size_t sz=0, std::size_t cap=0) FMT_NOEXCEPT
FMT_CONSTEXPR error_handler()
std::add_rvalue_reference< T >::type declval() FMT_NOEXCEPT
basic_parse_context< wchar_t > wparse_context
named_arg_base(basic_string_view< Char > nm)
basic_format_args< Context > args() const
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
FMT_CONSTEXPR basic_string_view(const std::basic_string< Char, Alloc > &s) FMT_NOEXCEPT
basic_string_view< wchar_t > wstring_view
friend bool operator<(basic_string_view lhs, basic_string_view rhs)
buffer_context< char >::type format_context
void check_arg_id(basic_string_view< Char >)
void resize(std::size_t new_size)
FMT_CONSTEXPR void on_error(const char *message)
#define FMT_MAKE_VALUE_SAME(TAG, Type)
basic_buffer(std::size_t sz) FMT_NOEXCEPT
value(unsigned long long val)
FMT_CONSTEXPR basic_string_view(const Char *s, size_t count) FMT_NOEXCEPT
FMT_CONSTEXPR basic_format_arg< Context > make_arg(const T &value)
#define FMT_END_NAMESPACE
FMT_CONSTEXPR size_t size() const
char data[sizeof(basic_format_arg< typename buffer_context< Char >::type >)]
named_arg(basic_string_view< Char > name, const T &val)
std::enable_if<!is_compile_string< S >::value >::type check_format_string(const S &)
basic_buffer< wchar_t > wbuffer
std::result_of< typename std::remove_reference< F >::type(Args...)>::type type
friend bool operator!=(basic_string_view lhs, basic_string_view rhs)
CompareResults OIIO_API compare(const ImageBuf &A, const ImageBuf &B, float failthresh, float warnthresh, ROI roi={}, int nthreads=0)
std::enable_if< is_contiguous< Container >::value &&internal::is_string< S >::value, std::back_insert_iterator< Container > >::type format_to(std::back_insert_iterator< Container > out, const S &format_str, const Args &...args)
container_buffer(Container &c)
basic_string_view(const Char *s)
value(const char_type *val)
buffer_context< FMT_CHAR(S)>::type context
value(basic_string_view< char_type > val)
virtual void grow(std::size_t capacity)=0
void advance_to(iterator it)
buffer_context< Char >::type::iterator vformat_to(internal::basic_buffer< Char > &buf, basic_string_view< Char > format_str, basic_format_args< typename buffer_context< Char >::type > args)
FMT_CONSTEXPR auto end(const C &c) -> decltype(c.end())
dummy_string_view to_string_view(...)
const T * data() const FMT_NOEXCEPT
FMT_CONSTEXPR const Char * data() const
friend bool operator>=(basic_string_view lhs, basic_string_view rhs)
basic_parse_context< char > format_parse_context
FMT_CONSTEXPR bool is_arithmetic(type t)
std::basic_string< Char > vformat(basic_string_view< Char > format_str, basic_format_args< typename buffer_context< Char >::type > args)
format_arg get_arg(unsigned arg_id)
FMT_CONSTEXPR bool is_integral(type t)
basic_string_view< char > string_view
GLsizei GLenum GLuint GLuint GLsizei GLchar * message
buffer_context< wchar_t >::type wformat_context
std::size_t size() const FMT_NOEXCEPT
GLuint GLsizei GLsizei * length
void push_back(const T &value)
std::size_t capacity() const FMT_NOEXCEPT
basic_string_view< Char > name
void grow(std::size_t capacity) FMT_OVERRIDE
friend bool operator>(basic_string_view lhs, basic_string_view rhs)
FMT_CONSTEXPR ErrorHandler error_handler() const
FMT_MAKE_VALUE((sizeof(long)==sizeof(int)?int_type:long_long_type), long, long_type) typedef std FMT_MAKE_VALUE((sizeof(unsigned long)==sizeof(unsigned)?uint_type:ulong_long_type), unsigned long, ulong_type) template< typename C
void reserve(std::size_t new_capacity)
basic_buffer< char > buffer
GLuint GLuint GLsizei GLenum type
FMT_CONSTEXPR void advance_to(iterator it)
format_arg_store< Context, Args...> make_format_args(const Args &...args)
FMT_MAKE_VALUE((sizeof(long)==sizeof(int)?int_type:long_long_type), long, long_type) typedef std Char FMT_CONSTEXPR std::enable_if< std::is_same< typename C::char_type, Char >::value, init< C, int, char_type > >::type make_value(Char val)
string_value< char_type > string
void init(const basic_format_args< Context > &args)
FMT_CONSTEXPR value(int val=0)
basic_format_context< std::back_insert_iterator< internal::basic_buffer< Char > >, Char > type
long long long_long_value
friend bool operator<=(basic_string_view lhs, basic_string_view rhs)
std::basic_string< FMT_CHAR(S)> format(const S &format_str, const Args &...args)
basic_format_arg< Context > deserialize() const
FMT_CONSTEXPR internal::result_of< Visitor(int)>::type visit(Visitor &&vis, const basic_format_arg< Context > &arg)
FMT_CONSTEXPR std::make_unsigned< Int >::type to_unsigned(Int value)
context_base(OutputIt out, basic_string_view< char_type > format_str, basic_format_args< Context > ctx_args, locale_ref loc=locale_ref())
GLsizei const void * pointer
friend bool operator==(basic_string_view lhs, basic_string_view rhs)
FMT_CONSTEXPR basic_parse_context(basic_string_view< Char > format_str, ErrorHandler eh=ErrorHandler())
FMT_CONSTEXPR iterator begin() const FMT_NOEXCEPT
GLuint GLuint GLsizei count
#define FMT_ENABLE_IF_STRING(S, T)
int compare(basic_string_view other) const
FMT_CONSTEXPR iterator end() const
Helper template to let us tell if two types are the same.
FMT_API void vprint(std::FILE *f, string_view format_str, format_args args)
basic_format_arg< Context > find(basic_string_view< char_type > name) const
basic_format_context(OutputIt out, basic_string_view< char_type > format_str, basic_format_args< basic_format_context > ctx_args, internal::locale_ref loc=internal::locale_ref())
basic_format_args< context > operator*() const
#define FMT_ASSERT(condition, message)
FMT_CONSTEXPR iterator begin() const
#define FMT_BEGIN_NAMESPACE
basic_string_view< Char > to_string_view(basic_string_view< Char > s)
custom_value< Context > custom
internal::error_handler error_handler()
formatter< T, char_type > type
GLenum GLuint GLsizei const GLchar * buf
string_value< signed char > sstring
basic_parse_context< char_type > & parse_context()
Context::char_type char_type
FMT_CONSTEXPR void remove_prefix(size_t n)
GLsizei const GLfloat * value
string_value< unsigned char > ustring
basic_parse_context< char > parse_context
FMT_CONSTEXPR init(const T &v)
FMT_CONSTEXPR internal::result_of< Visitor(int)>::type visit_format_arg(Visitor &&vis, const basic_format_arg< Context > &arg)
unsigned long long ulong_long_value
long double long_double_value
FMT_CONSTEXPR iterator end() const FMT_NOEXCEPT
void set(T *buf_data, std::size_t buf_capacity) FMT_NOEXCEPT
std::enable_if< internal::is_string< S >::value >::type print(std::basic_ostream< FMT_CHAR(S)> &os, const S &format_str, const Args &...args)
FMT_CONSTEXPR11 unsigned long long get_types()