|
Loading...
Searching...
No Matches
#include <algorithm>
#include <cerrno>
#include <cmath>
#include <cstdint>
#include <limits>
#include <memory>
#include <stdexcept>
#include "core.h"
#include "format-inl.h"
Go to the source code of this file.
|
struct | fallback_uintptr |
|
class | counting_iterator |
|
struct | counting_iterator::value_type |
|
class | truncating_iterator_base< OutputIt > |
|
class | truncating_iterator< OutputIt, std::false_type > |
|
class | 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 | uint128_wrapper |
|
struct | divtest_table_entry< T > |
|
struct | basic_data< T > |
|
struct | data |
|
struct | format_decimal_result< Iterator > |
|
class | utf8_to_utf16 |
|
struct | null< T > |
|
struct | fill_t< Char > |
|
struct | basic_format_specs< Char > |
|
struct | float_info< float > |
|
struct | float_info< double > |
|
struct | decimal_fp< T > |
|
struct | float_specs |
|
class | int_type_checker< ErrorHandler > |
|
class | char_specs_checker< ErrorHandler > |
|
class | cstring_type_checker< ErrorHandler > |
|
struct | write_int_data< Char > |
|
struct | int_writer< OutputIt, Char, UInt > |
|
struct | big_decimal_fp |
|
struct | is_integral< T > |
|
struct | is_integral< int128_t > |
|
struct | is_integral< uint128_t > |
|
struct | default_arg_formatter< OutputIt, Char > |
|
class | arg_formatter_base< OutputIt, Char, ErrorHandler > |
|
struct | arg_formatter_base< OutputIt, Char, ErrorHandler >::char_spec_handler |
|
struct | arg_formatter_base< OutputIt, Char, ErrorHandler >::cstring_spec_handler |
|
class | arg_formatter< OutputIt, Char > |
|
class | custom_formatter< Context > |
|
class | width_checker< ErrorHandler > |
|
class | precision_checker< ErrorHandler > |
|
class | specs_setter< Char > |
|
class | numeric_specs_checker< ErrorHandler > |
|
class | specs_checker< Handler > |
|
struct | auto_id |
|
class | specs_handler< ParseContext, Context > |
|
struct | arg_ref< Char > |
|
union | arg_ref< Char >::value |
|
struct | dynamic_format_specs< Char > |
|
class | dynamic_specs_handler< ParseContext > |
|
struct | width_adapter< SpecHandler, Char > |
|
struct | precision_adapter< SpecHandler, Char > |
|
struct | id_adapter< Handler, Char > |
|
struct | format_handler< OutputIt, Char, Context > |
|
class | compile_parse_context< Char, ErrorHandler > |
|
class | 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 > |
|
struct | dynamic_formatter< Char >::null_handler |
|
class | bytes |
|
struct | formatter< bytes > |
|
struct | arg_join< It, Sentinel, Char > |
|
struct | formatter< arg_join< It, Sentinel, Char >, Char > |
|
|
enum | { inline_buffer_size = 500
} |
|
enum | type {
none
, left
, right
, center
,
numeric
} |
|
enum | type { none
, minus
, plus
, space
} |
|
enum class | float_format : unsigned char { general
, exp
, fixed
, hex
} |
|
enum class | arg_id_kind { none
, index
, name
} |
|
|
template<typename Dest , typename Source > |
Dest | bit_cast (const Source &source) |
|
bool | is_big_endian () |
|
fallback_uintptr | to_uintptr (const void *p) |
|
template<typename T > |
constexpr T | max_value () |
|
template<typename T > |
constexpr int | num_bits () |
|
template<> |
constexpr int | num_bits< int128_t > () |
|
template<> |
constexpr int | num_bits< uint128_t > () |
|
template<> |
constexpr int | num_bits< fallback_uintptr > () |
|
FMT_INLINE void | assume (bool condition) |
|
template<typename Char > |
Char * | get_data (std::basic_string< Char > &s) |
|
template<typename Container > |
Container::value_type * | get_data (Container &c) |
|
template<typename T > |
T * | make_checked (T *p, size_t) |
|
template<typename Container , FMT_ENABLE_IF(is_contiguous< Container >::value) > |
checked_ptr< typename Container::value_type > | reserve (std::back_insert_iterator< Container > it, size_t n) |
|
template<typename T > |
buffer_appender< T > | reserve (buffer_appender< T > it, size_t n) |
|
template<typename Iterator > |
Iterator & | reserve (Iterator &it, size_t) |
|
template<typename T , typename OutputIt > |
constexpr T * | to_pointer (OutputIt, size_t) |
|
template<typename T > |
T * | to_pointer (buffer_appender< T > it, size_t n) |
|
template<typename Container , FMT_ENABLE_IF(is_contiguous< Container >::value) > |
std::back_insert_iterator< Container > | base_iterator (std::back_insert_iterator< Container > &it, checked_ptr< typename Container::value_type >) |
|
template<typename Iterator > |
Iterator | base_iterator (Iterator, Iterator it) |
|
template<typename Char > |
size_t | count_code_points (basic_string_view< Char > s) |
|
size_t | count_code_points (basic_string_view< char > s) |
|
size_t | count_code_points (basic_string_view< char8_type > s) |
|
template<typename Char > |
size_t | code_point_index (basic_string_view< Char > s, size_t n) |
|
size_t | 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 | copy_str (InputIt begin, InputIt end, OutputIt it) |
|
template<typename Char , typename InputIt > |
counting_iterator | copy_str (InputIt begin, InputIt end, counting_iterator it) |
|
template<typename T , FMT_ENABLE_IF(is_signed< T >::value) > |
FMT_CONSTEXPR bool | is_negative (T value) |
|
template<typename T , FMT_ENABLE_IF(std::is_floating_point< T >::value) > |
FMT_CONSTEXPR bool | is_supported_floating_point (T) |
|
FMT_INLINE uint16_t | bsr2log10 (int bsr) |
|
int | count_digits (uint64_t n) |
|
template<unsigned BITS, typename UInt > |
int | count_digits (UInt n) |
|
template<> |
int | count_digits< 4 > (detail::fallback_uintptr n) |
|
template<typename Int > |
constexpr int | digits10 () FMT_NOEXCEPT |
|
template<> |
constexpr int | digits10< int128_t > () FMT_NOEXCEPT |
|
template<> |
constexpr int | digits10< uint128_t > () FMT_NOEXCEPT |
|
template<typename Char > |
FMT_API std::string | grouping_impl (locale_ref loc) |
|
template<typename Char > |
std::string | grouping (locale_ref loc) |
|
template<> |
std::string | grouping< wchar_t > (locale_ref loc) |
|
template<typename Char > |
FMT_API Char | thousands_sep_impl (locale_ref loc) |
|
template<typename Char > |
Char | thousands_sep (locale_ref loc) |
|
template<> |
wchar_t | thousands_sep (locale_ref loc) |
|
template<typename Char > |
FMT_API Char | decimal_point_impl (locale_ref loc) |
|
template<typename Char > |
Char | decimal_point (locale_ref loc) |
|
template<> |
wchar_t | decimal_point (locale_ref loc) |
|
template<typename Char > |
bool | equal2 (const Char *lhs, const char *rhs) |
|
bool | equal2 (const char *lhs, const char *rhs) |
|
template<typename Char > |
void | copy2 (Char *dst, const char *src) |
|
FMT_INLINE void | copy2 (char *dst, const char *src) |
|
template<typename Char , typename UInt > |
format_decimal_result< Char * > | 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 > | format_decimal (Iterator out, UInt value, int size) |
|
template<unsigned BASE_BITS, typename Char , typename UInt > |
Char * | format_uint (Char *buffer, UInt value, int num_digits, bool upper=false) |
|
template<unsigned BASE_BITS, typename Char > |
Char * | format_uint (Char *buffer, detail::fallback_uintptr n, int num_digits, bool=false) |
|
template<unsigned BASE_BITS, typename Char , typename It , typename UInt > |
It | format_uint (It out, UInt value, int num_digits, bool upper=false) |
|
template<typename T > |
FMT_API decimal_fp< T > | to_decimal (T x) FMT_NOEXCEPT |
|
template<typename T > |
constexpr dragonbox::float_info< T >::carrier_uint | exponent_mask () |
|
template<typename Char , typename It > |
It | write_exponent (int exp, It it) |
|
template<typename T > |
int | format_float (T value, int precision, float_specs specs, buffer< char > &buf) |
|
template<typename T > |
int | snprintf_float (T value, int precision, float_specs specs, buffer< char > &buf) |
|
template<typename T > |
T | promote_float (T value) |
|
double | promote_float (float value) |
|
template<typename Handler > |
FMT_CONSTEXPR void | handle_int_type_spec (char spec, Handler &&handler) |
|
template<typename ErrorHandler = error_handler, typename Char > |
FMT_CONSTEXPR float_specs | parse_float_type_spec (const basic_format_specs< Char > &specs, ErrorHandler &&eh={}) |
|
template<typename Char , typename Handler > |
FMT_CONSTEXPR void | handle_char_specs (const basic_format_specs< Char > *specs, Handler &&handler) |
|
template<typename Char , typename Handler > |
FMT_CONSTEXPR void | handle_cstring_type_spec (Char spec, Handler &&handler) |
|
template<typename Char , typename ErrorHandler > |
FMT_CONSTEXPR void | check_string_type_spec (Char spec, ErrorHandler &&eh) |
|
template<typename Char , typename ErrorHandler > |
FMT_CONSTEXPR void | check_pointer_type_spec (Char spec, ErrorHandler &&eh) |
|
template<typename OutputIt , typename Char > |
FMT_NOINLINE OutputIt | fill (OutputIt it, size_t n, const fill_t< Char > &fill) |
|
template<align::type align = align::left, typename OutputIt , typename Char , typename F > |
OutputIt | 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 | write_padded (OutputIt out, const basic_format_specs< Char > &specs, size_t size, F &&f) |
|
template<typename Char , typename OutputIt > |
OutputIt | write_bytes (OutputIt out, string_view bytes, const basic_format_specs< Char > &specs) |
|
template<typename OutputIt , typename Char , typename F > |
OutputIt | 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 | write (OutputIt out, basic_string_view< StrChar > s, const basic_format_specs< Char > &specs) |
|
template<typename Char , typename OutputIt > |
OutputIt | write_nonfinite (OutputIt out, bool isinf, const basic_format_specs< Char > &specs, const float_specs &fspecs) |
|
int | get_significand_size (const big_decimal_fp &fp) |
|
template<typename T > |
int | get_significand_size (const dragonbox::decimal_fp< T > &fp) |
|
template<typename Char , typename OutputIt > |
OutputIt | write_significand (OutputIt out, const char *significand, int &significand_size) |
|
template<typename Char , typename OutputIt , typename UInt > |
OutputIt | write_significand (OutputIt out, UInt significand, int significand_size) |
|
template<typename Char , typename UInt , FMT_ENABLE_IF(std::is_integral< UInt >::value) > |
Char * | 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 | write_significand (OutputIt out, UInt significand, int significand_size, int integral_size, Char decimal_point) |
|
template<typename OutputIt , typename Char > |
OutputIt | write_significand (OutputIt out, const char *significand, int significand_size, int integral_size, Char decimal_point) |
|
template<typename OutputIt , typename DecimalFP , typename Char > |
OutputIt | 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 | 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 | write (OutputIt out, T value) |
|
template<typename Char , typename OutputIt > |
OutputIt | write_char (OutputIt out, Char value, const basic_format_specs< Char > &specs) |
|
template<typename Char , typename OutputIt , typename UIntPtr > |
OutputIt | write_ptr (OutputIt out, UIntPtr value, const basic_format_specs< Char > *specs) |
|
template<typename Char , typename OutputIt > |
OutputIt | write (OutputIt out, monostate) |
|
template<typename Char , typename OutputIt , FMT_ENABLE_IF(!std::is_same< Char, char >::value) > |
OutputIt | write (OutputIt out, string_view value) |
|
template<typename Char , typename OutputIt > |
OutputIt | write (OutputIt out, basic_string_view< Char > value) |
|
template<typename Char > |
buffer_appender< Char > | write (buffer_appender< Char > out, basic_string_view< Char > value) |
|
template<typename Char , typename OutputIt > |
OutputIt | write (OutputIt out, bool value) |
|
template<typename Char , typename OutputIt > |
OutputIt | write (OutputIt out, Char value) |
|
template<typename Char , typename OutputIt > |
OutputIt | write (OutputIt out, const Char *value) |
|
template<typename Char , typename OutputIt > |
OutputIt | write (OutputIt out, const void *value) |
|
template<typename Char , typename OutputIt , typename T > |
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<typename Char > |
FMT_CONSTEXPR bool | is_name_start (Char c) |
|
template<typename Char , typename ErrorHandler > |
FMT_CONSTEXPR int | parse_nonnegative_int (const Char *&begin, const Char *end, ErrorHandler &&eh) |
|
template<template< typename > class Handler, typename FormatArg , typename ErrorHandler > |
FMT_CONSTEXPR int | get_dynamic_spec (FormatArg arg, ErrorHandler eh) |
|
template<typename Context , typename ID > |
FMT_CONSTEXPR Context::format_arg | get_arg (Context &ctx, ID id) |
|
template<typename Char , typename IDHandler > |
FMT_CONSTEXPR const Char * | parse_arg_id (const Char *begin, const Char *end, IDHandler &&handler) |
|
template<typename Char > |
FMT_CONSTEXPR int | code_point_length (const Char *begin) |
|
template<typename Char > |
constexpr bool | is_ascii_letter (Char c) |
|
template<typename Char , FMT_ENABLE_IF(std::is_integral< Char >::value) > |
constexpr Char | to_ascii (Char value) |
|
template<typename Char , FMT_ENABLE_IF(std::is_enum< Char >::value) > |
constexpr std::underlying_type< Char >::type | to_ascii (Char value) |
|
template<typename Char , typename Handler > |
FMT_CONSTEXPR const Char * | parse_align (const Char *begin, const Char *end, Handler &&handler) |
|
template<typename Char , typename Handler > |
FMT_CONSTEXPR const Char * | parse_width (const Char *begin, const Char *end, Handler &&handler) |
|
template<typename Char , typename Handler > |
FMT_CONSTEXPR const Char * | parse_precision (const Char *begin, const Char *end, Handler &&handler) |
|
template<typename Char , typename SpecHandler > |
FMT_CONSTEXPR const Char * | parse_format_specs (const Char *begin, const Char *end, SpecHandler &&handler) |
|
template<bool IS_CONSTEXPR, typename T , typename Ptr = const T*> |
FMT_CONSTEXPR bool | find (Ptr first, Ptr last, T value, Ptr &out) |
|
template<> |
bool | find< false, char > (const char *first, const char *last, char value, const char *&out) |
|
template<typename Char , typename Handler > |
FMT_CONSTEXPR const Char * | 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 | parse_format_string (basic_string_view< Char > format_str, Handler &&handler) |
|
template<typename T , typename ParseContext > |
FMT_CONSTEXPR const ParseContext::char_type * | parse_format_specs (ParseContext &ctx) |
|
template<typename Char , size_t N> |
FMT_CONSTEXPR basic_string_view< Char > | compile_string_to_view (const Char(&s)[N]) |
|
template<typename Char > |
FMT_CONSTEXPR basic_string_view< Char > | compile_string_to_view (const std_string_view< Char > &s) |
|
template<typename... , typename S , FMT_ENABLE_IF(is_compile_string< S >::value) > |
void | check_format_string (S) |
|
template<template< typename > class Handler, typename Context > |
void | handle_dynamic_spec (int &value, arg_ref< typename Context::char_type > ref, Context &ctx) |
|
FMT_FUNC void | format_error_code (detail::buffer< char > &out, int error_code, string_view message) FMT_NOEXCEPT |
|
FMT_FUNC void | 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 (unsigned short, unsigned) |
|
| 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 void * | ptr (const T *p) |
|
template<typename T > |
const void * | ptr (const std::unique_ptr< T > &p) |
|
template<typename T > |
const void * | ptr (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<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) |
|
◆ FMT_ALWAYS_INLINE
#define FMT_ALWAYS_INLINE inline |
◆ FMT_CATCH
#define FMT_CATCH |
( |
| x | ) |
if (false) |
◆ FMT_CUDA_VERSION
#define FMT_CUDA_VERSION 0 |
◆ FMT_DEPRECATED_NUMERIC_ALIGN
#define FMT_DEPRECATED_NUMERIC_ALIGN 0 |
◆ FMT_FALLTHROUGH
◆ FMT_FORMAT_AS
#define FMT_FORMAT_AS |
( |
| Type, |
|
|
| Base ) |
Value: template <typename Char> \
template <typename FormatContext> \
auto format(Type const& val, FormatContext& ctx) -> decltype(ctx.out()) { \
} \
}
FMT_INLINE std::basic_string< Char > format(const S &format_str, Args &&... args)
Definition at line 3481 of file format.h.
◆ FMT_FUNC
◆ FMT_HAS_BUILTIN
#define FMT_HAS_BUILTIN |
( |
| x | ) |
0 |
◆ FMT_ICC_VERSION
#define FMT_ICC_VERSION 0 |
◆ FMT_MAYBE_UNUSED
◆ FMT_NOINLINE
◆ FMT_REDUCE_INT_INSTANTIATIONS
#define FMT_REDUCE_INT_INSTANTIATIONS 0 |
◆ FMT_SAFEBUFFERS
◆ FMT_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
Definition at line 3219 of file format.h.
◆ FMT_STRING_IMPL
#define FMT_STRING_IMPL |
( |
| s, |
|
|
| base ) |
Value: [] { \
\
struct 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::compile_string_to_view<char_type>(s); \
} \
}; \
return FMT_COMPILE_STRING(); \
}()
Definition at line 3196 of file format.h.
◆ FMT_THROW
Value: do { \
static_cast<void>(sizeof(x)); \
FMT_ASSERT(false, ""); \
} while (false)
Definition at line 116 of file format.h.
Referenced by basic_printf_context< OutputIt, Char >::format(), detail::fwrite_fully(), gmtime(), localtime(), int_writer< OutputIt, Char, UInt >::on_error(), error_handler::on_error(), formatter< std::chrono::duration< Rep, Period >, Char >::spec_handler::on_error(), text_style::operator&=(), printf_precision_handler::operator()(), printf_width_handler< Char >::operator()(), printf_precision_handler::operator()(), printf_width_handler< Char >::operator()(), fill_t< Char >::operator=(), text_style::operator|=(), detail::parse_chrono_format(), chrono_format_checker::report_no_date(), utf8_to_utf16::utf8_to_utf16(), vprint(), vprint(), arg_formatter_base< OutputIt, Char, ErrorHandler >::write(), and detail::write().
◆ FMT_TRY
#define FMT_TRY if (true) |
◆ FMT_USE_DOUBLE
◆ FMT_USE_FLOAT
◆ FMT_USE_FULL_CACHE_DRAGONBOX
#define FMT_USE_FULL_CACHE_DRAGONBOX 0 |
◆ FMT_USE_LONG_DOUBLE
#define FMT_USE_LONG_DOUBLE 1 |
◆ FMT_USE_UDL_TEMPLATE
#define FMT_USE_UDL_TEMPLATE 0 |
◆ FMT_USE_USER_DEFINED_LITERALS
#define FMT_USE_USER_DEFINED_LITERALS 0 |
◆ align_t
◆ FMT_DEPRECATED_ALIAS
◆ format_args_t
template<typename OutputIt , typename Char = char>
◆ format_context_t
template<typename OutputIt , typename Char = char>
◆ format_specs
◆ memory_buffer
◆ sign_t
◆ wmemory_buffer
◆ anonymous enum
Enumerator |
---|
inline_buffer_size | |
Definition at line 621 of file format.h.
◆ advance_to()
template<typename Char , typename ErrorHandler >
Definition at line 3589 of file format.h.
References basic_format_parse_context< Char, ErrorHandler >::advance_to(), and basic_format_parse_context< Char, ErrorHandler >::begin().
Referenced by format_string_checker< Char, ErrorHandler, Args >::on_format_specs(), format_handler< OutputIt, Char, Context >::on_format_specs(), arg_formatter< OutputIt, Char >::operator()(), and detail::cf::vformat_to().
◆ FMT_FORMAT_AS() [1/10]
FMT_FORMAT_AS |
( |
Char * | , |
|
|
const Char * | ) |
◆ FMT_FORMAT_AS() [2/10]
◆ FMT_FORMAT_AS() [3/10]
FMT_FORMAT_AS |
( |
long | , |
|
|
long long | ) |
◆ FMT_FORMAT_AS() [4/10]
FMT_FORMAT_AS |
( |
short | , |
|
|
int | ) |
◆ FMT_FORMAT_AS() [5/10]
FMT_FORMAT_AS |
( |
signed char | , |
|
|
int | ) |
◆ FMT_FORMAT_AS() [6/10]
◆ FMT_FORMAT_AS() [7/10]
FMT_FORMAT_AS |
( |
std::nullptr_t | , |
|
|
const void * | ) |
◆ FMT_FORMAT_AS() [8/10]
FMT_FORMAT_AS |
( |
unsigned char | , |
|
|
unsigned | ) |
◆ FMT_FORMAT_AS() [9/10]
FMT_FORMAT_AS |
( |
unsigned long | , |
|
|
unsigned long long | ) |
◆ FMT_FORMAT_AS() [10/10]
FMT_FORMAT_AS |
( |
unsigned short | , |
|
|
unsigned | ) |
◆ format_system_error()
\rst 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. \endrst
Definition at line 2713 of file format-inl.h.
References FMT_CATCH, FMT_TRY, detail::format_error_code(), format_to(), inline_buffer_size, basic_memory_buffer< T, SIZE, Allocator >::resize(), detail::safe_strerror(), and buffer< T >::size().
Referenced by system_error::init(), and report_system_error().
◆ format_to()
template<typename S , typename... Args, size_t SIZE = inline_buffer_size, typename Char = enable_if_t<detail::is_string<S>::value, char_t<S>>>
◆ join() [1/4]
template<typename It , typename Sentinel >
Returns an object that formats the iterator range [begin, end) with elements separated by sep .
Definition at line 3681 of file format.h.
Referenced by join(), and join().
◆ join() [2/4]
template<typename It , typename Sentinel >
◆ join() [3/4]
template<typename Range >
\rst 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" \endrst
Definition at line 3707 of file format.h.
References join().
◆ join() [4/4]
template<typename Range >
◆ make_format_to_n_args()
template<typename OutputIt , typename Char , typename... Args>
◆ ptr() [1/3]
template<typename T >
const void * ptr |
( |
const std::shared_ptr< T > & | p | ) |
|
◆ ptr() [2/3]
template<typename T >
const void * ptr |
( |
const std::unique_ptr< T > & | p | ) |
|
◆ ptr() [3/3]
template<typename T >
const void * ptr |
( |
const T * | p | ) |
|
◆ report_system_error()
◆ to_string() [1/3]
template<typename Char , size_t SIZE>
◆ to_string() [2/3]
template<typename T , FMT_ENABLE_IF(!std::is_integral< T >::value) >
std::string to_string |
( |
const T & | value | ) |
|
◆ to_string() [3/3]
template<typename T , FMT_ENABLE_IF(std::is_integral< T >::value) >
std::string to_string |
( |
T | value | ) |
|
◆ to_wstring()
template<typename T >
std::wstring to_wstring |
( |
const T & | value | ) |
|
Converts value to std::wstring using the default format for type T.
Definition at line 3749 of file format.h.
References format().
◆ vformat_to()
◆ vprint() [1/2]
template<typename Char , FMT_ENABLE_IF(std::is_same< Char, wchar_t >::value) >
◆ vprint() [2/2]
template<typename Char , FMT_ENABLE_IF(std::is_same< Char, wchar_t >::value) >
|