HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
format.h File Reference
#include <cmath>
#include <cstdint>
#include <limits>
#include <memory>
#include <stdexcept>
#include <system_error>
#include <utility>
#include "core.h"
+ Include dependency graph for format.h:
+ This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  detail::fallback_uintptr
 
struct  detail::is_locale< T, Enable >
 
struct  detail::is_locale< T, void_t< decltype(T::classic())> >
 
class  basic_memory_buffer< T, SIZE, Allocator >
 
struct  is_contiguous< basic_memory_buffer< T, SIZE, Allocator > >
 
class  format_error
 
struct  is_integral< T >
 
struct  is_integral< int128_t >
 
struct  is_integral< uint128_t >
 
struct  basic_data< T >
 
struct  data
 
struct  thousands_sep_result< Char >
 
struct  format_decimal_result< Iterator >
 
class  utf8_to_utf16
 
struct  dragonbox::float_info< T >
 
struct  dragonbox::float_info< float >
 
struct  dragonbox::float_info< double >
 
struct  dragonbox::decimal_fp< T >
 
struct  write_int_data< Char >
 
struct  write_int_arg< UInt >
 
struct  big_decimal_fp
 
struct  default_arg_formatter< Char >
 
struct  arg_formatter< Char >
 
struct  custom_formatter< Char >
 
class  width_checker< ErrorHandler >
 
class  precision_checker< ErrorHandler >
 
class  specs_handler< Char >
 
class  format_int
 
struct  formatter< void *, Char >
 
struct  formatter< Char[N], Char >
 
class  dynamic_formatter< Char >
 
class  bytes
 
struct  formatter< bytes >
 
struct  join_view< It, Sentinel, Char >
 
struct  formatter< join_view< It, Sentinel, Char >, Char >
 

Namespaces

 detail
 
 detail_exported
 
 dragonbox
 
 literals
 

Macros

#define FMT_ICC_VERSION   0
 
#define FMT_CUDA_VERSION   0
 
#define FMT_HAS_BUILTIN(x)   0
 
#define FMT_NOINLINE
 
#define FMT_MSC_DEFAULT
 
#define FMT_THROW(x)   throw x
 
#define FMT_TRY   try
 
#define FMT_CATCH(x)   catch (x)
 
#define FMT_DEPRECATED   /* deprecated */
 
#define FMT_DEPRECATED_ALIAS   FMT_DEPRECATED
 
#define FMT_USE_USER_DEFINED_LITERALS   0
 
#define FMT_REDUCE_INT_INSTANTIATIONS   0
 
#define FMT_CONSTEXPR20
 
#define FMT_USE_FULL_CACHE_DRAGONBOX   0
 
#define FMT_POWERS_OF_10(factor)
 
#define FMT_INC(T)   (((sizeof(#T) - 1ull) << 32) - T)
 
#define FMT_STRING_IMPL(s, base, explicit)
 
#define FMT_STRING(s)   FMT_STRING_IMPL(s, fmt::compile_string, )
 
#define FMT_FORMAT_AS(Type, Base)
 
#define FMT_FUNC
 

Typedefs

using detail::uintptr_t = fallback_uintptr
 
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 T >
using detail::checked_ptr = T *
 
template<typename OutputIt >
using detail::reserve_iterator = remove_reference_t< decltype(reserve(std::declval< OutputIt & >(), 0))>
 
template<typename T >
using detail::is_fast_float = bool_constant< std::numeric_limits< T >::is_iec559 &&sizeof(T)<=sizeof(double)>
 
using memory_buffer = basic_memory_buffer< char >
 
template<typename T >
using is_signed = std::integral_constant< bool, std::numeric_limits< T >::is_signed||std::is_same< T, int128_t >::value >
 
template<typename T >
using 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 uint64_or_128_t = conditional_t< num_bits< T >()<=64, uint64_t, uint128_t >
 
template<typename T >
using 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 format_func = void(*)(detail::buffer< char > &, int, const char *)
 
using FMT_DEPRECATED_ALIAS = join_view< It, Sentinel, Char >
 

Enumerations

enum  detail::char8_type : unsigned char
 
enum  { inline_buffer_size = 500 }
 

Functions

template<typename Dest , typename Source >
auto detail::bit_cast (const Source &source) -> Dest
 
auto detail::is_big_endian () -> bool
 
auto detail::to_uintptr (const void *p) -> fallback_uintptr
 
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_t > () -> int
 
template<>
constexpr auto detail::num_bits< uint128_t > () -> int
 
template<>
constexpr auto detail::num_bits< fallback_uintptr > () -> 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 T >
auto detail::make_checked (T *p, size_t) -> T *
 
template<typename Container , FMT_ENABLE_IF(is_contiguous< Container >::value) >
auto detail::reserve (std::back_insert_iterator< Container > it, size_t n) -> checked_ptr< 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, checked_ptr< 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 (basic_string_view< char8_type > s, size_t n) -> size_t
 
FMT_FUNC void detail::print (std::FILE *f, string_view text)
 
