HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
format.h File Reference
#include <algorithm>
#include <cerrno>
#include <cmath>
#include <cstdint>
#include <limits>
#include <memory>
#include <stdexcept>
#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
 
class  detail::counting_iterator
 
struct  detail::counting_iterator::value_type
 
class  detail::truncating_iterator_base< OutputIt >
 
class  detail::truncating_iterator< OutputIt, Enable >
 
class  detail::truncating_iterator< OutputIt, std::false_type >
 
class  detail::truncating_iterator< OutputIt, std::true_type >
 
class  basic_memory_buffer< T, SIZE, Allocator >
 
struct  is_contiguous< basic_memory_buffer< T, SIZE, Allocator > >
 
class  format_error
 
struct  detail::uint128_wrapper
 
struct  detail::divtest_table_entry< T >
 
struct  detail::basic_data< T >
 
struct  detail::data
 
struct  detail::format_decimal_result< Iterator >
 
class  detail::utf8_to_utf16
 
struct  detail::null< T >
 
struct  detail::fill_t< Char >
 
struct  basic_format_specs< Char >
 
struct  detail::dragonbox::float_info< T >
 
struct  detail::dragonbox::float_info< float >
 
struct  detail::dragonbox::float_info< double >
 
struct  detail::dragonbox::decimal_fp< T >
 
struct  detail::float_specs
 
class  detail::int_type_checker< ErrorHandler >
 
class  detail::char_specs_checker< ErrorHandler >
 
class  detail::cstring_type_checker< ErrorHandler >
 
struct  detail::write_int_data< Char >
 
struct  detail::int_writer< OutputIt, Char, UInt >
 
struct  detail::big_decimal_fp
 
struct  detail::is_integral< T >
 
struct  detail::is_integral< int128_t >
 
struct  detail::is_integral< uint128_t >
 
struct  detail::default_arg_formatter< OutputIt, Char >
 
class  detail::arg_formatter_base< OutputIt, Char, ErrorHandler >
 
class  detail::arg_formatter< OutputIt, Char >
 
class  detail::custom_formatter< Context >
 
class  detail::width_checker< ErrorHandler >
 
class  detail::precision_checker< ErrorHandler >
 
class  detail::specs_setter< Char >
 
class  detail::numeric_specs_checker< ErrorHandler >
 
class  detail::specs_checker< Handler >
 
struct  detail::auto_id
 
class  detail::specs_handler< ParseContext, Context >
 
struct  detail::arg_ref< Char >
 
union  detail::arg_ref< Char >::value
 
struct  detail::dynamic_format_specs< Char >
 
class  detail::dynamic_specs_handler< ParseContext >
 
struct  detail::width_adapter< SpecHandler, Char >
 
struct  detail::precision_adapter< SpecHandler, Char >
 
struct  detail::id_adapter< Handler, Char >
 
struct  detail::format_handler< OutputIt, Char, Context >
 
class  detail::compile_parse_context< Char, ErrorHandler >
 
class  detail::format_string_checker< Char, ErrorHandler, Args >
 
class  system_error
 
class  format_int
 
struct  formatter< T, Char, enable_if_t< detail::type_constant< T, Char >::value!=detail::type::custom_type > >
 
struct  formatter< void *, Char >
 
struct  formatter< Char[N], Char >
 
class  dynamic_formatter< Char >
 
class  bytes
 
struct  formatter< bytes >
 
struct  arg_join< It, Sentinel, Char >
 
struct  formatter< arg_join< It, Sentinel, Char >, Char >
 

Namespaces

 detail
 
 align
 
 sign
 
 detail::dragonbox
 

Macros

#define FMT_ICC_VERSION   0
 
#define FMT_CUDA_VERSION   0
 
#define FMT_HAS_BUILTIN(x)   0
 
#define FMT_NOINLINE
 
#define FMT_FALLTHROUGH
 
#define FMT_MAYBE_UNUSED
 
#define FMT_THROW(x)   throw x
 
#define FMT_TRY   try
 
