+Core API
+fmt/core.h defines the core API which provides main formatting functions
+for char/UTF-8 with C++20 compile-time checks. It has minimal include
+dependencies for better compile times. This header is only beneficial when
+using {fmt} as a library (the default) and not in the header-only mode.
+It also provides formatter specializations for built-in and string types.
+The following functions use format string syntax
+similar to that of Python’s str.format.
+They take fmt and args as arguments.
+fmt is a format string that contains literal text and replacement fields
+surrounded by braces {}. The fields are replaced with formatted arguments
+in the resulting string. format_string is a format string which can be
+implicitly constructed from a string literal or a constexpr string and is
+checked at compile time in C++20. To pass a runtime format string wrap it in
+fmt::runtime().
+args is an argument list representing objects to be formatted.
+
+-
+template<typename ...
T>
auto fmt::format(format_string<T...> fmt, T&&... args) -> std::string
+Formats args according to specifications in fmt and returns the result
+as a string.
+Example:
+#include <fmt/core.h>
+std::string message = fmt::format("The answer is {}.", 42);
+
+
+
+
+-
+auto
fmt::vformat(string_view fmt, format_args args) -> std::string
+
+
+
+-
+template<typename
OutputIt, typename ...T>
auto fmt::format_to(OutputIt out, format_string<T...> fmt, T&&... args) -> OutputIt
+Formats args according to specifications in fmt, writes the result to
+the output iterator out and returns the iterator past the end of the output
+range. format_to() does not append a terminating null character.
+Example:
+auto out = std::vector<char>();
+fmt::format_to(std::back_inserter(out), "{}", 42);
+
+
+
+
+-
+template<typename
OutputIt, typename ...T>
auto fmt::format_to_n(OutputIt out, size_t n, format_string<T...> fmt, T&&... args) -> format_to_n_result<OutputIt>
+Formats args according to specifications in fmt, writes up to n
+characters of the result to the output iterator out and returns the total
+(not truncated) output size and the iterator past the end of the output range.
+format_to_n() does not append a terminating null character.
+
+
+
+
+
+-
+template<typename ...
T>
auto fmt::formatted_size(format_string<T...> fmt, T&&... args) -> size_t
+Returns the number of chars in the output of format(fmt, args...).
+
+
+
+-
+template<typename
OutputIt>
struct fmt::format_to_n_result
+
+
Public Members
+
+-
+OutputIt
out
+Iterator past the end of the output range.
+
+
+
+-
+size_t
size
+Total (not truncated) output size.
+
+
+
+
+
+-
+template<typename ...
T>
void fmt::print(format_string<T...> fmt, T&&... args)
+Formats args according to specifications in fmt and writes the output
+to stdout.
+Example:
+fmt::print("Elapsed time: {0:.2f} seconds", 1.23);
+
+
+
+
+-
+void
fmt::vprint(string_view fmt, format_args args)
+
+
+
+-
+template<typename ...
T>
void fmt::print(std::FILE *f, format_string<T...> fmt, T&&... args)
+Formats args according to specifications in fmt and writes the
+output to the file f.
+Example:
+fmt::print(stderr, "Don't {}!", "panic");
+
+
+
+
+-
+void
fmt::vprint(std::FILE *f, string_view fmt, format_args args)
+
+
+
+
+
+Named Arguments
+
+-
+template<typename
Char, typename T>
auto fmt::arg(const Char *name, const T &arg) -> detail::named_arg<Char, T>
+Returns a named argument to be used in a formatting function.
+It should only be used in a call to a formatting function or
+dynamic_format_arg_store::push_back().
+Example:
+fmt::print("Elapsed time: {s:.2f} seconds", fmt::arg("s", 1.23));
+
+
+
+Named arguments are not supported in compile-time checks at the moment.
+
+
+Argument Lists
+You can create your own formatting function with compile-time checks and small
+binary footprint, for example (https://godbolt.org/z/vajfWEG4b):
+#include <fmt/core.h>
+
+void vlog(const char* file, int line, fmt::string_view format,
+ fmt::format_args args) {
+ fmt::print("{}: {}: ", file, line);
+ fmt::vprint(format, args);
+}
+
+template <typename... T>
+void log(const char* file, int line, fmt::format_string<T...> format, T&&... args) {
+ vlog(file, line, format, fmt::make_format_args(args...));
+}
+
+#define MY_LOG(format, ...) log(__FILE__, __LINE__, format, __VA_ARGS__)
+
+MY_LOG("invalid squishiness: {}", 42);
+
+
Note that vlog is not parameterized on argument types which improves compile
+times and reduces binary code size compared to a fully parameterized version.
+
+-
+template<typename
Context = format_context, typename ...T>
constexpr auto fmt::make_format_args(T&... args) -> format_arg_store<Context, remove_cvref_t<T>...>
+Constructs a format_arg_store object that contains references to
+arguments and can be implicitly converted to format_args. Context
+can be omitted in which case it defaults to format_context.
+See arg() for lifetime considerations.
+
+
+
+
+
+-
+template<typename
Context, typename ...Args>
class format_arg_store
+An array of references to arguments. It can be implicitly converted into
+basic_format_args for passing into type-erased formatting functions
+such as vformat().
+
+
+
+
+
+-
+template<typename
Context>
class fmt::basic_format_args
+A view of a collection of formatting arguments. To avoid lifetime issues it
+should only be used as a parameter type in type-erased functions such as
+vformat:
+void vlog(string_view format_str, format_args args); // OK
+format_args args = make_format_args(); // Error: dangling reference
+
+
+
+
+-
+using
fmt::format_args = basic_format_args<format_context>
+An alias to basic_format_args<format_context>.
+
+
+
+-
+template<typename
Context>
class basic_format_arg
+
+
+
+-
+template<typename
Char>
class fmt::basic_format_parse_context
+Parsing context consisting of a format string range being parsed and an
+argument counter for automatic indexing.
+You can use the format_parse_context type alias for char instead.
+
+
+Subclassed by fmt::detail::compile_parse_context< Char >
+
+
Public Functions
+
+-
+constexpr auto
begin() const noexcept -> iterator
+Returns an iterator to the beginning of the format string range being parsed.
+
+
+
+-
+constexpr auto
end() const noexcept -> iterator
+Returns an iterator past the end of the format string range being parsed.
+
+
+
+-
+void
advance_to(iterator it)
+Advances the begin iterator to it.
+
+
+
+-
+auto
next_arg_id() -> int
+Reports an error if using the manual argument indexing; otherwise returns the next argument index and switches to the automatic indexing.
+
+
+
+-
+void
check_arg_id(int id)
+Reports an error if using the automatic argument indexing; otherwise switches to the manual indexing.
+
+
+
+
+
+-
+template<typename
OutputIt, typename Char>
class fmt::basic_format_context
+
+
Public Types
+
+-
+using
char_type = Char
+The character type for the output.
+
+
+
+
Public Functions
+
+-
+constexpr
basic_format_context(OutputIt out, format_args ctx_args, detail::locale_ref loc = {})
+Constructs a basic_format_context object.
+References to the arguments are stored in the object so make sure they have appropriate lifetimes.
+
+
+
+
+
+-
+using
fmt::format_context = buffer_context<char>
+
+
+
+
+Dynamic Argument Lists
+The header fmt/args.h provides dynamic_format_arg_store, a builder-like
+API that can be used to construct format argument lists dynamically.
+
+-
+template<typename
Context>
class fmt::dynamic_format_arg_store
+A dynamic version of fmt::format_arg_store.
+It’s equipped with a storage to potentially temporary objects which lifetimes
+could be shorter than the format arguments object.
+It can be implicitly converted into basic_format_args for passing
+into type-erased formatting functions such as vformat().
+
+
+
+
Public Functions
+
+-
+template<typename
T>
void push_back(const T &arg)
+Adds an argument into the dynamic store for later passing to a formatting
+function.
+Note that custom types and string types (but not string views) are copied
+into the store dynamically allocating memory if necessary.
+Example:
+fmt::dynamic_format_arg_store<fmt::format_context> store;
+store.push_back(42);
+store.push_back("abc");
+store.push_back(1.5f);
+std::string result = fmt::vformat("{} and {} and {}", store);
+
+
+
+
+-
+template<typename
T>
void push_back(std::reference_wrapper<T> arg)
+Adds a reference to the argument into the dynamic store for later passing to
+a formatting function.
+Example:
+fmt::dynamic_format_arg_store<fmt::format_context> store;
+char band[] = "Rolling Stones";
+store.push_back(std::cref(band));
+band[9] = 'c'; // Changing str affects the output.
+std::string result = fmt::vformat("{}", store);
+// result == "Rolling Scones"
+
+
+
+
+-
+template<typename
T>
void push_back(const detail::named_arg<char_type, T> &arg)
+Adds named argument into the dynamic store for later passing to a formatting function.
+std::reference_wrapper is supported to avoid copying of the argument. The name is always copied into the store.
+
+
+
+-
+void
clear()
+Erase all elements from the store.
+
+
+
+-
+void
reserve(size_t new_cap, size_t new_cap_named)
+Reserves space to store at least new_cap arguments including
+new_cap_named named arguments.
+
+
+
+
+
+
+
+
+Compatibility
+
+-
+template<typename
Char>
class fmt::basic_string_view
+An implementation of std::basic_string_view for pre-C++17.
+It provides a subset of the API. fmt::basic_string_view is used for format strings even if std::string_view is available to prevent issues when a library is compiled with a different -std option than the client code (which is not recommended).
+
+
Public Functions
+
+-
+constexpr
basic_string_view(const Char *s, size_t count) noexcept
+Constructs a string reference object from a C string and a size.
+
+
+
+-
+
basic_string_view(const Char *s)
+Constructs a string reference object from a C string computing
+the size with std::char_traits<Char>::length.
+
+
+
+
+
+-
+template<typename
Traits, typename Alloc>
basic_string_view(const std::basic_string<Char, Traits, Alloc> &s) noexcept
+Constructs a string reference from a std::basic_string object.
+
+
+
+-
+constexpr auto
data() const noexcept -> const Char*
+Returns a pointer to the string data.
+
+
+
+-
+constexpr auto
size() const noexcept -> size_t
+Returns the string size.
+
+
+
+
+
+-
+using
fmt::string_view = basic_string_view<char>
+
+
+
+
+
+Terminal Color and Text Style
+fmt/color.h provides support for terminal color and text style output.
+
+-
+template<typename
S, typename ...Args>
void fmt::print(const text_style &ts, const S &format_str, const Args&... args)
+Formats a string and prints it to stdout using ANSI escape sequences to
+specify text formatting.
+Example:
+fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
+ "Elapsed time: {0:.2f} seconds", 1.23);
+
+
+
+
+-
+text_style
fmt::fg(detail::color_type foreground) noexcept
+Creates a text style from the foreground (text) color.
+
+
+
+-
+text_style
fmt::bg(detail::color_type background) noexcept
+Creates a text style from the background color.
+
+
+
+-
+template<typename
T>
auto fmt::styled(const T &value, text_style ts) -> detail::styled_arg<remove_cvref_t<T>>
+Returns an argument that will be formatted using ANSI escape sequences,
+to be used in a formatting function.
+Example:
+fmt::print("Elapsed time: {0:.2f} seconds",
+ fmt::styled(1.23, fmt::fg(fmt::color::green) |
+ fmt::bg(fmt::color::blue)));
+
+
+
+
+