template<typename... Args, typename S , typename Char = char_t<S>>
FMT_INLINE auto make_args_checked (const S &fmt, const remove_reference_t< Args > &...args) -> format_arg_store< buffer_context< Char >, remove_reference_t< Args >...>
 
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 >
 
FMT_BEGIN_DETAIL_NAMESPACE void throw_format_error (const char *message)
 
template<typename T , FMT_ENABLE_IF(is_signed< T >::value) >
FMT_CONSTEXPR auto is_negative (T value) -> bool
 
template<typename T , FMT_ENABLE_IF(std::is_floating_point< T >::value) >
FMT_CONSTEXPR auto is_supported_floating_point (T) -> uint16_t
 
template<typename T >
FMT_CONSTEXPR auto count_digits_fallback (T n) -> int
 
FMT_CONSTEXPR20 auto count_digits (uint64_t n) -> int
 
template<int BITS, typename UInt >
FMT_CONSTEXPR auto count_digits (UInt n) -> int
 
template<>
auto count_digits< 4 > (detail::fallback_uintptr n) -> int
 
FMT_INLINE uint64_t count_digits_inc (int n)
 
FMT_CONSTEXPR20 auto count_digits (uint32_t n) -> int
 
template<typename Int >
constexpr auto digits10 () FMT_NOEXCEPT-> int
 
template<>
constexpr auto digits10< int128_t > () FMT_NOEXCEPT-> int
 
template<>
constexpr auto digits10< uint128_t > () FMT_NOEXCEPT-> int
 
template<typename Char >
FMT_API auto thousands_sep_impl (locale_ref loc) -> thousands_sep_result< Char >
 
template<typename Char >
auto thousands_sep (locale_ref loc) -> thousands_sep_result< Char >
 
template<>
auto thousands_sep (locale_ref loc) -> thousands_sep_result< wchar_t >
 
template<typename Char >
FMT_API auto decimal_point_impl (locale_ref loc) -> Char
 
template<typename Char >
auto decimal_point (locale_ref loc) -> Char
 
template<>
auto decimal_point (locale_ref loc) -> wchar_t
 
template<typename Char >
auto equal2 (const Char *lhs, const char *rhs) -> bool
 
auto equal2 (const char *lhs, const char *rhs) -> bool
 
template<typename Char >
void copy2 (Char *dst, const char *src)
 
FMT_INLINE void copy2 (char *dst, const char *src)
 
template<typename Char , typename UInt >
FMT_CONSTEXPR20 auto 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) >
auto format_decimal (Iterator out, UInt value, int size) -> format_decimal_result< Iterator >
 
template<unsigned BASE_BITS, typename Char , typename UInt >
FMT_CONSTEXPR auto format_uint (Char *buffer, UInt value, int num_digits, bool upper=false) -> Char *
 
template<unsigned BASE_BITS, typename Char >
auto format_uint (Char *buffer, detail::fallback_uintptr n, int num_digits, bool=false) -> Char *
 
template<unsigned BASE_BITS, typename Char , typename It , typename UInt >
auto format_uint (It out, UInt value, int num_digits, bool upper=false) -> It
 
template<typename T >
FMT_API auto dragonbox::to_decimal (T x) FMT_NOEXCEPT-> decimal_fp< T >
 
template<typename T >
constexpr auto exponent_mask () -> typename dragonbox::float_info< T >::carrier_uint
 
template<typename Char , typename It >
auto write_exponent (int exp, It it) -> It
 
template<typename T >
auto format_float (T value, int precision, float_specs specs, buffer< char > &buf) -> int
 
template<typename T >
auto snprintf_float (T value, int precision, float_specs specs, buffer< char > &buf) -> int
 
template<typename T >
auto promote_float (T value) -> T
 
auto promote_float (float value) -> double
 
