WPILibC++ 2024.3.1
format.h File Reference
#include <cmath>
#include <cstdint>
#include <cstring>
#include <initializer_list>
#include <limits>
#include <memory>
#include <stdexcept>
#include <system_error>
#include "core.h"

Go to the source code of this file.

Classes

struct  disjunction<... >
 
struct  disjunction< P >
 
struct  disjunction< P1, Pn... >
 
struct  conjunction<... >
 
struct  conjunction< P >
 
struct  conjunction< P1, Pn... >
 
struct  detail::string_literal< CharT, C >
 
class  detail::formatbuf< Streambuf >
 
class  detail::uint128_fallback
 
struct  detail::is_integral< T >
 
struct  detail::is_integral< int128_opt >
 
struct  detail::is_integral< uint128_t >
 
class  basic_memory_buffer< T, SIZE, Allocator >
 \rst A dynamically growing memory buffer for trivially copyable/constructible types with the first SIZE elements stored in the object itself. More...
 
struct  is_contiguous< basic_memory_buffer< T, SIZE, Allocator > >
 
class  loc_value
 
class  format_facet< Locale >
 
struct  detail::thousands_sep_result< Char >
 
struct  detail::format_decimal_result< Iterator >
 
class  detail::utf8_to_utf16
 
class  detail::to_utf8< WChar, Buffer >
 
struct  detail::dragonbox::float_info< float >
 
struct  detail::dragonbox::float_info< double >
 
struct  detail::dragonbox::float_info< T, enable_if_t< std::numeric_limits< T >::digits==64||std::numeric_limits< T >::digits==113||is_float128< T >::value > >
 
struct  detail::dragonbox::float_info< T, enable_if_t< is_double_double< T >::value > >
 
struct  detail::dragonbox::decimal_fp< T >
 
struct  detail::basic_fp< F >
 
struct  detail::basic_data< T >
 
struct  detail::data
 
struct  detail::find_escape_result< Char >
 
struct  detail::write_int_data< Char >
 
class  detail::digit_grouping< Char >
 
struct  detail::write_int_arg< UInt >
 
struct  detail::loc_writer< Char >
 
class  detail::counting_iterator
 
struct  detail::counting_iterator::value_type
 
struct  detail::float_specs
 
struct  detail::big_decimal_fp
 
class  detail::fallback_digit_grouping< Char >
 
struct  detail::has_isfinite< T, Enable >
 
struct  detail::has_isfinite< T, enable_if_t< sizeof(std::isfinite(T())) !=0 > >
 
class  detail::bigint
 
struct  detail::default_arg_formatter< Char >
 
struct  detail::arg_formatter< Char >
 
struct  detail::custom_formatter< Char >
 
class  detail::width_checker< ErrorHandler >
 
class  detail::precision_checker< ErrorHandler >
 
class  format_int
 Fast integer formatter. More...
 
struct  formatter< T, Char, enable_if_t< detail::has_format_as< T >::value > >
 
struct  formatter< Char[N], Char >
 
class  bytes
 
struct  formatter< bytes >
 
struct  group_digits_view< T >
 
struct  formatter< group_digits_view< T > >
 
struct  join_view< It, Sentinel, Char >
 
struct  formatter< join_view< It, Sentinel, Char >, Char >
 

Namespaces

namespace  detail
 detail namespace with internal helper functions
 
namespace  detail_exported
 An error reported from a formatting function.
 
namespace  detail::dragonbox
 
namespace  enums
 

Macros

#define FMT_INLINE_VARIABLE
 
#define FMT_FALLTHROUGH
 
#define FMT_DEPRECATED   /* deprecated */
 
#define FMT_NO_UNIQUE_ADDRESS
 
#define FMT_VISIBILITY(value)
 
#define FMT_HAS_BUILTIN(x)   0
 
#define FMT_NOINLINE
 
#define FMT_THROW(x)   throw x
 
#define FMT_TRY   try
 
#define FMT_CATCH(x)   catch (x)
 
#define FMT_MAYBE_UNUSED
 
#define FMT_USE_USER_DEFINED_LITERALS   0
 
#define FMT_REDUCE_INT_INSTANTIATIONS   0
 
#define FMT_USE_FLOAT   1
 
#define FMT_USE_DOUBLE   1
 
#define FMT_USE_LONG_DOUBLE   1
 
#define FMT_USE_FLOAT128   0
 
#define FMT_USE_FULL_CACHE_DRAGONBOX   0
 
#define FMT_POWERS_OF_10(factor)
 
#define FMT_STRING_IMPL(s, base, explicit)
 
#define FMT_STRING(s)   FMT_STRING_IMPL(s, fmt::detail::compile_string, )
 \rst Constructs a compile-time format string from a string literal s. More...
 
#define FMT_FORMAT_AS(Type, Base)
 
#define FMT_FUNC
 

Typedefs

using detail::uint128_t = conditional_t< FMT_USE_INT128, uint128_opt, uint128_fallback >
 
using detail::uintptr_t = uint128_t
 
template<typename T >
using detail::iterator_t = decltype(std::begin(std::declval< T & >()))
 
template<typename T >
using detail::sentinel_t = decltype(std::end(std::declval< T & >()))
 
template<typename OutputIt >
using detail::reserve_iterator = remove_reference_t< decltype(reserve(std::declval< OutputIt & >(), 0))>
 
template<typename T >
using detail::is_signed = std::integral_constant< bool, std::numeric_limits< T >::is_signed||std::is_same< T, int128_opt >::value >
 
template<typename T >
using detail::is_integer = bool_constant< is_integral< T >::value &&!std::is_same< T, bool >::value &&!std::is_same< T, char >::value &&!std::is_same< T, wchar_t >::value >
 
