@@ -113,7 +113,8 @@ binary footprint, for example (https://godbolt.org/z/oba4Mc):
113113
114114 template <typename S, typename... Args>
115115 void log(const char* file, int line, const S& format, Args&&... args) {
116- vlog(file, line, format, fmt::make_format_args(args...));
116+ vlog(file, line, format,
117+ fmt::make_args_checked<Args...>(format, args...));
117118 }
118119
119120 #define MY_LOG(format, ...) \
@@ -124,6 +125,8 @@ binary footprint, for example (https://godbolt.org/z/oba4Mc):
124125Note that ``vlog `` is not parameterized on argument types which improves compile
125126times and reduces binary code size compared to a fully parameterized version.
126127
128+ .. doxygenfunction :: fmt::make_args_checked(const S&, const remove_reference_t<Args>&...)
129+
127130.. doxygenfunction :: fmt::make_format_args(const Args&...)
128131
129132.. doxygenclass :: fmt::format_arg_store
@@ -179,11 +182,6 @@ functions and locale support.
179182Formatting User-defined Types
180183-----------------------------
181184
182- The {fmt} library provides formatters for many standard C++ types.
183- See :ref: `fmt/ranges.h <ranges-api >` for ranges and tuples including standard
184- containers such as ``std::vector `` and :ref: `fmt/chrono.h <chrono-api >` for date
185- and time formatting.
186-
187185To make a user-defined type formattable, specialize the ``formatter<T> `` struct
188186template and implement ``parse `` and ``format `` methods::
189187
@@ -224,7 +222,7 @@ template and implement ``parse`` and ``format`` methods::
224222 // Formats the point p using the parsed format specification (presentation)
225223 // stored in this formatter.
226224 template <typename FormatContext>
227- auto format(const point& p, FormatContext& ctx) const -> decltype(ctx.out()) {
225+ auto format(const point& p, FormatContext& ctx) -> decltype(ctx.out()) {
228226 // ctx.out() is an output iterator to write to.
229227 return presentation == 'f'
230228 ? format_to(ctx.out(), "({:.1f}, {:.1f})", p.x, p.y)
@@ -246,7 +244,7 @@ example::
246244 template <> struct fmt::formatter<color>: formatter<string_view> {
247245 // parse is inherited from formatter<string_view>.
248246 template <typename FormatContext>
249- auto format(color c, FormatContext& ctx) const {
247+ auto format(color c, FormatContext& ctx) {
250248 string_view name = "unknown";
251249 switch (c) {
252250 case color::red: name = "red"; break;
@@ -284,7 +282,7 @@ You can also write a formatter for a hierarchy of classes::
284282 struct fmt::formatter<T, std::enable_if_t<std::is_base_of<A, T>::value, char>> :
285283 fmt::formatter<std::string> {
286284 template <typename FormatCtx>
287- auto format(const A& a, FormatCtx& ctx) const {
285+ auto format(const A& a, FormatCtx& ctx) {
288286 return fmt::formatter<std::string>::format(a.name(), ctx);
289287 }
290288 };
@@ -309,7 +307,7 @@ The following user-defined literals are defined in ``fmt/format.h``.
309307
310308.. doxygenfunction :: operator""_format(const char *s, size_t n) -> detail::udl_formatter<char>
311309
312- .. doxygenfunction :: operator""_a()
310+ .. doxygenfunction :: operator""_a(const char *s, size_t) -> detail::udl_arg<char>
313311
314312Utilities
315313---------
@@ -318,8 +316,6 @@ Utilities
318316.. doxygenfunction :: fmt::ptr(const std::unique_ptr<T> &p) -> const void*
319317.. doxygenfunction :: fmt::ptr(const std::shared_ptr<T> &p) -> const void*
320318
321- .. doxygenfunction :: fmt::underlying(Enum e) -> typename std::underlying_type<Enum>::type
322-
323319.. doxygenfunction :: fmt::to_string(const T &value) -> std::string
324320
325321.. doxygenfunction :: fmt::to_string_view(const Char *s) -> basic_string_view<Char>
@@ -450,19 +446,16 @@ The format syntax is described in :ref:`chrono-specs`.
450446Format string compilation
451447=========================
452448
453- ``fmt/compile.h `` provides format string compilation enabled via the
454- ``FMT_COMPILE `` macro or the ``_cf `` user-defined literal. Format strings
455- marked with ``FMT_COMPILE `` or ``_cf `` are parsed, checked and converted into
456- efficient formatting code at compile-time. This supports arguments of built-in
457- and string types as well as user-defined types with ``constexpr `` ``parse ``
458- functions in their ``formatter `` specializations. Format string compilation can
459- generate more binary code compared to the default API and is only recommended in
460- places where formatting is a performance bottleneck.
449+ ``fmt/compile.h `` provides format string compilation support when using
450+ ``FMT_COMPILE ``. Format strings are parsed, checked and converted into efficient
451+ formatting code at compile-time. This supports arguments of built-in and string
452+ types as well as user-defined types with ``constexpr `` ``parse `` functions in
453+ their ``formatter `` specializations. Format string compilation can generate more
454+ binary code compared to the default API and is only recommended in places where
455+ formatting is a performance bottleneck.
461456
462457.. doxygendefine :: FMT_COMPILE
463458
464- .. doxygenfunction :: operator""_cf()
465-
466459.. _color-api :
467460
468461Terminal color and text style
@@ -476,8 +469,6 @@ Terminal color and text style
476469
477470.. doxygenfunction :: bg(detail::color_type)
478471
479- .. doxygenfunction :: styled(const T& value, text_style ts)
480-
481472.. _os-api :
482473
483474System APIs
@@ -495,9 +486,7 @@ System APIs
495486========================
496487
497488``fmt/ostream.h `` provides ``std::ostream `` support including formatting of
498- user-defined types that have an overloaded insertion operator (``operator<< ``).
499- In order to make a type formattable via ``std::ostream `` you should provide a
500- ``formatter `` specialization inherited from ``ostream_formatter ``::
489+ user-defined types that have an overloaded insertion operator (``operator<< ``)::
501490
502491 #include <fmt/ostream.h>
503492
@@ -511,12 +500,13 @@ In order to make a type formattable via ``std::ostream`` you should provide a
511500 }
512501 };
513502
514- template <> struct fmt::formatter<date> : ostream_formatter {};
515-
516503 std::string s = fmt::format("The date is {}", date(2012, 12, 9));
517504 // s == "The date is 2012-12-9"
518505
519- .. doxygenfunction :: print(std::ostream &os, format_string<T...> fmt, T&&... args)
506+ {fmt} only supports insertion operators that are defined in the same namespaces
507+ as the types they format and can be found with the argument-dependent lookup.
508+
509+ .. doxygenfunction :: print(std::basic_ostream<Char> &os, const S &format_str, Args&&... args)
520510
521511.. _printf-api :
522512
0 commit comments