template<typename OutputIt , typename Char >
FMT_NOINLINE FMT_CONSTEXPR auto 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 write_padded (OutputIt out, const basic_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 write_padded (OutputIt out, const basic_format_specs< Char > &specs, size_t size, F &&f) -> OutputIt
 
template<align::type align = align::left, typename Char , typename OutputIt >
FMT_CONSTEXPR auto write_bytes (OutputIt out, string_view bytes, const basic_format_specs< Char > &specs) -> OutputIt
 
template<typename Char , typename OutputIt , typename UIntPtr >
auto write_ptr (OutputIt out, UIntPtr value, const basic_format_specs< Char > *specs) -> OutputIt
 
template<typename Char , typename OutputIt >
FMT_CONSTEXPR auto write_char (OutputIt out, Char value, const basic_format_specs< Char > &specs) -> OutputIt
 
template<typename Char , typename OutputIt >
FMT_CONSTEXPR auto write (OutputIt out, Char value, const basic_format_specs< Char > &specs, locale_ref loc={}) -> OutputIt
 
template<typename OutputIt , typename Char , typename W >
FMT_CONSTEXPR FMT_INLINE auto write_int (OutputIt out, int num_digits, unsigned prefix, const basic_format_specs< Char > &specs, W write_digits) -> OutputIt
 
template<typename OutputIt , typename UInt , typename Char >
auto write_int_localized (OutputIt &out, UInt value, unsigned prefix, const basic_format_specs< Char > &specs, locale_ref loc) -> bool
 
FMT_CONSTEXPR void prefix_append (unsigned &prefix, unsigned value)
 
template<typename T >
FMT_CONSTEXPR auto 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 write_int (OutputIt out, write_int_arg< T > arg, const basic_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 auto write (OutputIt out, T value, const basic_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 write (OutputIt out, T value, const basic_format_specs< Char > &specs, locale_ref loc) -> OutputIt
 
template<typename Char , typename OutputIt >
FMT_CONSTEXPR auto write (OutputIt out, basic_string_view< Char > s, const basic_format_specs< Char > &specs) -> OutputIt
 
template<typename Char , typename OutputIt >
FMT_CONSTEXPR auto write (OutputIt out, basic_string_view< type_identity_t< Char >> s, const basic_format_specs< Char > &specs, locale_ref) -> OutputIt
 
template<typename Char , typename OutputIt >
FMT_CONSTEXPR auto write (OutputIt out, const Char *s, const basic_format_specs< Char > &specs, locale_ref) -> OutputIt
 
template<typename Char , typename OutputIt >
auto write_nonfinite (OutputIt out, bool isinf, basic_format_specs< Char > specs, const float_specs &fspecs) -> OutputIt
 
auto get_significand_size (const big_decimal_fp &fp) -> int
 
template<typename T >
auto get_significand_size (const dragonbox::decimal_fp< T > &fp) -> int
 
template<typename Char , typename OutputIt >
auto write_significand (OutputIt out, const char *significand, int &significand_size) -> OutputIt
 
template<typename Char , typename OutputIt , typename UInt >
auto write_significand (OutputIt out, UInt significand, int significand_size) -> OutputIt
 
template<typename Char , typename UInt , FMT_ENABLE_IF(std::is_integral< UInt >::value) >
auto 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 write_significand (OutputIt out, UInt significand, int significand_size, int integral_size, Char decimal_point) -> OutputIt
 
template<typename OutputIt , typename Char >
auto write_significand (OutputIt out, const char *significand, int significand_size, int integral_size, Char decimal_point) -> OutputIt
 
template<typename OutputIt , typename DecimalFP , typename Char >
auto write_float (OutputIt out, const DecimalFP &fp, const basic_format_specs< Char > &specs, float_specs fspecs, Char decimal_point) -> OutputIt
 
template<typename Char , typename OutputIt , typename T , FMT_ENABLE_IF(std::is_floating_point< T >::value) >
auto write (OutputIt out, T value, basic_format_specs< Char > specs, locale_ref loc={}) -> OutputIt
 
template<typename Char , typename OutputIt , typename T , FMT_ENABLE_IF(is_fast_float< T >::value) >
auto write (OutputIt out, T value) -> OutputIt
 
template<typename Char , typename OutputIt >
auto write (OutputIt out, monostate, basic_format_specs< Char >={}, locale_ref={}) -> OutputIt
 
template<typename Char , typename OutputIt >
FMT_CONSTEXPR auto 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 write (OutputIt out, const T &value) -> 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 write (OutputIt out, 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 write (OutputIt out, T value) -> OutputIt
 
template<typename Char , typename OutputIt >
FMT_CONSTEXPR auto write (OutputIt out, Char value) -> OutputIt
 
template<typename Char , typename OutputIt >
FMT_CONSTEXPR_CHAR_TRAITS auto write (OutputIt out, const Char *value) -> OutputIt
 
template<typename Char , typename OutputIt , typename T , FMT_ENABLE_IF(std::is_same< T, void >::value) >
auto write (OutputIt out, const T *value, const basic_format_specs< Char > &specs={}, locale_ref={}) -> OutputIt
 
template<typename Char , typename OutputIt , typename T >
FMT_CONSTEXPR auto write (OutputIt out, const T &value) -> typename std::enable_if< mapped_type_constant< T, basic_format_context< OutputIt, Char >>::value==type::custom_type, OutputIt >::type
 
template<template< typename > class Handler, typename FormatArg , typename ErrorHandler >
FMT_CONSTEXPR auto get_dynamic_spec (FormatArg arg, ErrorHandler eh) -> int
 
template<typename Context , typename ID >
FMT_CONSTEXPR auto get_arg (Context &ctx, ID id) -> typename Context::format_arg
 
template<template< typename > class Handler, typename Context >
FMT_CONSTEXPR void handle_dynamic_spec (int &value, arg_ref< typename Context::char_type > ref, Context &ctx)
 
template<typename Locale , typename Char >
auto vformat (const Locale &loc, basic_string_view< Char > format_str, basic_format_args< buffer_context< type_identity_t< Char >>> args) -> std::basic_string< Char >
 
FMT_API void format_error_code (buffer< char > &out, int error_code, string_view message) FMT_NOEXCEPT
 
FMT_API void report_error (format_func func, int error_code, const char *message) FMT_NOEXCEPT
 
FMT_END_DETAIL_NAMESPACE
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
 
FMT_API void format_system_error (detail::buffer< char > &out, int error_code, const char *message) FMT_NOEXCEPT
 
FMT_API void report_system_error (int error_code, const char *message) FMT_NOEXCEPT
 
 FMT_FORMAT_AS (signed char, int)
 
 FMT_FORMAT_AS (unsigned char, unsigned)
 
 FMT_FORMAT_AS (short, int)
 
 FMT_FORMAT_AS (long, long long)
 
 FMT_FORMAT_AS (unsigned long, unsigned long long)
 
 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 >)
 
template<typename T >
auto ptr (T p) -> const void *
 
template<typename T >
auto ptr (const std::unique_ptr< T > &p) -> const void *
 
template<typename T >
auto ptr (const std::shared_ptr< T > &p) -> const void *
 
template<typename It , typename Sentinel >
auto join (It begin, Sentinel end, string_view sep) -> join_view< It, Sentinel >
 
template<typename Range >
auto join (Range &&range, string_view sep) -> join_view< detail::iterator_t< Range >, detail::sentinel_t< Range >>
 
template<typename T , FMT_ENABLE_IF(!std::is_integral< T >::value) >
auto to_string (const T &value) -> std::string
 
template<typename T , FMT_ENABLE_IF(std::is_integral< T >::value) >
auto to_string (T value) -> std::string
 
template<typename Char , size_t SIZE>
auto to_string (const basic_memory_buffer< Char, SIZE > &buf) -> std::basic_string< Char >
 
template<typename Char >
FMT_BEGIN_DETAIL_NAMESPACE void vformat_to (buffer< Char > &buf, basic_string_view< Char > fmt, basic_format_args< buffer_context< type_identity_t< Char >>> args, locale_ref loc)
 
template void vformat_to (detail::buffer< char > &, string_view, basic_format_args< format_context >, detail::locale_ref)
 
template FMT_API auto thousands_sep_impl< char > (locale_ref) -> thousands_sep_result< char >
 
template FMT_API auto thousands_sep_impl< wchar_t > (locale_ref) -> thousands_sep_result< wchar_t >
 
template auto format_float< double > (double value, int precision, float_specs specs, buffer< char > &buf) -> int
 
template auto format_float< long double > (long double value, int precision, float_specs specs, buffer< char > &buf) -> int
 
void snprintf_float (float, int, float_specs, buffer< char > &)=delete
 
template auto snprintf_float< double > (double value, int precision, float_specs specs, buffer< char > &buf) -> int
 
template auto snprintf_float< long double > (long double value, int precision, float_specs specs, buffer< char > &buf) -> int
 
constexpr auto literals::operator""_a (const char *s, size_t) -> detail::udl_arg< char >
 
constexpr auto literals::operator""_format (const char *s, size_t n) -> detail::udl_formatter< 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... T, size_t SIZE, typename Allocator >
FMT_DEPRECATED auto format_to (basic_memory_buffer< char, SIZE, Allocator > &buf, format_string< T...> fmt, T &&...args) -> appender
 
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
 

Macro Definition Documentation

#define FMT_CATCH (   x)    catch (x)

Definition at line 105 of file format.h.

#define FMT_CONSTEXPR20

Definition at line 254 of file format.h.

#define FMT_CUDA_VERSION   0

Definition at line 57 of file format.h.

#define FMT_DEPRECATED   /* deprecated */

Definition at line 120 of file format.h.

Definition at line 129 of file format.h.

#define FMT_FORMAT_AS (   Type,
  Base 
)
Value:
template <typename Char> \
template <typename FormatContext> \
auto format(Type const& val, FormatContext& ctx) const \
-> decltype(ctx.out()) { \
return formatter<Base, Char>::format(static_cast<Base>(val), ctx); \
} \
}
auto format(const Locale &loc, format_string< T...> fmt, T &&...args) -> std::string
Definition: format.h:2781
GLuint GLfloat * val
Definition: glcorearb.h:1608

Definition at line 2349 of file format.h.

#define FMT_FUNC

Definition at line 2824 of file format.h.

#define FMT_HAS_BUILTIN (   x)    0

Definition at line 63 of file format.h.

#define FMT_ICC_VERSION   0

Definition at line 51 of file format.h.

#define FMT_INC (   T)    (((sizeof(#T) - 1ull) << 32) - T)
#define FMT_MSC_DEFAULT

Definition at line 75 of file format.h.

#define FMT_NOINLINE

Definition at line 69 of file format.h.

#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

Definition at line 851 of file format.h.

#define FMT_REDUCE_INT_INSTANTIATIONS   0

Definition at line 148 of file format.h.

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

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");

Definition at line 2152 of file format.h.

#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_GCC_VISIBILITY_HIDDEN FMT_COMPILE_STRING : base { \
using char_type = fmt::remove_cvref_t<decltype(s[0])>; \
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_GCC_VISIBILITY_HIDDEN
Definition: core.h:269
#define FMT_CONSTEXPR
Definition: core.h:98
#define FMT_MAYBE_UNUSED
Definition: core.h:172
GLdouble s
Definition: glew.h:1395

Definition at line 2128 of file format.h.

#define FMT_THROW (   x)    throw x

Definition at line 93 of file format.h.

#define FMT_TRY   try

Definition at line 104 of file format.h.

#define FMT_USE_FULL_CACHE_DRAGONBOX   0

Definition at line 572 of file format.h.

#define FMT_USE_USER_DEFINED_LITERALS   0

Definition at line 139 of file format.h.

Typedef Documentation

using FMT_DEPRECATED_ALIAS = join_view<It, Sentinel, Char>

Definition at line 2504 of file format.h.

using format_func = void (*)(detail::buffer<char>&, int, const char*)

Definition at line 2210 of file format.h.

template<typename T >
using 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>

Definition at line 2010 of file format.h.

template<typename T >
using is_signed = std::integral_constant<bool, std::numeric_limits<T>::is_signed || std::is_same<T, int128_t>::value>

Definition at line 821 of file format.h.

Definition at line 736 of file format.h.

template<typename T >
using 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>>

Definition at line 847 of file format.h.

template<typename T >
using uint64_or_128_t = conditional_t<num_bits<T>() <= 64, uint64_t, uint128_t>

Definition at line 849 of file format.h.

Enumeration Type Documentation

anonymous enum
Enumerator
inline_buffer_size 

Definition at line 599 of file format.h.

Function Documentation

template<typename Char >
void copy2 ( Char *  dst,
const char *  src 
)

Definition at line 1033 of file format.h.

FMT_INLINE void copy2 ( char *  dst,
const char *  src 
)

Definition at line 1037 of file format.h.

FMT_CONSTEXPR20 auto count_digits ( uint64_t  n) -> int
inline

Definition at line 919 of file format.h.

template<int BITS, typename UInt >
FMT_CONSTEXPR auto count_digits ( UInt  n) -> int

Definition at line 941 of file format.h.

FMT_CONSTEXPR20 auto count_digits ( uint32_t  n) -> int
inline

Definition at line 978 of file format.h.

template<>
auto count_digits< 4 > ( detail::fallback_uintptr  n) -> int

Definition at line 140 of file format-inl.h.

template<typename T >
FMT_CONSTEXPR auto count_digits_fallback ( n) -> int

Definition at line 897 of file format.h.

FMT_INLINE uint64_t count_digits_inc ( int  n)

Definition at line 957 of file format.h.

template<typename Char >
auto decimal_point ( locale_ref  loc) -> Char
inline

Definition at line 1017 of file format.h.

template<>
auto decimal_point ( locale_ref  loc) -> wchar_t
inline

Definition at line 1020 of file format.h.

template<typename Char >
template FMT_API auto decimal_point_impl ( locale_ref  loc) -> Char

Definition at line 113 of file format-inl.h.

template<typename Int >
constexpr auto digits10 ( ) -> int

Definition at line 988 of file format.h.

template<>
constexpr auto digits10< int128_t > ( ) -> int

Definition at line 991 of file format.h.

template<>
constexpr auto digits10< uint128_t > ( ) -> int

Definition at line 994 of file format.h.

template<typename Char >
auto equal2 ( const Char *  lhs,
const char *  rhs 
) -> bool

Definition at line 1025 of file format.h.

auto equal2 ( const char *  lhs,
const char *  rhs 
) -> bool
inline

Definition at line 1028 of file format.h.

template<typename T >
constexpr auto exponent_mask ( ) -> typename dragonbox::float_info<T>::carrier_uint

Definition at line 1218 of file format.h.

template<typename OutputIt , typename Char >
FMT_NOINLINE FMT_CONSTEXPR auto fill ( OutputIt  it,
size_t  n,
const fill_t< Char > &  fill 
) -> OutputIt

Definition at line 1262 of file format.h.

FMT_FORMAT_AS ( signed  char,
int   
)
FMT_FORMAT_AS ( unsigned  char,
unsigned   
)
FMT_FORMAT_AS ( short  ,
int   
)
FMT_FORMAT_AS ( long  ,
long  long 
)
FMT_FORMAT_AS ( unsigned  long,
unsigned long  long 
)
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 >   
)
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