using detail::float128 = void
 
template<typename T >
using detail::is_float128 = std::is_same< T, float128 >
 
template<typename T >
using detail::is_floating_point = bool_constant< std::is_floating_point< T >::value||is_float128< T >::value >
 
using memory_buffer = basic_memory_buffer< char >
 
template<typename T >
using detail::uint32_or_64_or_128_t = conditional_t< num_bits< T >()<=32 &&!FMT_REDUCE_INT_INSTANTIATIONS, uint32_t, conditional_t< num_bits< T >()<=64, uint64_t, uint128_t > >
 
template<typename T >
using detail::uint64_or_128_t = conditional_t< num_bits< T >()<=64, uint64_t, uint128_t >
 
using detail::fp = basic_fp< unsigned long long >
 
template<typename T , bool doublish = num_bits<T>() == num_bits<double>()>
using detail::convert_float_result = conditional_t< std::is_same< T, float >::value||doublish, double, T >
 
template<typename Char >
using detail::make_unsigned_char = typename conditional_t< std::is_integral< Char >::value, std::make_unsigned< Char >, type_identity< uint32_t > >::type
 
using detail::format_func = void(*)(detail::buffer< char > &, int, const char *)
 

Enumerations

enum  detail::char8_type : unsigned char
 
enum  { inline_buffer_size = 500 }
 
enum class  detail::to_utf8_error_policy { detail::abort , detail::replace }
 
enum class  detail::float_format : unsigned char { detail::general , detail::exp , detail::fixed , detail::hex }
 
enum  detail::dragon { detail::predecessor_closer = 1 , detail::fixup = 2 , detail::fixed = 4 }
 

Functions

FMT_CONSTEXPR void detail::abort_fuzzing_if (bool condition)
 
template<typename To , typename From , FMT_ENABLE_IF(sizeof(To)==sizeof(From)) >
FMT_CONSTEXPR20 auto detail::bit_cast (const From &from) -> To
 
auto detail::is_big_endian () -> bool
 
template<typename T >
constexpr auto detail::max_value () -> T
 
template<typename T >
constexpr auto detail::num_bits () -> int
 
template<>
constexpr auto detail::num_bits< int128_opt > () -> int
 
template<>
constexpr auto detail::num_bits< uint128_t > () -> int
 
template<typename To , typename From , FMT_ENABLE_IF(sizeof(To) > sizeof(From)) >
auto detail::bit_cast (const From &from) -> To
 
template<typename UInt >
FMT_CONSTEXPR20 auto detail::countl_zero_fallback (UInt n) -> int
 
FMT_CONSTEXPR20 auto detail::countl_zero (uint32_t n) -> int
 
FMT_CONSTEXPR20 auto detail::countl_zero (uint64_t n) -> int
 
FMT_INLINE void detail::assume (bool condition)
 
template<typename Char >
auto detail::get_data (std::basic_string< Char > &s) -> Char *
 
template<typename Container >
auto detail::get_data (Container &c) -> typename Container::value_type *
 
template<typename Container , FMT_ENABLE_IF(is_contiguous< Container >::value) >
auto detail::reserve (std::back_insert_iterator< Container > it, size_t n) -> typename Container::value_type *
 
template<typename T >
auto detail::reserve (buffer_appender< T > it, size_t n) -> buffer_appender< T >
 
template<typename Iterator >
constexpr auto detail::reserve (Iterator &it, size_t) -> Iterator &
 
template<typename T , typename OutputIt >
constexpr auto detail::to_pointer (OutputIt, size_t) -> T *
 
template<typename T >
auto detail::to_pointer (buffer_appender< T > it, size_t n) -> T *
 
template<typename Container , FMT_ENABLE_IF(is_contiguous< Container >::value) >
auto detail::base_iterator (std::back_insert_iterator< Container > it, typename Container::value_type *) -> std::back_insert_iterator< Container >
 
template<typename Iterator >
constexpr auto detail::base_iterator (Iterator, Iterator it) -> Iterator
 
template<typename OutputIt , typename Size , typename T >
FMT_CONSTEXPR auto detail::fill_n (OutputIt out, Size count, const T &value) -> OutputIt
 
template<typename T , typename Size >
FMT_CONSTEXPR20 auto detail::fill_n (T *out, Size count, char value) -> T *
 
template<typename OutChar , typename InputIt , typename OutputIt >
FMT_CONSTEXPR FMT_NOINLINE auto detail::copy_str_noinline (InputIt begin, InputIt end, OutputIt out) -> OutputIt
 
FMT_CONSTEXPR auto detail::utf8_decode (const char *s, uint32_t *c, int *e) -> const char *
 
template<typename F >
FMT_CONSTEXPR void detail::for_each_codepoint (string_view s, F f)
 
template<typename Char >
auto detail::compute_width (basic_string_view< Char > s) -> size_t
 
FMT_CONSTEXPR size_t detail::compute_width (string_view s)
 
auto detail::compute_width (basic_string_view< char8_type > s) -> size_t
 
template<typename Char >
auto detail::code_point_index (basic_string_view< Char > s, size_t n) -> size_t
 
auto detail::code_point_index (string_view s, size_t n) -> size_t
 
auto detail::code_point_index (basic_string_view< char8_type > s, size_t n) -> size_t
 
FMT_API bool detail::write_console (std::FILE *f, string_view text)
 
FMT_API void detail::print (std::FILE *, string_view)
 
template<typename Char , size_t N>
constexpr auto detail_exported::compile_string_to_view (const Char(&s)[N]) -> basic_string_view< Char >
 
