fmt/doc/api.rst

314 lines
9.2 KiB
ReStructuredText
Raw Normal View History

2014-10-10 15:40:35 +00:00
.. _string-formatting-api:
*************
API Reference
*************
2018-03-10 17:25:17 +00:00
The {fmt} library API consists of the following parts:
2014-10-10 15:40:35 +00:00
2018-03-10 17:25:17 +00:00
* :ref:`fmt/core.h <core-api>`: the core API providing argument handling
facilities and a lightweight subset of formatting functions
* :ref:`fmt/format.h <format-api>`: the full format API providing compile-time
format string checks, output iterator and user-defined type support
* :ref:`fmt/time.h <time-api>`: date and time formatting
* :ref:`fmt/ostream.h <ostream-api>`: ``std::ostream`` support
* :ref:`fmt/printf.h <printf-api>`: ``printf`` formatting
All functions and types provided by the library reside in namespace ``fmt`` and
macros have prefix ``FMT_`` or ``fmt``.
.. _core-api:
Core API
========
``fmt/core.h`` defines the core API which provides argument handling facilities
and a lightweight subset of formatting functions.
2014-10-10 15:40:35 +00:00
2018-03-10 17:25:17 +00:00
The following functions use :ref:`format string syntax <syntax>`
imilar to that of Python's `str.format
2018-03-04 06:12:23 +00:00
<http://docs.python.org/3/library/stdtypes.html#str.format>`_.
2014-10-10 15:40:35 +00:00
They take *format_str* and *args* as arguments.
*format_str* 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.
2018-02-11 17:43:54 +00:00
*args* is an argument list representing objects to be formatted.
2014-10-10 15:40:35 +00:00
.. _format:
2018-02-11 17:43:54 +00:00
.. doxygenfunction:: format(string_view, const Args&...)
2018-03-10 17:25:17 +00:00
.. doxygenfunction:: vformat(string_view, format_args)
2014-10-10 15:40:35 +00:00
.. _print:
2018-02-11 17:43:54 +00:00
.. doxygenfunction:: print(string_view, const Args&...)
2018-03-10 17:25:17 +00:00
.. doxygenfunction:: vprint(string_view, format_args)
2014-10-10 15:40:35 +00:00
2018-02-11 17:43:54 +00:00
.. doxygenfunction:: print(std::FILE *, string_view, const Args&...)
2018-03-10 17:25:17 +00:00
.. doxygenfunction:: vprint(std::FILE *, string_view, format_args)
2015-12-18 15:16:40 +00:00
2018-03-10 17:25:17 +00:00
Named arguments
---------------
.. doxygenfunction:: fmt::arg(string_view, const T&)
2018-03-10 17:25:17 +00:00
Argument lists
--------------
2018-04-08 14:33:07 +00:00
.. doxygenfunction:: fmt::make_format_args(const Args&...)
2018-03-20 02:47:14 +00:00
2018-04-04 14:53:19 +00:00
.. doxygenclass:: fmt::format_arg_store
2018-03-16 20:04:12 +00:00
:members:
2018-03-10 17:25:17 +00:00
.. doxygenclass:: fmt::basic_format_args
:members:
2018-03-10 17:25:17 +00:00
.. doxygenstruct:: fmt::format_args
2018-04-04 14:53:19 +00:00
.. doxygenclass:: fmt::basic_format_arg
2018-03-20 02:47:14 +00:00
:members:
2018-03-10 17:25:17 +00:00
Compatibility
-------------
.. doxygenclass:: fmt::basic_string_view
:members:
2018-03-16 20:04:12 +00:00
.. doxygentypedef:: fmt::string_view
.. doxygentypedef:: fmt::wstring_view
2018-05-13 15:04:39 +00:00
.. _format-api:
2018-03-10 17:25:17 +00:00
Format API
==========
``fmt/format.h`` defines the full format API providing compile-time format
string checks, output iterator and user-defined type support.
Compile-time format string checks
---------------------------------
.. doxygendefine:: fmt
Formatting user-defined types
-----------------------------
To make a user-defined type formattable, specialize the ``formatter<T>`` struct
template and implement ``parse`` and ``format`` methods::
2018-03-10 17:25:17 +00:00
#include <fmt/format.h>
struct point { double x, y; };
namespace fmt {
template <>
struct formatter<point> {
template <typename ParseContext>
2018-03-04 17:16:51 +00:00
constexpr auto parse(ParseContext &ctx) { return ctx.begin(); }
template <typename FormatContext>
auto format(const point &p, FormatContext &ctx) {
return format_to(ctx.begin(), "({:.1f}, {:.1f})", p.x, p.y);
}
};
}
Then you can pass objects of type ``point`` to any formatting function::
point p = {1, 2};
std::string s = fmt::format("{}", p);
// s == "(1.0, 2.0)"
In the example above the ``formatter<point>::parse`` function ignores the
contents of the format string referred to by ``ctx.begin()`` so the object will
2018-02-11 21:43:16 +00:00
always be formatted in the same way. See ``formatter<tm>::parse`` in
:file:`fmt/time.h` for an advanced example of how to parse the format string and
customize the formatted output.
This section shows how to define a custom format function for a user-defined
type. The next section describes how to get ``fmt`` to use a conventional stream
output ``operator<<`` when one is defined for a user-defined type.
2018-03-10 17:25:17 +00:00
Output iterator support
-----------------------
2016-05-07 16:09:33 +00:00
2018-03-10 17:25:17 +00:00
.. doxygenfunction:: fmt::format_to(OutputIt, string_view, const Args&...)
2018-04-04 14:43:51 +00:00
.. doxygenfunction:: fmt::format_to_n(OutputIt, size_t, string_view, const Args&...)
2018-03-30 18:31:41 +00:00
.. doxygenstruct:: fmt::format_to_n_result
:members:
2016-05-07 16:09:33 +00:00
2018-03-10 17:25:17 +00:00
Literal-based API
-----------------
2016-05-07 16:09:33 +00:00
2018-03-10 17:25:17 +00:00
The following user-defined literals are defined in ``fmt/format.h``.
2016-05-07 16:09:33 +00:00
2018-03-10 17:25:17 +00:00
.. doxygenfunction:: operator""_format(const char *, std::size_t)
2016-05-07 16:09:33 +00:00
2018-03-10 17:25:17 +00:00
.. doxygenfunction:: operator""_a(const char *, std::size_t)
2016-05-07 16:09:33 +00:00
2018-03-10 17:25:17 +00:00
Utilities
---------
2016-05-07 16:09:33 +00:00
2018-03-10 17:25:17 +00:00
.. doxygenfunction:: fmt::to_string(const T&)
.. doxygenclass:: fmt::basic_memory_buffer
:protected-members:
:members:
System errors
-------------
.. doxygenclass:: fmt::system_error
:members:
.. doxygenfunction:: fmt::format_system_error
.. doxygenclass:: fmt::windows_error
:members:
.. _formatstrings:
Custom allocators
2018-03-04 20:09:34 +00:00
-----------------
2018-03-10 17:25:17 +00:00
The {fmt} library supports custom dynamic memory allocators.
A custom allocator class can be specified as a template argument to
:class:`fmt::basic_memory_buffer`::
2018-03-04 20:09:34 +00:00
2018-03-10 17:25:17 +00:00
using custom_memory_buffer =
fmt::basic_memory_buffer<char, fmt::inline_buffer_size, custom_allocator>;
2018-03-04 20:09:34 +00:00
2018-03-10 17:25:17 +00:00
It is also possible to write a formatting function that uses a custom
allocator::
using custom_string =
std::basic_string<char, std::char_traits<char>, custom_allocator>;
2018-03-04 20:09:34 +00:00
2018-03-10 17:25:17 +00:00
custom_string vformat(custom_allocator alloc, fmt::string_view format_str,
fmt::format_args args) {
custom_memory_buffer buf(alloc);
fmt::vformat_to(buf, format_str, args);
return custom_string(buf.data(), buf.size(), alloc);
}
template <typename ...Args>
inline custom_string format(custom_allocator alloc,
fmt::string_view format_str,
const Args & ... args) {
2018-04-08 14:33:07 +00:00
return vformat(alloc, format_str, fmt::make_format_args(args...));
2018-03-10 17:25:17 +00:00
}
2018-03-20 02:47:14 +00:00
2018-05-09 13:43:54 +00:00
The allocator will be used for the output container only. If you are using named
arguments, the container that stores pointers to them will be allocated using
the default allocator. Also floating-point formatting falls back on ``sprintf``
which may do allocations.
2018-03-04 20:09:34 +00:00
Custom formatting of built-in types
-----------------------------------
2016-04-20 14:16:52 +00:00
It is possible to change the way arguments are formatted by providing a
custom argument formatter class::
2018-03-04 06:12:23 +00:00
using arg_formatter =
fmt::arg_formatter<fmt::back_insert_range<fmt::internal::buffer>>;
// A custom argument formatter that formats negative integers as unsigned
// with the ``x`` format specifier.
2018-03-04 06:12:23 +00:00
class custom_arg_formatter : public arg_formatter {
2016-10-07 10:22:14 +00:00
public:
2018-04-08 14:33:07 +00:00
custom_arg_formatter(fmt::format_context &ctx, fmt::format_specs &spec)
2018-03-04 06:12:23 +00:00
: arg_formatter(ctx, spec) {}
using arg_formatter::operator();
2018-03-04 06:12:23 +00:00
void operator()(int value) {
if (spec().type() == 'x')
2018-03-04 06:12:23 +00:00
(*this)(static_cast<unsigned>(value)); // convert to unsigned and format
else
2018-03-04 06:12:23 +00:00
arg_formatter::operator()(value);
}
};
2018-03-04 06:12:23 +00:00
std::string custom_vformat(fmt::string_view format_str, fmt::format_args args) {
fmt::memory_buffer buffer;
// Pass custom argument formatter as a template arg to vformat_to.
fmt::vformat_to<custom_arg_formatter>(buffer, format_str, args);
2018-03-04 06:12:23 +00:00
return fmt::to_string(buffer);
}
template <typename ...Args>
inline std::string custom_format(
fmt::string_view format_str, const Args &... args) {
2018-04-08 14:33:07 +00:00
return custom_vformat(format_str, fmt::make_format_args(args...));
}
std::string s = custom_format("{:x}", -42); // s == "ffffffd6"
2018-03-04 06:12:23 +00:00
.. doxygenclass:: fmt::arg_formatter
2016-04-20 14:16:52 +00:00
:members:
2018-03-10 17:25:17 +00:00
.. _time-api:
Date and time formatting
========================
The library supports `strftime
<http://en.cppreference.com/w/cpp/chrono/c/strftime>`_-like date and time
formatting::
#include <fmt/time.h>
std::time_t t = std::time(nullptr);
// Prints "The date is 2016-04-29." (with the current date)
fmt::print("The date is {:%Y-%m-%d}.", *std::localtime(&t));
The format string syntax is described in the documentation of
`strftime <http://en.cppreference.com/w/cpp/chrono/c/strftime>`_.
.. _ostream-api:
``std::ostream`` support
========================
``fmt/ostream.h`` provides ``std::ostream`` support including formatting of
user-defined types that have overloaded ``operator<<``::
#include <fmt/ostream.h>
class date {
int year_, month_, day_;
public:
date(int year, int month, int day): year_(year), month_(month), day_(day) {}
friend std::ostream &operator<<(std::ostream &os, const date &d) {
return os << d.year_ << '-' << d.month_ << '-' << d.day_;
}
};
std::string s = fmt::format("The date is {}", date(2012, 12, 9));
// s == "The date is 2012-12-9"
.. doxygenfunction:: print(std::ostream&, string_view, const Args&...)
.. _printf-api:
``printf`` formatting
=====================
2014-10-10 15:40:35 +00:00
The header ``fmt/printf.h`` provides ``printf``-like formatting functionality.
2014-10-10 15:40:35 +00:00
The following functions use `printf format string syntax
<http://pubs.opengroup.org/onlinepubs/009695399/functions/fprintf.html>`_ with
the POSIX extension for positional arguments. Unlike their standard
counterparts, the ``fmt`` functions are type-safe and throw an exception if an
argument type doesn't match its format specification.
2014-10-10 15:40:35 +00:00
2018-02-11 21:43:16 +00:00
.. doxygenfunction:: printf(string_view, const Args&...)
2014-10-10 15:40:35 +00:00
2018-02-11 21:43:16 +00:00
.. doxygenfunction:: fprintf(std::FILE *, string_view, const Args&...)
2018-02-11 21:43:16 +00:00
.. doxygenfunction:: fprintf(std::ostream&, string_view, const Args&...)
2016-08-03 15:52:05 +00:00
2018-02-11 21:43:16 +00:00
.. doxygenfunction:: sprintf(string_view, const Args&...)