Definition at line 2781 of file format.h.

template<typename Char , typename UInt >
FMT_CONSTEXPR20 auto format_decimal ( Char *  out,
UInt  value,
int  size 
) -> format_decimal_result<Char*>

Definition at line 1048 of file format.h.

template<typename Char , typename UInt , typename Iterator , FMT_ENABLE_IF(!std::is_pointer< remove_cvref_t< Iterator >>::value) >
auto format_decimal ( Iterator  out,
UInt  value,
int  size 
) -> format_decimal_result<Iterator>
inline

Definition at line 1080 of file format.h.

FMT_API void format_error_code ( buffer< char > &  out,
int  error_code,
string_view  message 
)

Definition at line 56 of file format-inl.h.

template<typename T >
auto format_float ( value,
int  precision,
float_specs  specs,
buffer< char > &  buf 
) -> int

Definition at line 2335 of file format-inl.h.

template auto format_float< double > ( double  value,
int  precision,
float_specs  specs,
buffer< char > &  buf 
) -> int
template auto format_float< long double > ( long double  value,
int  precision,
float_specs  specs,
buffer< char > &  buf 
) -> int
FMT_API void format_system_error ( detail::buffer< char > &  out,
int  error_code,
const char *  message 
)

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.

Definition at line 2542 of file format-inl.h.