template<typename Char >
constexpr auto detail_exported::compile_string_to_view (detail::std_string_view< Char > s) -> basic_string_view< Char >
 
template<typename T , FMT_ENABLE_IF(is_signed< T >::value) >
constexpr auto detail::is_negative (T value) -> bool
 
template<typename T >
FMT_CONSTEXPR auto detail::is_supported_floating_point (T) -> bool
 
constexpr const char * detail::digits2 (size_t value)
 
template<typename Char , typename Sign >
constexpr Char detail::sign (Sign s)
 
template<typename T >
FMT_CONSTEXPR auto detail::count_digits_fallback (T n) -> int
 
FMT_CONSTEXPR20 auto detail::count_digits (uint64_t n) -> int
 
template<int BITS, typename UInt >
FMT_CONSTEXPR auto detail::count_digits (UInt n) -> int
 
FMT_CONSTEXPR20 auto detail::count_digits (uint32_t n) -> int
 
template<typename Int >
constexpr auto detail::digits10 () noexcept -> int
 
template<>
constexpr auto detail::digits10< int128_opt > () noexcept -> int
 
template<>
constexpr auto detail::digits10< uint128_t > () noexcept -> int
 
template<typename Char >
FMT_API auto detail::thousands_sep_impl (locale_ref loc) -> thousands_sep_result< Char >
 
template<typename Char >
auto detail::thousands_sep (locale_ref loc) -> thousands_sep_result< Char >
 
template<>
auto detail::thousands_sep (locale_ref loc) -> thousands_sep_result< wchar_t >
 
template<typename Char >
FMT_API auto detail::decimal_point_impl (locale_ref loc) -> Char
 
template<typename Char >
auto detail::decimal_point (locale_ref loc) -> Char
 
template<>
auto detail::decimal_point (locale_ref loc) -> wchar_t
 
template<typename Char >
auto detail::equal2 (const Char *lhs, const char *rhs) -> bool
 
auto detail::equal2 (const char *lhs, const char *rhs) -> bool
 
template<typename Char >
FMT_CONSTEXPR20 FMT_INLINE void detail::copy2 (Char *dst, const char *src)
 
template<typename Char , typename UInt >
FMT_CONSTEXPR20 auto detail::format_decimal (Char *out, UInt value, int size) -> format_decimal_result< Char * >
 
template<typename Char , typename UInt , typename Iterator , FMT_ENABLE_IF(!std::is_pointer< remove_cvref_t< Iterator > >::value) >
FMT_CONSTEXPR auto detail::format_decimal (Iterator out, UInt value, int size) -> format_decimal_result< Iterator >
 
template<unsigned BASE_BITS, typename Char , typename UInt >
FMT_CONSTEXPR auto detail::format_uint (Char *buffer, UInt value, int num_digits, bool upper=false) -> Char *
 
template<unsigned BASE_BITS, typename Char , typename It , typename UInt >
FMT_CONSTEXPR auto detail::format_uint (It out, UInt value, int num_digits, bool upper=false) -> It
 
uint128_fallback detail::umul128 (uint64_t x, uint64_t y) noexcept
 
int detail::dragonbox::floor_log10_pow2 (int e) noexcept
 
int detail::dragonbox::floor_log2_pow10 (int e) noexcept
 
uint64_t detail::dragonbox::umul128_upper64 (uint64_t x, uint64_t y) noexcept
 
uint128_fallback detail::dragonbox::umul192_upper128 (uint64_t x, uint128_fallback y) noexcept
 
FMT_API uint128_fallback detail::dragonbox::get_cached_power (int k) noexcept
 
template<typename T >
FMT_API auto detail::dragonbox::to_decimal (T x) noexcept -> decimal_fp< T >
 
template<typename Float >
constexpr bool detail::has_implicit_bit ()
 
template<typename Float >
constexpr int detail::num_significand_bits ()
 
template<typename Float >
constexpr auto detail::exponent_mask () -> typename dragonbox::float_info< Float >::carrier_uint
 
template<typename Float >
constexpr auto detail::exponent_bias () -> int
 
template<typename Char , typename It >
FMT_CONSTEXPR auto detail::write_exponent (int exp, It it) -> It
 
template<int SHIFT = 0, typename F >
FMT_CONSTEXPR basic_fp< F > detail::normalize (basic_fp< F > value)
 
FMT_CONSTEXPR uint64_t detail::multiply (uint64_t lhs, uint64_t rhs)
 
FMT_CONSTEXPR fp detail::operator* (fp x, fp y)
 
template<typename T >
constexpr auto detail::convert_float (T value) -> convert_float_result< T >
 
template<typename OutputIt , typename Char >
FMT_NOINLINE FMT_CONSTEXPR auto detail::fill (OutputIt it, size_t n, const fill_t< Char > &fill) -> OutputIt
 
template<align::type align = align::left, typename OutputIt , typename Char , typename F >
FMT_CONSTEXPR auto detail::write_padded (OutputIt out, const format_specs< Char > &specs, size_t size, size_t width, F &&f) -> OutputIt
 
template<align::type align = align::left, typename OutputIt , typename Char , typename F >
constexpr auto detail::write_padded (OutputIt out, const format_specs< Char > &specs, size_t size, F &&f) -> OutputIt
 
template<align::type align = align::left, typename Char , typename OutputIt >
FMT_CONSTEXPR auto detail::write_bytes (OutputIt out, string_view bytes, const format_specs< Char > &specs) -> OutputIt
 
template<typename Char , typename OutputIt , typename UIntPtr >
auto detail::write_ptr (OutputIt out, UIntPtr value, const format_specs< Char > *specs) -> OutputIt
 
FMT_API auto detail::is_printable (uint32_t cp) -> bool
 