#define FMT_CATCH(x)   catch (x)
 
#define FMT_USE_USER_DEFINED_LITERALS   0
 
#define FMT_USE_UDL_TEMPLATE   0
 
#define FMT_USE_FLOAT   1
 
#define FMT_USE_DOUBLE   1
 
#define FMT_USE_LONG_DOUBLE   1
 
#define FMT_REDUCE_INT_INSTANTIATIONS   0
 
#define FMT_DEPRECATED_NUMERIC_ALIGN   0
 
#define FMT_USE_FULL_CACHE_DRAGONBOX   0
 
#define FMT_ALWAYS_INLINE   inline
 
#define FMT_SAFEBUFFERS
 
#define FMT_STRING_IMPL(s, base)
 
#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 InputIt , typename OutChar >
using detail::needs_conversion = bool_constant< std::is_same< typename std::iterator_traits< InputIt >::value_type, char >::value &&std::is_same< OutChar, char8_type >::value >
 
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 >
 
using wmemory_buffer = basic_memory_buffer< wchar_t >
 
template<typename T >
using detail::is_signed = std::integral_constant< bool, std::numeric_limits< T >::is_signed||std::is_same< T, int128_t >::value >
 
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 >>
 
using align_t = align::type
 
using sign_t = sign::type
 
using format_specs = basic_format_specs< char >
 
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::format_func = void(*)(detail::buffer< char > &, int, string_view)
 
using FMT_DEPRECATED_ALIAS = detail::arg_formatter< OutputIt, Char >
 
template<typename OutputIt , typename Char = char>
using format_context_t = basic_format_context< OutputIt, Char >
 
template<typename OutputIt , typename Char = char>
using format_args_t = basic_format_args< format_context_t< OutputIt, Char >>
 

Enumerations

enum  { inline_buffer_size = 500 }
 
enum  align::type {
  align::none, align::left, align::right, align::center,
  align::numeric
}
 
enum  sign::type { sign::none, sign::minus, sign::plus, sign::space }
 
enum  detail::float_format : unsigned char { detail::float_format::general, detail::float_format::exp, detail::float_format::fixed, detail::float_format::hex }
 
enum  detail::arg_id_kind { detail::arg_id_kind::none, detail::arg_id_kind::index, detail::arg_id_kind::name }
 

Functions

template<typename Dest , typename Source >
Dest detail::bit_cast (const Source &source)
 
bool detail::is_big_endian ()
 
fallback_uintptr detail::to_uintptr (const void *p)
 
template<typename T >
constexpr T detail::max_value ()
 
template<typename T >
constexpr int detail::num_bits ()
 
template<>
constexpr int detail::num_bits< int128_t > ()
 
template<>
constexpr int detail::num_bits< uint128_t > ()
 
template<>
constexpr int detail::num_bits< fallback_uintptr > ()
 
FMT_INLINE void detail::assume (bool condition)
 
template<typename Char >
Char * detail::get_data (std::basic_string< Char > &s)
 
template<typename Container >
Container::value_type * detail::get_data (Container &c)
 
template<typename T >
T * detail::make_checked (T *p, size_t)
 
template<typename Container , FMT_ENABLE_IF(is_contiguous< Container >::value) >
checked_ptr< typename
Container::value_type > 
detail::reserve (std::back_insert_iterator< Container > it, size_t n)
 
template<typename T >
buffer_appender< T > detail::reserve (buffer_appender< T > it, size_t n)
 
template<typename Iterator >
Iterator & detail::reserve (Iterator &it, size_t)
 
template<typename T , typename OutputIt >
constexpr T * detail::to_pointer (OutputIt, size_t)
 
template<typename T >
T * detail::to_pointer (buffer_appender< T > it, size_t n)
 
template<typename Container , FMT_ENABLE_IF(is_contiguous< Container >::value) >
std::back_insert_iterator
< Container > 
detail::base_iterator (std::back_insert_iterator< Container > &it, checked_ptr< typename Container::value_type >)
 