template<typename... T, size_t SIZE, typename Allocator >
FMT_DEPRECATED auto format_to ( basic_memory_buffer< char, SIZE, Allocator > &  buf,
format_string< T...>  fmt,
T &&...  args 
) -> appender

Definition at line 2787 of file format.h.

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

Definition at line 2808 of file format.h.

template<unsigned BASE_BITS, typename Char , typename UInt >
FMT_CONSTEXPR auto format_uint ( Char *  buffer,
UInt  value,
int  num_digits,
bool  upper = false 
) -> Char*

Definition at line 1089 of file format.h.

template<unsigned BASE_BITS, typename Char >
auto format_uint ( Char *  buffer,
detail::fallback_uintptr  n,
int  num_digits,
bool  = false 
) -> Char*

Definition at line 1103 of file format.h.

template<unsigned BASE_BITS, typename Char , typename It , typename UInt >
auto format_uint ( It  out,
UInt  value,
int  num_digits,
bool  upper = false 
) -> It
inline

Definition at line 1125 of file format.h.

template<typename Context , typename ID >
FMT_CONSTEXPR auto get_arg ( Context &  ctx,
ID  id 
) -> typename Context::format_arg

Definition at line 2061 of file format.h.

template<template< typename > class Handler, typename FormatArg , typename ErrorHandler >
FMT_CONSTEXPR auto get_dynamic_spec ( FormatArg  arg,
ErrorHandler  eh 
) -> int