auto detail::needs_escape (uint32_t cp) -> bool
 
template<typename Char >
auto detail::find_escape (const Char *begin, const Char *end) -> find_escape_result< Char >
 
auto detail::find_escape (const char *begin, const char *end) -> find_escape_result< char >
 
template<size_t width, typename Char , typename OutputIt >
auto detail::write_codepoint (OutputIt out, char prefix, uint32_t cp) -> OutputIt
 
template<typename OutputIt , typename Char >
auto detail::write_escaped_cp (OutputIt out, const find_escape_result< Char > &escape) -> OutputIt
 
template<typename Char , typename OutputIt >
auto detail::write_escaped_string (OutputIt out, basic_string_view< Char > str) -> OutputIt
 
template<typename Char , typename OutputIt >
auto detail::write_escaped_char (OutputIt out, Char v) -> OutputIt
 
template<typename Char , typename OutputIt >
FMT_CONSTEXPR auto detail::write_char (OutputIt out, Char value, const format_specs< Char > &specs) -> OutputIt
 
template<typename Char , typename OutputIt >
FMT_CONSTEXPR auto detail::write (OutputIt out, Char value, const format_specs< Char > &specs, locale_ref loc={}) -> OutputIt
 
template<typename OutputIt , typename Char , typename W >
FMT_CONSTEXPR FMT_INLINE auto detail::write_int (OutputIt out, int num_digits, unsigned prefix, const format_specs< Char > &specs, W write_digits) -> OutputIt
 
template<typename OutputIt , typename UInt , typename Char >
auto detail::write_int (OutputIt out, UInt value, unsigned prefix, const format_specs< Char > &specs, const digit_grouping< Char > &grouping) -> OutputIt
 
FMT_API auto detail::write_loc (appender out, loc_value value, const format_specs<> &specs, locale_ref loc) -> bool
 
template<typename OutputIt , typename Char >
auto detail::write_loc (OutputIt, loc_value, const format_specs< Char > &, locale_ref) -> bool
 
FMT_CONSTEXPR void detail::prefix_append (unsigned &prefix, unsigned value)
 
template<typename T >
FMT_CONSTEXPR auto detail::make_write_int_arg (T value, sign_t sign) -> write_int_arg< uint32_or_64_or_128_t< T > >
 
template<typename Char , typename OutputIt , typename T >
FMT_CONSTEXPR FMT_INLINE auto detail::write_int (OutputIt out, write_int_arg< T > arg, const format_specs< Char > &specs, locale_ref) -> OutputIt
 
template<typename Char , typename OutputIt , typename T >
FMT_CONSTEXPR FMT_NOINLINE auto detail::write_int_noinline (OutputIt out, write_int_arg< T > arg, const format_specs< Char > &specs, locale_ref loc) -> OutputIt
 
template<typename Char , typename OutputIt , typename T , FMT_ENABLE_IF(is_integral< T >::value && !std::is_same< T, bool >::value && std::is_same< OutputIt, buffer_appender< Char > >::value) >
FMT_CONSTEXPR FMT_INLINE auto detail::write (OutputIt out, T value, const format_specs< Char > &specs, locale_ref loc) -> OutputIt
 
template<typename Char , typename OutputIt >
FMT_CONSTEXPR auto detail::write (OutputIt out, basic_string_view< Char > s, const format_specs< Char > &specs) -> OutputIt
 
template<typename Char , typename OutputIt >
FMT_CONSTEXPR auto detail::write (OutputIt out, basic_string_view< type_identity_t< Char > > s, const format_specs< Char > &specs, locale_ref) -> OutputIt
 
template<typename Char , typename OutputIt >
FMT_CONSTEXPR auto detail::write (OutputIt out, const Char *s, const format_specs< Char > &specs, locale_ref) -> OutputIt
 
template<typename Char , typename OutputIt , typename T , FMT_ENABLE_IF(is_integral< T >::value && !std::is_same< T, bool >::value && !std::is_same< T, Char >::value) >
FMT_CONSTEXPR auto detail::write (OutputIt out, T value) -> OutputIt
 
template<typename Char >
FMT_CONSTEXPR auto detail::parse_align (const Char *begin, const Char *end, format_specs< Char > &specs) -> const Char *
 
template<typename ErrorHandler = error_handler, typename Char >
FMT_CONSTEXPR auto detail::parse_float_type_spec (const format_specs< Char > &specs, ErrorHandler &&eh={}) -> float_specs
 
template<typename Char , typename OutputIt >
FMT_CONSTEXPR20 auto detail::write_nonfinite (OutputIt out, bool isnan, format_specs< Char > specs, const float_specs &fspecs) -> OutputIt
 
constexpr auto detail::get_significand_size (const big_decimal_fp &f) -> int
 
template<typename T >
auto detail::get_significand_size (const dragonbox::decimal_fp< T > &f) -> int
 
template<typename Char , typename OutputIt >
constexpr auto detail::write_significand (OutputIt out, const char *significand, int significand_size) -> OutputIt
 
template<typename Char , typename OutputIt , typename UInt >
auto detail::write_significand (OutputIt out, UInt significand, int significand_size) -> OutputIt
 
template<typename Char , typename OutputIt , typename T , typename Grouping >
FMT_CONSTEXPR20 auto detail::write_significand (OutputIt out, T significand, int significand_size, int exponent, const Grouping &grouping) -> OutputIt
 
template<typename Char , typename UInt , FMT_ENABLE_IF(std::is_integral< UInt >::value) >
auto detail::write_significand (Char *out, UInt significand, int significand_size, int integral_size, Char decimal_point) -> Char *
 