template<typename Iterator >
Iterator detail::base_iterator (Iterator, Iterator it)
 
template<typename Char >
size_t detail::count_code_points (basic_string_view< Char > s)
 
size_t detail::count_code_points (basic_string_view< char > s)
 
size_t detail::count_code_points (basic_string_view< char8_type > s)
 
template<typename Char >
size_t detail::code_point_index (basic_string_view< Char > s, size_t n)
 
size_t detail::code_point_index (basic_string_view< char8_type > s, size_t n)
 
template<typename OutChar , typename InputIt , typename OutputIt , FMT_ENABLE_IF(!needs_conversion< InputIt, OutChar >::value) >
OutputIt detail::copy_str (InputIt begin, InputIt end, OutputIt it)
 
template<typename Char , typename InputIt >
counting_iterator detail::copy_str (InputIt begin, InputIt end, counting_iterator it)
 
template<typename T , FMT_ENABLE_IF(is_signed< T >::value) >
FMT_CONSTEXPR bool detail::is_negative (T value)
 
template<typename T , FMT_ENABLE_IF(std::is_floating_point< T >::value) >
FMT_CONSTEXPR bool detail::is_supported_floating_point (T)
 
FMT_INLINE uint16_t detail::bsr2log10 (int bsr)
 
int detail::count_digits (uint64_t n)
 
template<unsigned BITS, typename UInt >
int detail::count_digits (UInt n)
 
template<>
int detail::count_digits< 4 > (detail::fallback_uintptr n)
 
template<typename Int >
constexpr int detail::digits10 () FMT_NOEXCEPT
 
template<>
constexpr int detail::digits10< int128_t > () FMT_NOEXCEPT
 
template<>
constexpr int detail::digits10< uint128_t > () FMT_NOEXCEPT
 
template<typename Char >
FMT_API std::string detail::grouping_impl (locale_ref loc)
 
template<typename Char >
std::string detail::grouping (locale_ref loc)
 
template<>
std::string detail::grouping< wchar_t > (locale_ref loc)
 
template<typename Char >
FMT_API Char detail::thousands_sep_impl (locale_ref loc)
 
template<typename Char >
Char detail::thousands_sep (locale_ref loc)
 
template<>
wchar_t detail::thousands_sep (locale_ref loc)
 
template<typename Char >
FMT_API Char detail::decimal_point_impl (locale_ref loc)
 
template<typename Char >
Char detail::decimal_point (locale_ref loc)
 
template<>
wchar_t detail::decimal_point (locale_ref loc)
 
template<typename Char >
bool detail::equal2 (const Char *lhs, const char *rhs)
 
bool detail::equal2 (const char *lhs, const char *rhs)
 
template<typename Char >
void detail::copy2 (Char *dst, const char *src)
 
FMT_INLINE void detail::copy2 (char *dst, const char *src)
 
template<typename Char , typename UInt >
format_decimal_result< Char * > detail::format_decimal (Char *out, UInt value, int size)
 
template<typename Char , typename UInt , typename Iterator , FMT_ENABLE_IF(!std::is_pointer< remove_cvref_t< Iterator >>::value) >
format_decimal_result< Iterator > detail::format_decimal (Iterator out, UInt value, int size)
 
template<unsigned BASE_BITS, typename Char , typename UInt >
Char * detail::format_uint (Char *buffer, UInt value, int num_digits, bool upper=false)
 
template<unsigned BASE_BITS, typename Char >
Char * detail::format_uint (Char *buffer, detail::fallback_uintptr n, int num_digits, bool=false)
 
template<unsigned BASE_BITS, typename Char , typename It , typename UInt >
It detail::format_uint (It out, UInt value, int num_digits, bool upper=false)
 
template<typename T >
FMT_API decimal_fp< T > detail::dragonbox::to_decimal (T x) FMT_NOEXCEPT
 
template<typename T >
constexpr
dragonbox::float_info< T >
::carrier_uint 
detail::exponent_mask ()
 
template<typename Char , typename It >
It detail::write_exponent (int exp, It it)
 