Definition at line 2054 of file format.h.

auto get_significand_size ( const big_decimal_fp fp) -> int
inline

Definition at line 1606 of file format.h.

template<typename T >
auto get_significand_size ( const dragonbox::decimal_fp< T > &  fp) -> int
inline

Definition at line 1610 of file format.h.

template<template< typename > class Handler, typename Context >
FMT_CONSTEXPR void handle_dynamic_spec ( int value,
arg_ref< typename Context::char_type ref,
Context &  ctx 
)

Definition at line 2111 of file format.h.

template<typename T , FMT_ENABLE_IF(is_signed< T >::value) >
FMT_CONSTEXPR auto is_negative ( value) -> bool

Definition at line 826 of file format.h.

template<typename T , FMT_ENABLE_IF(std::is_floating_point< T >::value) >
FMT_CONSTEXPR auto is_supported_floating_point ( ) -> uint16_t

Definition at line 835 of file format.h.

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

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

Definition at line 2559 of file format.h.

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

Returns an object 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"

Definition at line 2580 of file format.h.

template<typename... Args, typename S , typename Char = char_t<S>>
FMT_INLINE auto make_args_checked ( const S &  fmt,
const remove_reference_t< Args > &...  args 
) -> format_arg_store<buffer_context<Char>, remove_reference_t<Args>...>

Constructs a ~fmtformat_arg_store object that contains references to arguments and can be implicitly converted to ~fmtformat_args. If fmt is a compile-time string then make_args_checked checks its validity at compile time.

Definition at line 769 of file format.h.

template<typename T >
FMT_CONSTEXPR auto make_write_int_arg ( value,
sign_t  sign 
) -> write_int_arg<uint32_or_64_or_128_t<T>>

Definition at line 1458 of file format.h.

FMT_CONSTEXPR void prefix_append ( unsigned &  prefix,
unsigned  value 
)
inline

Definition at line 1447 of file format.h.

template<typename T >
auto promote_float ( value) -> T

Definition at line 1256 of file format.h.

auto promote_float ( float  value) -> double
inline

Definition at line 1257 of file format.h.

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

Converts p to const void* for pointer formatting.

Example**::

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

Examples:
standalone/tiledevice.C.

Definition at line 2448 of file format.h.

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

Definition at line 2452 of file format.h.

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

Definition at line 2455 of file format.h.

FMT_API void report_error ( format_func  func,
int  error_code,
const char *  message 
)

Definition at line 79 of file format-inl.h.

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

Definition at line 2557 of file format-inl.h.

template<typename T >
auto snprintf_float ( value,
int  precision,
float_specs  specs,
buffer< char > &  buf 
) -> int

Definition at line 2398 of file format-inl.h.

void snprintf_float ( float  ,
int  ,
float_specs  ,
buffer< char > &   
)
delete
template auto snprintf_float< double > ( double  value,
int  precision,
float_specs  specs,
buffer< char > &  buf 
) -> int
template auto snprintf_float< long double > ( long double  value,
int  precision,
float_specs  specs,
buffer< char > &  buf 
) -> int
template<typename... T>
auto system_error ( int  error_code,
format_string< T...>  fmt,
T &&...  args 
) -> std::system_error

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);