template<typename OutputIt , typename UInt , typename Char , FMT_ENABLE_IF(!std::is_pointer< remove_cvref_t< OutputIt > >::value) >
auto detail::write_significand (OutputIt out, UInt significand, int significand_size, int integral_size, Char decimal_point) -> OutputIt
 
template<typename OutputIt , typename Char >
FMT_CONSTEXPR auto detail::write_significand (OutputIt out, const char *significand, int significand_size, int integral_size, Char decimal_point) -> OutputIt
 
template<typename OutputIt , typename Char , typename T , typename Grouping >
FMT_CONSTEXPR20 auto detail::write_significand (OutputIt out, T significand, int significand_size, int integral_size, Char decimal_point, const Grouping &grouping) -> OutputIt
 
template<typename OutputIt , typename DecimalFP , typename Char , typename Grouping = digit_grouping<Char>>
FMT_CONSTEXPR20 auto detail::do_write_float (OutputIt out, const DecimalFP &f, const format_specs< Char > &specs, float_specs fspecs, locale_ref loc) -> OutputIt
 
template<typename OutputIt , typename DecimalFP , typename Char >
FMT_CONSTEXPR20 auto detail::write_float (OutputIt out, const DecimalFP &f, const format_specs< Char > &specs, float_specs fspecs, locale_ref loc) -> OutputIt
 
template<typename T >
constexpr bool detail::isnan (T value)
 
template<typename T , FMT_ENABLE_IF(std::is_floating_point< T >::value && has_isfinite< T >::value) >
FMT_CONSTEXPR20 bool detail::isfinite (T value)
 
template<typename T , FMT_ENABLE_IF(!has_isfinite< T >::value) >
FMT_CONSTEXPR bool detail::isfinite (T value)
 
template<typename T , FMT_ENABLE_IF(is_floating_point< T >::value) >
FMT_INLINE FMT_CONSTEXPR bool detail::signbit (T value)
 
FMT_CONSTEXPR20 void detail::adjust_precision (int &precision, int exp10)
 
FMT_CONSTEXPR20 void detail::format_dragon (basic_fp< uint128_t > value, unsigned flags, int num_digits, buffer< char > &buf, int &exp10)
 
template<typename Float , FMT_ENABLE_IF(!is_double_double< Float >::value) >
FMT_CONSTEXPR20 void detail::format_hexfloat (Float value, int precision, float_specs specs, buffer< char > &buf)
 
template<typename Float >
FMT_CONSTEXPR20 auto detail::format_float (Float value, int precision, float_specs specs, buffer< char > &buf) -> int
 
template<typename Char , typename OutputIt , typename T >
FMT_CONSTEXPR20 auto detail::write_float (OutputIt out, T value, format_specs< Char > specs, locale_ref loc) -> OutputIt
 
template<typename Char , typename OutputIt , typename T , FMT_ENABLE_IF(is_floating_point< T >::value) >
FMT_CONSTEXPR20 auto detail::write (OutputIt out, T value, format_specs< Char > specs, locale_ref loc={}) -> OutputIt
 
template<typename Char , typename OutputIt , typename T , FMT_ENABLE_IF(is_fast_float< T >::value) >
FMT_CONSTEXPR20 auto detail::write (OutputIt out, T value) -> OutputIt
 
template<typename Char , typename OutputIt , typename T , FMT_ENABLE_IF(is_floating_point< T >::value && !is_fast_float< T >::value) >
auto detail::write (OutputIt out, T value) -> OutputIt
 
template<typename Char , typename OutputIt >
auto detail::write (OutputIt out, monostate, format_specs< Char >={}, locale_ref={}) -> OutputIt
 
template<typename Char , typename OutputIt >
FMT_CONSTEXPR auto detail::write (OutputIt out, basic_string_view< Char > value) -> OutputIt
 
template<typename Char , typename OutputIt , typename T , FMT_ENABLE_IF(is_string< T >::value) >
constexpr auto detail::write (OutputIt out, const T &value) -> OutputIt
 
template<typename Char , typename OutputIt , typename T , bool check = std::is_enum<T>::value && !std::is_same<T, Char>::value && mapped_type_constant<T, basic_format_context<OutputIt, Char>>::value != type::custom_type, FMT_ENABLE_IF(check) >
FMT_CONSTEXPR auto detail::write (OutputIt out, T value) -> OutputIt
 
template<typename Char , typename OutputIt , typename T , FMT_ENABLE_IF(std::is_same< T, bool >::value) >
FMT_CONSTEXPR auto detail::write (OutputIt out, T value, const format_specs< Char > &specs={}, locale_ref={}) -> OutputIt
 
template<typename Char , typename OutputIt >
FMT_CONSTEXPR auto detail::write (OutputIt out, Char value) -> OutputIt
 
template<typename Char , typename OutputIt >
FMT_CONSTEXPR_CHAR_TRAITS auto detail::write (OutputIt out, const Char *value) -> OutputIt
 
template<typename Char , typename OutputIt , typename T , FMT_ENABLE_IF(std::is_same< T, void >::value) >
auto detail::write (OutputIt out, const T *value, const format_specs< Char > &specs={}, locale_ref={}) -> OutputIt
 
template<typename Char , typename OutputIt , typename T , typename Context = basic_format_context<OutputIt, Char>>
FMT_CONSTEXPR auto detail::write (OutputIt out, const T &value) -> enable_if_t< std::is_class< T >::value &&!is_string< T >::value &&!is_floating_point< T >::value &&!std::is_same< T, Char >::value &&!std::is_same< T, remove_cvref_t< decltype(arg_mapper< Context >().map(value))> >::value, OutputIt >
 