template<typename T >
int detail::format_float (T value, int precision, float_specs specs, buffer< char > &buf)
 
template<typename T >
int detail::snprintf_float (T value, int precision, float_specs specs, buffer< char > &buf)
 
template<typename T >
detail::promote_float (T value)
 
double detail::promote_float (float value)
 
template<typename Handler >
FMT_CONSTEXPR void detail::handle_int_type_spec (char spec, Handler &&handler)
 
template<typename ErrorHandler = error_handler, typename Char >
FMT_CONSTEXPR float_specs detail::parse_float_type_spec (const basic_format_specs< Char > &specs, ErrorHandler &&eh={})
 
template<typename Char , typename Handler >
FMT_CONSTEXPR void detail::handle_char_specs (const basic_format_specs< Char > *specs, Handler &&handler)
 
template<typename Char , typename Handler >
FMT_CONSTEXPR void detail::handle_cstring_type_spec (Char spec, Handler &&handler)
 
template<typename Char , typename ErrorHandler >
FMT_CONSTEXPR void detail::check_string_type_spec (Char spec, ErrorHandler &&eh)
 
template<typename Char , typename ErrorHandler >
FMT_CONSTEXPR void detail::check_pointer_type_spec (Char spec, ErrorHandler &&eh)
 
template<typename OutputIt , typename Char >
FMT_NOINLINE OutputIt detail::fill (OutputIt it, size_t n, const fill_t< Char > &fill)
 
template<align::type align = align::left, typename OutputIt , typename Char , typename F >
OutputIt detail::write_padded (OutputIt out, const basic_format_specs< Char > &specs, size_t size, size_t width, F &&f)
 
template<align::type align = align::left, typename OutputIt , typename Char , typename F >
OutputIt detail::write_padded (OutputIt out, const basic_format_specs< Char > &specs, size_t size, F &&f)
 
template<typename Char , typename OutputIt >
OutputIt detail::write_bytes (OutputIt out, string_view bytes, const basic_format_specs< Char > &specs)
 
template<typename OutputIt , typename Char , typename F >
OutputIt detail::write_int (OutputIt out, int num_digits, string_view prefix, const basic_format_specs< Char > &specs, F f)
 
template<typename StrChar , typename Char , typename OutputIt >
OutputIt detail::write (OutputIt out, basic_string_view< StrChar > s, const basic_format_specs< Char > &specs)
 
template<typename Char , typename OutputIt >
OutputIt detail::write_nonfinite (OutputIt out, bool isinf, const basic_format_specs< Char > &specs, const float_specs &fspecs)
 
int detail::get_significand_size (const big_decimal_fp &fp)
 
template<typename T >
int detail::get_significand_size (const dragonbox::decimal_fp< T > &fp)
 
template<typename Char , typename OutputIt >
OutputIt detail::write_significand (OutputIt out, const char *significand, int &significand_size)
 
template<typename Char , typename OutputIt , typename UInt >
OutputIt detail::write_significand (OutputIt out, UInt significand, int significand_size)
 
template<typename Char , typename UInt , FMT_ENABLE_IF(std::is_integral< UInt >::value) >
Char * detail::write_significand (Char *out, UInt significand, int significand_size, int integral_size, Char decimal_point)
 
template<typename OutputIt , typename UInt , typename Char , FMT_ENABLE_IF(!std::is_pointer< remove_cvref_t< OutputIt >>::value) >
OutputIt detail::write_significand (OutputIt out, UInt significand, int significand_size, int integral_size, Char decimal_point)
 
template<typename OutputIt , typename Char >
OutputIt detail::write_significand (OutputIt out, const char *significand, int significand_size, int integral_size, Char decimal_point)
 
template<typename OutputIt , typename DecimalFP , typename Char >
OutputIt detail::write_float (OutputIt out, const DecimalFP &fp, const basic_format_specs< Char > &specs, float_specs fspecs, Char decimal_point)
 