Examples:
mocapstream/MocapStreamRokokoHDK.C.

Definition at line 2240 of file format.h.

template<typename Char >
auto thousands_sep ( locale_ref  loc) -> thousands_sep_result<Char>
inline

Definition at line 1006 of file format.h.

template<>
auto thousands_sep ( locale_ref  loc) -> thousands_sep_result<wchar_t>
inline

Definition at line 1011 of file format.h.

template<typename Char >
FMT_API auto thousands_sep_impl ( locale_ref  loc) -> thousands_sep_result< Char >

Definition at line 107 of file format-inl.h.

template FMT_API auto thousands_sep_impl< char > ( locale_ref  ) -> thousands_sep_result< char >
template FMT_API auto thousands_sep_impl< wchar_t > ( locale_ref  ) -> thousands_sep_result< wchar_t >
FMT_BEGIN_DETAIL_NAMESPACE void throw_format_error ( const char *  message)
inline

Definition at line 810 of file format.h.

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

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

Example**::

#include <fmt/format.h>

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

Definition at line 2597 of file format.h.

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

Definition at line 2604 of file format.h.

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

Definition at line 2614 of file format.h.

template<typename Locale , typename Char >
auto vformat ( const Locale &  loc,
basic_string_view< Char >  format_str,
basic_format_args< buffer_context< type_identity_t< Char >>>  args 
) -> std::basic_string<Char>

Definition at line 2202 of file format.h.

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

Definition at line 2774 of file format.h.

template<typename Char >
FMT_BEGIN_DETAIL_NAMESPACE void vformat_to ( buffer< Char > &  buf,
basic_string_view< Char >  fmt,
basic_format_args< buffer_context< type_identity_t< Char >>>  args,
locale_ref  loc 
)

Definition at line 2624 of file format.h.

template void vformat_to ( detail::buffer< char > &  ,
string_view  ,
basic_format_args< format_context ,
detail::locale_ref   
)
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

Definition at line 2797 of file format.h.

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

Definition at line 132 of file format-inl.h.

template<typename Char , typename OutputIt >
FMT_CONSTEXPR auto write ( OutputIt  out,
Char  value,
const basic_format_specs< Char > &  specs,
locale_ref  loc = {} 
) -> OutputIt

Definition at line 1336 of file format.h.

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 auto write ( OutputIt  out,
value,
const basic_format_specs< Char > &  specs = {},
locale_ref  loc = {} 
) -> OutputIt

Definition at line 1535 of file format.h.

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 write ( OutputIt  out,
value,
const basic_format_specs< Char > &  specs,
locale_ref  loc 
) -> OutputIt

Definition at line 1545 of file format.h.

template<typename Char , typename OutputIt >
FMT_CONSTEXPR auto write ( OutputIt  out,
basic_string_view< Char >  s,
const basic_format_specs< Char > &  specs 
) -> OutputIt

Definition at line 1552 of file format.h.

template<typename Char , typename OutputIt >
FMT_CONSTEXPR auto write ( OutputIt  out,
basic_string_view< type_identity_t< Char >>  s,
const basic_format_specs< Char > &  specs,
locale_ref   
) -> OutputIt

Definition at line 1566 of file format.h.

template<typename Char , typename OutputIt >
FMT_CONSTEXPR auto write ( OutputIt  out,
const Char *  s,
const basic_format_specs< Char > &  specs,
locale_ref   
) -> OutputIt

Definition at line 1573 of file format.h.

template<typename Char , typename OutputIt , typename T , FMT_ENABLE_IF(std::is_floating_point< T >::value) >
auto write ( OutputIt  out,
value,
basic_format_specs< Char >  specs,
locale_ref  loc = {} 
) -> OutputIt

Definition at line 1767 of file format.h.

template<typename Char , typename OutputIt , typename T , FMT_ENABLE_IF(is_fast_float< T >::value) >
auto write ( OutputIt  out,
value 
) -> OutputIt
inline

Definition at line 1816 of file format.h.

template<typename Char , typename OutputIt >
auto write ( OutputIt  out,
monostate  ,
basic_format_specs< Char >  = {},
locale_ref  = {} 
) -> OutputIt

Definition at line 1847 of file format.h.

template<typename Char , typename OutputIt >
FMT_CONSTEXPR auto write ( OutputIt  out,
basic_string_view< Char >  value 
) -> OutputIt

Definition at line 1854 of file format.h.

template<typename Char , typename OutputIt , typename T , FMT_ENABLE_IF(is_string< T >::value) >
constexpr auto write ( OutputIt  out,
const T &  value 
) -> OutputIt

Definition at line 1863 of file format.h.

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 write ( OutputIt  out,
value 
) -> OutputIt

Definition at line 1871 of file format.h.

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 write ( OutputIt  out,
value 
) -> OutputIt

Definition at line 1897 of file format.h.

template<typename Char , typename OutputIt >
FMT_CONSTEXPR auto write ( OutputIt  out,
Char  value 
) -> OutputIt