template<template< typename > class Handler, typename FormatArg , typename ErrorHandler >
FMT_CONSTEXPR auto detail::get_dynamic_spec (FormatArg arg, ErrorHandler eh) -> int
 
template<typename Context , typename ID >
FMT_CONSTEXPR auto detail::get_arg (Context &ctx, ID id) -> decltype(ctx.arg(id))
 
template<template< typename > class Handler, typename Context >
FMT_CONSTEXPR void detail::handle_dynamic_spec (int &value, arg_ref< typename Context::char_type > ref, Context &ctx)
 
template<typename Locale , typename Char >
auto detail::vformat (const Locale &loc, basic_string_view< Char > fmt, basic_format_args< buffer_context< type_identity_t< Char > > > args) -> std::basic_string< Char >
 
FMT_API void detail::format_error_code (buffer< char > &out, int error_code, string_view message) noexcept
 
FMT_API void detail::report_error (format_func func, int error_code, const char *message) noexcept
 
FMT_API auto vsystem_error (int error_code, string_view format_str, format_args args) -> std::system_error
 
template<typename... T>
auto system_error (int error_code, format_string< T... > fmt, T &&... args) -> std::system_error
 \rst Constructs :class:std::system_error with a message formatted with fmt::format(fmt, args...). More...
 
FMT_API void format_system_error (detail::buffer< char > &out, int error_code, const char *message) noexcept
 \rst Formats an error message for an error returned by an operating system or a language runtime, for example a file opening error, and writes it to out. More...
 
FMT_API void report_system_error (int error_code, const char *message) noexcept
 
 FMT_FORMAT_AS (signed char, int)
 
 FMT_FORMAT_AS (unsigned char, unsigned)
 
 FMT_FORMAT_AS (short, int)
 
 FMT_FORMAT_AS (unsigned short, unsigned)
 
 FMT_FORMAT_AS (long, detail::long_type)
 
 FMT_FORMAT_AS (unsigned long, detail::ulong_type)
 
 FMT_FORMAT_AS (Char *, const Char *)
 
 FMT_FORMAT_AS (std::basic_string< Char >, basic_string_view< Char >)
 
 FMT_FORMAT_AS (std::nullptr_t, const void *)
 
 FMT_FORMAT_AS (detail::std_string_view< Char >, basic_string_view< Char >)
 
 FMT_FORMAT_AS (void *, const void *)
 
template<typename T >
auto ptr (T p) -> const void *
 \rst Converts p to const void* for pointer formatting. More...
 
template<typename T , typename Deleter >
auto ptr (const std::unique_ptr< T, Deleter > &p) -> const void *
 
template<typename T >
auto ptr (const std::shared_ptr< T > &p) -> const void *
 
template<typename Enum >
constexpr auto underlying (Enum e) noexcept -> underlying_t< Enum >
 \rst Converts e to the underlying type. More...
 
template<typename Enum , FMT_ENABLE_IF(std::is_enum< Enum >::value) >
constexpr auto enums::format_as (Enum e) noexcept -> underlying_t< Enum >
 
template<typename T >
auto group_digits (T value) -> group_digits_view< T >
 \rst Returns a view that formats an integer value using ',' as a locale-independent thousands separator. More...
 
template<typename It , typename Sentinel >
auto join (It begin, Sentinel end, string_view sep) -> join_view< It, Sentinel >
 Returns a view that formats the iterator range [begin, end) with elements separated by sep. More...
 
template<typename Range >
auto join (Range &&range, string_view sep) -> join_view< detail::iterator_t< Range >, detail::sentinel_t< Range > >
 \rst Returns a view that formats range with elements separated by sep. More...
 
template<typename T , FMT_ENABLE_IF(!std::is_integral< T >::value && !detail::has_format_as< T >::value) >
auto to_string (const T &value) -> std::string
 \rst Converts value to std::string using the default format for type T. More...
 
template<typename T , FMT_ENABLE_IF(std::is_integral< T >::value) >
FMT_NODISCARD auto to_string (T value) -> std::string
 
template<typename Char , size_t SIZE>
FMT_NODISCARD auto to_string (const basic_memory_buffer< Char, SIZE > &buf) -> std::basic_string< Char >
 
template<typename Char >
void detail::vformat_to (buffer< Char > &buf, basic_string_view< Char > fmt, typename vformat_args< Char >::type args, locale_ref loc)
 
FMT_BEGIN_EXPORT template FMT_API void detail::vformat_to (buffer< char > &, string_view, typename vformat_args<>::type, locale_ref)
 
template FMT_API auto detail::thousands_sep_impl< char > (locale_ref) -> thousands_sep_result< char >
 
template FMT_API auto detail::thousands_sep_impl< wchar_t > (locale_ref) -> thousands_sep_result< wchar_t >
 
template FMT_API auto detail::decimal_point_impl (locale_ref) -> char
 
template<typename Locale , FMT_ENABLE_IF(detail::is_locale< Locale >::value) >
auto vformat (const Locale &loc, string_view fmt, format_args args) -> std::string
 
template<typename Locale , typename... T, FMT_ENABLE_IF(detail::is_locale< Locale >::value) >
auto format (const Locale &loc, format_string< T... > fmt, T &&... args) -> std::string
 
template<typename OutputIt , typename Locale , FMT_ENABLE_IF(detail::is_output_iterator< OutputIt, char >::value && detail::is_locale< Locale >::value) >
auto vformat_to (OutputIt out, const Locale &loc, string_view fmt, format_args args) -> OutputIt
 
template<typename OutputIt , typename Locale , typename... T, FMT_ENABLE_IF(detail::is_output_iterator< OutputIt, char >::value && detail::is_locale< Locale >::value) >
FMT_INLINE auto format_to (OutputIt out, const Locale &loc, format_string< T... > fmt, T &&... args) -> OutputIt
 