template<typename Char , typename OutputIt , typename T , FMT_ENABLE_IF(std::is_floating_point< T >::value) >
OutputIt detail::write (OutputIt out, T value, basic_format_specs< Char > specs, locale_ref loc={})
 
template<typename Char , typename OutputIt , typename T , FMT_ENABLE_IF(is_fast_float< T >::value) >
OutputIt detail::write (OutputIt out, T value)
 
template<typename Char , typename OutputIt >
OutputIt detail::write_char (OutputIt out, Char value, const basic_format_specs< Char > &specs)
 
template<typename Char , typename OutputIt , typename UIntPtr >
OutputIt detail::write_ptr (OutputIt out, UIntPtr value, const basic_format_specs< Char > *specs)
 
template<typename Char , typename OutputIt >
OutputIt detail::write (OutputIt out, monostate)
 
template<typename Char , typename OutputIt , FMT_ENABLE_IF(!std::is_same< Char, char >::value) >
OutputIt detail::write (OutputIt out, string_view value)
 
template<typename Char , typename OutputIt >
OutputIt detail::write (OutputIt out, basic_string_view< Char > value)
 
template<typename Char >
buffer_appender< Char > detail::write (buffer_appender< Char > out, basic_string_view< Char > value)
 
template<typename Char , typename OutputIt >
OutputIt detail::write (OutputIt out, bool value)
 
template<typename Char , typename OutputIt >
OutputIt detail::write (OutputIt out, Char value)
 
template<typename Char , typename OutputIt >
OutputIt detail::write (OutputIt out, const Char *value)
 
template<typename Char , typename OutputIt >
OutputIt detail::write (OutputIt out, const void *value)
 
template<typename Char , typename OutputIt , typename T >
auto detail::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<typename Char >
FMT_CONSTEXPR bool detail::is_name_start (Char c)
 
template<typename Char , typename ErrorHandler >
FMT_CONSTEXPR int detail::parse_nonnegative_int (const Char *&begin, const Char *end, ErrorHandler &&eh)
 
template<template< typename > class Handler, typename FormatArg , typename ErrorHandler >
FMT_CONSTEXPR int detail::get_dynamic_spec (FormatArg arg, ErrorHandler eh)
 
template<typename Context , typename ID >
FMT_CONSTEXPR Context::format_arg detail::get_arg (Context &ctx, ID id)
 
template<typename Char , typename IDHandler >
FMT_CONSTEXPR const Char * detail::parse_arg_id (const Char *begin, const Char *end, IDHandler &&handler)
 
template<typename Char >
FMT_CONSTEXPR int detail::code_point_length (const Char *begin)
 
template<typename Char >
constexpr bool detail::is_ascii_letter (Char c)
 
template<typename Char , FMT_ENABLE_IF(std::is_integral< Char >::value) >
constexpr Char detail::to_ascii (Char value)
 
template<typename Char , FMT_ENABLE_IF(std::is_enum< Char >::value) >
constexpr std::underlying_type
< Char >::type 
detail::to_ascii (Char value)
 
template<typename Char , typename Handler >
FMT_CONSTEXPR const Char * detail::parse_align (const Char *begin, const Char *end, Handler &&handler)
 
template<typename Char , typename Handler >
FMT_CONSTEXPR const Char * detail::parse_width (const Char *begin, const Char *end, Handler &&handler)
 
template<typename Char , typename Handler >
FMT_CONSTEXPR const Char * detail::parse_precision (const Char *begin, const Char *end, Handler &&handler)
 
template<typename Char , typename SpecHandler >
FMT_CONSTEXPR const Char * detail::parse_format_specs (const Char *begin, const Char *end, SpecHandler &&handler)
 
template<bool IS_CONSTEXPR, typename T , typename Ptr = const T*>
FMT_CONSTEXPR bool detail::find (Ptr first, Ptr last, T value, Ptr &out)
 
template<>
bool detail::find< false, char > (const char *first, const char *last, char value, const char *&out)
 
template<typename Char , typename Handler >
FMT_CONSTEXPR const Char * detail::parse_replacement_field (const Char *begin, const Char *end, Handler &&handler)
 