Definition at line 1913 of file format.h.

template<typename Char , typename OutputIt >
FMT_CONSTEXPR_CHAR_TRAITS auto write ( OutputIt  out,
const Char *  value 
) -> OutputIt

Definition at line 1920 of file format.h.

template<typename Char , typename OutputIt , typename T , FMT_ENABLE_IF(std::is_same< T, void >::value) >
auto write ( OutputIt  out,
const T *  value,
const basic_format_specs< Char > &  specs = {},
locale_ref  = {} 
) -> OutputIt

Definition at line 1933 of file format.h.

template<typename Char , typename OutputIt , typename T >
FMT_CONSTEXPR auto write ( OutputIt  out,
const T &  value 
) -> typename std::enable_if< mapped_type_constant<T, basic_format_context<OutputIt, Char>>::value == type::custom_type, OutputIt>::type

Definition at line 1941 of file format.h.

template<align::type align = align::left, typename Char , typename OutputIt >
FMT_CONSTEXPR auto write_bytes ( OutputIt  out,
string_view  bytes,
const basic_format_specs< Char > &  specs 
) -> OutputIt

Definition at line 1302 of file format.h.

template<typename Char , typename OutputIt >
FMT_CONSTEXPR auto write_char ( OutputIt  out,
Char  value,
const basic_format_specs< Char > &  specs 
) -> OutputIt

Definition at line 1327 of file format.h.

template<typename Char , typename It >
auto write_exponent ( int  exp,
It  it 
) -> It

Definition at line 1227 of file format.h.

template<typename OutputIt , typename DecimalFP , typename Char >
auto write_float ( OutputIt  out,
const DecimalFP &  fp,
const basic_format_specs< Char > &  specs,
float_specs  fspecs,
Char  decimal_point 
) -> OutputIt

Definition at line 1667 of file format.h.

template<typename OutputIt , typename Char , typename W >
FMT_CONSTEXPR FMT_INLINE auto write_int ( OutputIt  out,
int  num_digits,
unsigned  prefix,
const basic_format_specs< Char > &  specs,
W  write_digits 
) -> OutputIt

Definition at line 1371 of file format.h.

template<typename Char , typename OutputIt , typename T >
FMT_CONSTEXPR FMT_INLINE auto write_int ( OutputIt  out,
write_int_arg< T >  arg,
const basic_format_specs< Char > &  specs,
locale_ref  loc 
) -> OutputIt

Definition at line 1472 of file format.h.

template<typename OutputIt , typename UInt , typename Char >
auto write_int_localized ( OutputIt &  out,
UInt  value,
unsigned  prefix,
const basic_format_specs< Char > &  specs,
locale_ref  loc 
) -> bool

Definition at line 1395 of file format.h.

template<typename Char , typename OutputIt >
auto write_nonfinite ( OutputIt  out,
bool  isinf,
basic_format_specs< Char >  specs,
const float_specs fspecs 
) -> OutputIt

Definition at line 1582 of file format.h.

template<align::type align = align::left, typename OutputIt , typename Char , typename F >
FMT_CONSTEXPR auto write_padded ( OutputIt  out,
const basic_format_specs< Char > &  specs,
size_t  size,
size_t  width,
F &&  f 
) -> OutputIt

Definition at line 1277 of file format.h.

template<align::type align = align::left, typename OutputIt , typename Char , typename F >
constexpr auto write_padded ( OutputIt  out,
const basic_format_specs< Char > &  specs,
size_t  size,
F &&  f 
) -> OutputIt

Definition at line 1296 of file format.h.

template<typename Char , typename OutputIt , typename UIntPtr >
auto write_ptr ( OutputIt  out,
UIntPtr  value,
const basic_format_specs< Char > *  specs 
) -> OutputIt

Definition at line 1313 of file format.h.

template<typename Char , typename OutputIt >
auto write_significand ( OutputIt  out,
const char *  significand,
int significand_size 
) -> OutputIt
inline

Definition at line 1615 of file format.h.

template<typename Char , typename OutputIt , typename UInt >
auto write_significand ( OutputIt  out,
UInt  significand,
int  significand_size 
) -> OutputIt
inline

Definition at line 1620 of file format.h.

template<typename Char , typename UInt , FMT_ENABLE_IF(std::is_integral< UInt >::value) >
auto write_significand ( Char *  out,
UInt  significand,
int  significand_size,
int  integral_size,
Char  decimal_point 
) -> Char*
inline

Definition at line 1627 of file format.h.

template<typename OutputIt , typename UInt , typename Char , FMT_ENABLE_IF(!std::is_pointer< remove_cvref_t< OutputIt >>::value) >
auto write_significand ( OutputIt  out,
UInt  significand,
int  significand_size,
int  integral_size,
Char  decimal_point 
) -> OutputIt
inline

Definition at line 1644 of file format.h.

template<typename OutputIt , typename Char >
auto write_significand ( OutputIt  out,
const char *  significand,
int  significand_size,
int  integral_size,
Char  decimal_point 
) -> OutputIt
inline

Definition at line 1655 of file format.h.