template<typename Locale , typename... T, FMT_ENABLE_IF(detail::is_locale< Locale >::value) >
FMT_NODISCARD FMT_INLINE auto formatted_size (const Locale &loc, format_string< T... > fmt, T &&... args) -> size_t
 

Variables

constexpr FMT_INLINE_VARIABLE uint32_t detail::invalid_code_point = ~uint32_t()
 

Macro Definition Documentation

◆ FMT_CATCH

#define FMT_CATCH (   x)    catch (x)

◆ FMT_DEPRECATED

#define FMT_DEPRECATED   /* deprecated */

◆ FMT_FALLTHROUGH

#define FMT_FALLTHROUGH

◆ FMT_FORMAT_AS

#define FMT_FORMAT_AS (   Type,
  Base 
)
Value:
template <typename Char> \
Definition: core.h:1068

◆ FMT_FUNC

#define FMT_FUNC

◆ FMT_HAS_BUILTIN

#define FMT_HAS_BUILTIN (   x)    0

◆ FMT_INLINE_VARIABLE

#define FMT_INLINE_VARIABLE

◆ FMT_MAYBE_UNUSED

#define FMT_MAYBE_UNUSED

◆ FMT_NO_UNIQUE_ADDRESS

#define FMT_NO_UNIQUE_ADDRESS

◆ FMT_NOINLINE

#define FMT_NOINLINE

◆ FMT_POWERS_OF_10

#define FMT_POWERS_OF_10 (   factor)
Value:
factor * 10, (factor)*100, (factor)*1000, (factor)*10000, (factor)*100000, \
(factor)*1000000, (factor)*10000000, (factor)*100000000, \
(factor)*1000000000

◆ FMT_REDUCE_INT_INSTANTIATIONS

#define FMT_REDUCE_INT_INSTANTIATIONS   0

◆ FMT_STRING

#define FMT_STRING (   s)    FMT_STRING_IMPL(s, fmt::detail::compile_string, )

\rst Constructs a compile-time format string from a string literal s.

Example**::

A compile-time error because 'd' is an invalid specifier for strings. std::string s = fmt::format(FMT_STRING("{:d}"), "foo"); \endrst

◆ FMT_STRING_IMPL

#define FMT_STRING_IMPL (   s,
  base,
  explicit 
)
Value:
[] { \
/* Use the hidden visibility as a workaround for a GCC bug (#1973). */ \
/* Use a macro-like name to avoid shadowing warnings. */ \
struct FMT_VISIBILITY("hidden") FMT_COMPILE_STRING : base { \
using char_type FMT_MAYBE_UNUSED = fmt::remove_cvref_t<decltype(s[0])>; \
FMT_MAYBE_UNUSED FMT_CONSTEXPR explicit \
operator fmt::basic_string_view<char_type>() const { \
return fmt::detail_exported::compile_string_to_view<char_type>(s); \
} \
}; \
return FMT_COMPILE_STRING(); \
}()
#define FMT_CONSTEXPR
Definition: core.h:105
typename std::remove_cv< remove_reference_t< T > >::type remove_cvref_t
Definition: core.h:265
#define FMT_VISIBILITY(value)
Definition: format.h:99
#define FMT_MAYBE_UNUSED
Definition: format.h:149

◆ FMT_THROW

#define FMT_THROW (   x)    throw x

◆ FMT_TRY

#define FMT_TRY   try

◆ FMT_USE_DOUBLE

#define FMT_USE_DOUBLE   1

◆ FMT_USE_FLOAT

#define FMT_USE_FLOAT   1

◆ FMT_USE_FLOAT128

#define FMT_USE_FLOAT128   0

◆ FMT_USE_FULL_CACHE_DRAGONBOX

#define FMT_USE_FULL_CACHE_DRAGONBOX   0

◆ FMT_USE_LONG_DOUBLE

#define FMT_USE_LONG_DOUBLE   1

◆ FMT_USE_USER_DEFINED_LITERALS

#define FMT_USE_USER_DEFINED_LITERALS   0

◆ FMT_VISIBILITY

#define FMT_VISIBILITY (   value)

Typedef Documentation

◆ memory_buffer

Enumeration Type Documentation

◆ anonymous enum

anonymous enum
Enumerator
inline_buffer_size 

Function Documentation

◆ FMT_FORMAT_AS() [1/11]

FMT_FORMAT_AS ( Char *  ,
const Char *   
)

◆ FMT_FORMAT_AS() [2/11]

FMT_FORMAT_AS ( detail::std_string_view< Char >  ,
basic_string_view< Char >   
)

◆ FMT_FORMAT_AS() [3/11]

FMT_FORMAT_AS ( long  ,
detail::long_type   
)

◆ FMT_FORMAT_AS() [4/11]

FMT_FORMAT_AS ( short  ,
int   
)

◆ FMT_FORMAT_AS() [5/11]

FMT_FORMAT_AS ( signed char  ,
int   
)

◆ FMT_FORMAT_AS() [6/11]

FMT_FORMAT_AS ( std::basic_string< Char >  ,
basic_string_view< Char >   
)

◆ FMT_FORMAT_AS() [7/11]

FMT_FORMAT_AS ( std::nullptr_t  ,
const void *   
)

◆ FMT_FORMAT_AS() [8/11]

FMT_FORMAT_AS ( unsigned char  ,
unsigned   
)

◆ FMT_FORMAT_AS() [9/11]

FMT_FORMAT_AS ( unsigned long  ,
detail::ulong_type   
)

◆ FMT_FORMAT_AS() [10/11]