template<bool IS_CONSTEXPR, typename Char , typename Handler >
FMT_CONSTEXPR_DECL FMT_INLINE void detail::parse_format_string (basic_string_view< Char > format_str, Handler &&handler)
 
template<typename T , typename ParseContext >
FMT_CONSTEXPR const
ParseContext::char_type * 
detail::parse_format_specs (ParseContext &ctx)
 
template<typename Char , size_t N>
FMT_CONSTEXPR
basic_string_view< Char > 
detail::compile_string_to_view (const Char(&s)[N])
 
template<typename Char >
FMT_CONSTEXPR
basic_string_view< Char > 
detail::compile_string_to_view (const std_string_view< Char > &s)
 
template<typename... , typename S , FMT_ENABLE_IF(is_compile_string< S >::value) >
void detail::check_format_string (S)
 
template<template< typename > class Handler, typename Context >
void detail::handle_dynamic_spec (int &value, arg_ref< typename Context::char_type > ref, Context &ctx)
 
FMT_FUNC void detail::format_error_code (detail::buffer< char > &out, int error_code, string_view message) FMT_NOEXCEPT
 
FMT_FUNC void detail::report_error (format_func func, int error_code, string_view message) FMT_NOEXCEPT
 
FMT_API void format_system_error (detail::buffer< char > &out, int error_code, string_view message) FMT_NOEXCEPT
 
FMT_API void report_system_error (int error_code, string_view 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 Char , typename ErrorHandler >
FMT_CONSTEXPR void advance_to (basic_format_parse_context< Char, ErrorHandler > &ctx, const Char *p)
 
template<typename T >
const voidptr (const T *p)
 
template<typename T >
const voidptr (const std::unique_ptr< T > &p)
 
template<typename T >
const voidptr (const std::shared_ptr< T > &p)
 
template<typename It , typename Sentinel >
arg_join< It, Sentinel, char > join (It begin, Sentinel end, string_view sep)
 
template<typename It , typename Sentinel >
arg_join< It, Sentinel, wchar_t > join (It begin, Sentinel end, wstring_view sep)
 
template<typename Range >
arg_join< detail::iterator_t
< Range >, detail::sentinel_t
< Range >, char > 
join (Range &&range, string_view sep)
 
template<typename Range >
arg_join< detail::iterator_t
< Range >, detail::sentinel_t
< Range >, wchar_t > 
join (Range &&range, wstring_view sep)
 
template<typename T , FMT_ENABLE_IF(!std::is_integral< T >::value) >
std::string to_string (const T &value)
 
template<typename T , FMT_ENABLE_IF(std::is_integral< T >::value) >
std::string to_string (T value)
 
template<typename T >
std::wstring to_wstring (const T &value)
 
template<typename Char , size_t SIZE>
std::basic_string< Char > to_string (const basic_memory_buffer< Char, SIZE > &buf)
 
template FMT_API std::string detail::grouping_impl< char > (locale_ref loc)
 
template FMT_API std::string detail::grouping_impl< wchar_t > (locale_ref loc)
 
template FMT_API char detail::thousands_sep_impl< char > (locale_ref loc)
 
template FMT_API wchar_t detail::thousands_sep_impl< wchar_t > (locale_ref loc)
 
template<typename Char >
FMT_FUNC Char detail::decimal_point_impl (locale_ref loc)
 
template int detail::format_float< double > (double value, int precision, float_specs specs, buffer< char > &buf)
 
template int detail::format_float< long double > (long double value, int precision, float_specs specs, buffer< char > &buf)
 
int detail::snprintf_float (float value, int precision, float_specs specs, buffer< char > &buf)=delete
 
template int detail::snprintf_float< double > (double value, int precision, float_specs specs, buffer< char > &buf)
 
template int detail::snprintf_float< long double > (long double value, int precision, float_specs specs, buffer< char > &buf)
 
template<typename S , typename Char = char_t<S>, FMT_ENABLE_IF(detail::is_string< S >::value) >
void vformat_to (detail::buffer< Char > &buf, const S &format_str, basic_format_args< FMT_BUFFER_CONTEXT(type_identity_t< Char >)> args)
 
template<typename S , typename... Args, size_t SIZE = inline_buffer_size, typename Char = enable_if_t<detail::is_string<S>::value, char_t<S>>>
buffer_context< Char >::iterator format_to (basic_memory_buffer< Char, SIZE > &buf, const S &format_str, Args &&...args)
 
template<typename OutputIt , typename Char , typename... Args>
FMT_DEPRECATED
format_arg_store
< buffer_context< Char >
, Args...> 
make_format_to_n_args (const Args &...args)
 
template<typename Char , FMT_ENABLE_IF(std::is_same< Char, wchar_t >::value) >
void vprint (std::FILE *f, basic_string_view< Char > format_str, wformat_args args)
 
template<typename Char , FMT_ENABLE_IF(std::is_same< Char, wchar_t >::value) >
void vprint (basic_string_view< Char > format_str, wformat_args args)
 

Variables

FMT_EXTERN template struct detail::basic_data< void >
 

Macro Definition Documentation

#define FMT_ALWAYS_INLINE   inline

Definition at line 977 of file format.h.

#define FMT_CATCH (   x)    catch (x)

Definition at line 126 of file format.h.

#define FMT_CUDA_VERSION   0

Definition at line 57 of file format.h.

#define FMT_DEPRECATED_NUMERIC_ALIGN   0

Definition at line 272 of file format.h.

#define FMT_FALLTHROUGH

Definition at line 87 of file format.h.

#define FMT_FORMAT_AS (   Type,
  Base 
)
Value:
template <typename Char> \
template <typename FormatContext> \
auto format(Type const& val, FormatContext& ctx) -> decltype(ctx.out()) { \
} \
}
GLint GLint GLsizei GLint GLenum format
Definition: glcorearb.h:107
GLuint GLfloat * val
Definition: glcorearb.h:1607