FMT_FORMAT_AS ( unsigned short  ,
unsigned   
)

◆ FMT_FORMAT_AS() [11/11]

FMT_FORMAT_AS ( void *  ,
const void *   
)

◆ format()

template<typename Locale , typename... T, FMT_ENABLE_IF(detail::is_locale< Locale >::value) >
auto format ( const Locale &  loc,
format_string< T... >  fmt,
T &&...  args 
) -> std::string
inline

◆ format_system_error()

FMT_API void format_system_error ( detail::buffer< char > &  out,
int  error_code,
const char *  message 
)
noexcept

\rst Formats an error message for an error returned by an operating system or a language runtime, for example a file opening error, and writes it to out.

The format is the same as the one used by std::system_error(ec, message) where ec is std::error_code(error_code, std::generic_category()}). It is implementation-defined but normally looks like:

.. parsed-literal:: <message>*: *<system-message>*

where *<message>* is the passed message and *<system-message>* is the system message corresponding to the error code. error_code* is a system error code as given by errno. \endrst

◆ format_to()

template<typename OutputIt , typename Locale , typename... T, FMT_ENABLE_IF(detail::is_output_iterator< OutputIt, char >::value && detail::is_locale< Locale >::value) >
FMT_INLINE auto format_to ( OutputIt  out,
const Locale &  loc,
format_string< T... >  fmt,
T &&...  args 
) -> OutputIt

◆ formatted_size()

template<typename Locale , typename... T, FMT_ENABLE_IF(detail::is_locale< Locale >::value) >
FMT_NODISCARD FMT_INLINE auto formatted_size ( const Locale &  loc,
format_string< T... >  fmt,
T &&...  args 
) -> size_t

◆ group_digits()

template<typename T >
auto group_digits ( value) -> group_digits_view<T>

\rst Returns a view that formats an integer value using ',' as a locale-independent thousands separator.

Example**::

fmt::print("{}", fmt::group_digits(12345)); Output: "12,345" \endrst

◆ join() [1/2]

template<typename It , typename Sentinel >
auto join ( It  begin,
Sentinel  end,
string_view  sep 
) -> join_view<It, Sentinel>

Returns a view that formats the iterator range [begin, end) with elements separated by sep.

◆ join() [2/2]

template<typename Range >
auto join ( Range &&  range,
string_view  sep 
) -> join_view<detail::iterator_t<Range>, detail::sentinel_t<Range>>

\rst Returns a view that formats range with elements separated by sep.

Example**::

std::vector<int> v = {1, 2, 3}; fmt::print("{}", fmt::join(v, ", ")); Output: "1, 2, 3"

fmt::join applies passed format specifiers to the range elements::

fmt::print("{:02}", fmt::join(v, ", ")); Output: "01, 02, 03" \endrst

◆ ptr() [1/3]

template<typename T >
auto ptr ( const std::shared_ptr< T > &  p) -> const void*

◆ ptr() [2/3]

template<typename T , typename Deleter >
auto ptr ( const std::unique_ptr< T, Deleter > &  p) -> const void*

◆ ptr() [3/3]

template<typename T >
auto ptr ( p) -> const void*

\rst Converts p to const void* for pointer formatting.

Example**::

auto s = fmt::format("{}", fmt::ptr(p)); \endrst

◆ report_system_error()

FMT_API void report_system_error ( int  error_code,
const char *  message 
)
noexcept

◆ system_error()

template<typename... T>
auto system_error ( int  error_code,
format_string< T... >  fmt,
T &&...  args 
) -> std::system_error

\rst Constructs :class:std::system_error with a message formatted with fmt::format(fmt, args...).

error_code* is a system error code as given by errno.

Example**::

This throws std::system_error with the description cannot open file 'madeup': No such file or directory or similar (system message may vary). const char* filename = "madeup"; std::FILE* file = std::fopen(filename, "r"); if (!file) throw fmt::system_error(errno, "cannot open file '{}'", filename); \endrst

◆ to_string() [1/3]

template<typename Char , size_t SIZE>
FMT_NODISCARD auto to_string ( const basic_memory_buffer< Char, SIZE > &  buf) -> std::basic_string<Char>

◆ to_string() [2/3]

template<typename T , FMT_ENABLE_IF(!std::is_integral< T >::value && !detail::has_format_as< T >::value) >
auto to_string ( const T &  value) -> std::string
inline

\rst Converts value to std::string using the default format for type T.

Example**::

#include <fmt/format.h>

std::string answer = fmt::to_string(42); \endrst

◆ to_string() [3/3]

template<typename T , FMT_ENABLE_IF(std::is_integral< T >::value) >
FMT_NODISCARD auto to_string ( value) -> std::string
inline

◆ underlying()

template<typename Enum >
constexpr auto underlying ( Enum  e) -> underlying_t<Enum>
constexprnoexcept

\rst Converts e to the underlying type.

Example**::

enum class color { red, green, blue }; auto s = fmt::format("{}", fmt::underlying(color::red)); \endrst

◆ vformat()

template<typename Locale , FMT_ENABLE_IF(detail::is_locale< Locale >::value) >
auto vformat ( const Locale &  loc,
string_view  fmt,
format_args  args 
) -> std::string
inline

◆ vformat_to()

template<typename OutputIt , typename Locale , FMT_ENABLE_IF(detail::is_output_iterator< OutputIt, char >::value && detail::is_locale< Locale >::value) >
auto vformat_to ( OutputIt  out,
const Locale &  loc,
string_view  fmt,
format_args  args 
) -> OutputIt

◆ vsystem_error()

FMT_API auto vsystem_error ( int  error_code,
string_view  format_str,
format_args  args 
) -> std::system_error