Definition at line 3481 of file format.h.

#define FMT_FUNC

Definition at line 3957 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_MAYBE_UNUSED

Definition at line 94 of file format.h.

#define FMT_NOINLINE

Definition at line 69 of file format.h.

#define FMT_REDUCE_INT_INSTANTIATIONS   0

Definition at line 174 of file format.h.

#define FMT_SAFEBUFFERS

Definition at line 984 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 3219 of file format.h.

#define FMT_STRING_IMPL (   s,
  base 
)
Value:
[] { \
/* Use a macro-like name to avoid shadowing warnings. */ \
struct FMT_COMPILE_STRING : base { \
using char_type = fmt::remove_cvref_t<decltype(s[0])>; \
FMT_MAYBE_UNUSED FMT_CONSTEXPR \
operator fmt::basic_string_view<char_type>() const { \
return fmt::detail::compile_string_to_view<char_type>(s); \
} \
}; \
return FMT_COMPILE_STRING(); \
}()
#define FMT_MAYBE_UNUSED
Definition: format.h:94
GLdouble s
Definition: glew.h:1395

Definition at line 3196 of file format.h.

#define FMT_THROW (   x)    throw x

Definition at line 113 of file format.h.

#define FMT_TRY   try

Definition at line 125 of file format.h.

#define FMT_USE_DOUBLE   1

Definition at line 162 of file format.h.

#define FMT_USE_FLOAT   1

Definition at line 158 of file format.h.

#define FMT_USE_FULL_CACHE_DRAGONBOX   0

Definition at line 595 of file format.h.

#define FMT_USE_LONG_DOUBLE   1

Definition at line 166 of file format.h.

#define FMT_USE_UDL_TEMPLATE   0

Definition at line 153 of file format.h.

#define FMT_USE_USER_DEFINED_LITERALS   0

Definition at line 139 of file format.h.

Typedef Documentation

Definition at line 1177 of file format.h.

Definition at line 3260 of file format.h.

template<typename OutputIt , typename Char = char>
using format_args_t = basic_format_args<format_context_t<OutputIt, Char>>

Definition at line 3829 of file format.h.

template<typename OutputIt , typename Char = char>
using format_context_t = basic_format_context<OutputIt, Char>

Definition at line 3826 of file format.h.

Definition at line 1203 of file format.h.

Definition at line 761 of file format.h.

using sign_t = sign::type

Definition at line 1182 of file format.h.

Definition at line 762 of file format.h.

Enumeration Type Documentation

anonymous enum
Enumerator
inline_buffer_size 

Definition at line 621 of file format.h.

Function Documentation

template<typename Char , typename ErrorHandler >
FMT_CONSTEXPR void advance_to ( basic_format_parse_context< Char, ErrorHandler > &  ctx,
const Char *  p 
)

Definition at line 3589 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 >   
)
FMT_API void format_system_error ( detail::buffer< char > &  out,
int  error_code,
string_view  message 
)

Formats an error returned by an operating system or a language runtime, for example a file opening error, and writes it to out in the following form:

.. 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. If error_code is not a valid error code such as -1, the system message may look like "Unknown error -1" and is platform-dependent.

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

template<typename S , typename... Args, size_t SIZE = inline_buffer_size, typename Char = enable_if_t<detail::is_string<S>::value, char_t<S>>>
buffer_context<Char>::iterator format_to ( basic_memory_buffer< Char, SIZE > &  buf,
const S &  format_str,
Args &&...  args 
)
inline

Definition at line 3818 of file format.h.

template<typename It , typename Sentinel >
arg_join<It, Sentinel, char> join ( It  begin,
Sentinel  end,
string_view  sep 
)

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

Definition at line 3681 of file format.h.

template<typename It , typename Sentinel >
arg_join<It, Sentinel, wchar_t> join ( It  begin,
Sentinel  end,
wstring_view  sep 
)

Definition at line 3686 of file format.h.

template<typename Range >
arg_join<detail::iterator_t<Range>, detail::sentinel_t<Range>, char> join ( Range &&  range,
string_view  sep 
)

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 3707 of file format.h.

template<typename Range >
arg_join<detail::iterator_t<Range>, detail::sentinel_t<Range>, wchar_t> join ( Range &&  range,
wstring_view  sep 
)

Definition at line 3713 of file format.h.

template<typename OutputIt , typename Char , typename... Args>
FMT_DEPRECATED format_arg_store<buffer_context<Char>, Args...> make_format_to_n_args ( const Args &...  args)

Definition at line 3840 of file format.h.

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

Converts p to const void* for pointer formatting.

Example**::

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

Examples:
standalone/tiledevice.C.

Definition at line 3603 of file format.h.

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

Definition at line 3604 of file format.h.

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

Definition at line 3607 of file format.h.

FMT_API void report_system_error ( int  error_code,
string_view  message 
)
template<typename T , FMT_ENABLE_IF(!std::is_integral< T >::value) >
std::string to_string ( const T &  value)
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 3730 of file format.h.

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

Definition at line 3737 of file format.h.

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

Definition at line 3754 of file format.h.

template<typename T >
std::wstring to_wstring ( const T &  value)
inline

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

Definition at line 3749 of file format.h.

template<typename S , typename Char = char_t<S>, FMT_ENABLE_IF(detail::is_string< S >::value) >
void vformat_to ( detail::buffer< Char > &  buf,
const S &  format_str,
basic_format_args< FMT_BUFFER_CONTEXT(type_identity_t< Char >)>  args 
)
inline

Definition at line 3810 of file format.h.

template<typename Char , FMT_ENABLE_IF(std::is_same< Char, wchar_t >::value) >
void vprint ( std::FILE *  f,
basic_string_view< Char >  format_str,
wformat_args  args 
)

Definition at line 3854 of file format.h.

template<typename Char , FMT_ENABLE_IF(std::is_same< Char, wchar_t >::value) >
void vprint ( basic_string_view< Char >  format_str,
wformat_args  args 
)

Definition at line 3864 of file format.h.