#include <cstddef>
#include <cstdio>
#include <cstring>
#include <iterator>
#include <limits>
#include <string>
#include <type_traits>

Include dependency graph for core.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	type_identity< T >

struct	monostate

struct	detail::std_string_view< T >

class	basic_string_view< Char >

struct	is_char< T >

struct	is_char< char >

struct	detail::compile_string

struct	detail::is_compile_string< S >

struct	detail::is_string< S >

struct	detail::char_t_impl< S, typename >

struct	detail::char_t_impl< S, enable_if_t< is_string< S >::value > >

struct	detail::type_constant< T, Char >

struct	detail::error_handler

class	basic_format_parse_context< Char >

class	detail::compile_parse_context< Char >

class	basic_format_arg< Context >

class	basic_format_args< Context >

class	dynamic_format_arg_store< Context >

struct	formatter< T, Char, Enable >

struct	is_contiguous< T >

struct	is_contiguous< std::basic_string< Char > >

class	detail::buffer< T >

struct	detail::buffer_traits

class	detail::fixed_buffer_traits

class	detail::iterator_buffer< OutputIt, T, Traits >

class	detail::iterator_buffer< T *, T, fixed_buffer_traits >

class	detail::iterator_buffer< T *, T >

class	detail::iterator_buffer< std::back_insert_iterator< Container >, enable_if_t< is_contiguous< Container >::value, typename Container::value_type > >

class	detail::counting_buffer< T >

struct	detail::view

struct	detail::named_arg< Char, T >

struct	detail::named_arg_info< Char >

struct	detail::arg_data< T, Char, NUM_ARGS, NUM_NAMED_ARGS >

struct	detail::arg_data< T, Char, NUM_ARGS, 0 >

struct	detail::is_named_arg< T >

struct	detail::is_statically_named_arg< T >

struct	detail::is_named_arg< named_arg< Char, T > >

struct	detail::unformattable

struct	detail::unformattable_char

struct	detail::unformattable_pointer

struct	detail::string_value< Char >

struct	detail::named_arg_value< Char >

struct	detail::custom_value< Context >

class	detail::value< Context >

struct	detail::format_as_result< T >

struct	detail::has_format_as< T >

struct	detail::arg_mapper< Context >

struct	detail::arg_mapper< Context >::formattable< T, U >

class	appender

class	basic_format_arg< Context >

class	basic_format_arg< Context >::handle

struct	detail::is_output_iterator< It, T, Enable >

struct	detail::is_output_iterator< It, T, void_t< typename std::iterator_traits< It >::iterator_category, decltype(*std::declval< It >()=std::declval< T >())> >

struct	detail::is_back_insert_iterator< It >

struct	detail::is_back_insert_iterator< std::back_insert_iterator< Container > >

struct	detail::is_contiguous_back_insert_iterator< It >

struct	detail::is_contiguous_back_insert_iterator< std::back_insert_iterator< Container > >

struct	detail::is_contiguous_back_insert_iterator< appender >

class	detail::locale_ref

class	basic_format_context< OutputIt, Char >

class	format_arg_store< Context, Args >

class	basic_format_args< Context >

struct	detail::fill_t< Char >

struct	format_specs< Char >

struct	detail::arg_ref< Char >

union	detail::arg_ref< Char >::value

struct	detail::dynamic_format_specs< Char >

struct	detail::dynamic_spec_id_handler< Char >

struct	detail::strip_named_arg< T, bool >

struct	detail::strip_named_arg< T, true >

class	detail::format_string_checker< Char, Args >

struct	detail::vformat_args< Char >

struct	detail::vformat_args< char >

struct	formatter< T, Char, enable_if_t< detail::type_constant< T, Char >::value!=detail::type::custom_type > >

struct	runtime_format_string< Char >

class	basic_format_string< Char, Args >

struct	format_to_n_result< OutputIt >

Namespaces
	detail

	align

	sign

Macros
#define	FMT_VERSION 100000

#define	FMT_CLANG_VERSION 0

#define	FMT_GCC_VERSION 0

#define	FMT_GCC_PRAGMA(arg)

#define	FMT_ICC_VERSION 0

#define	FMT_MSC_VERSION 0

#define	FMT_MSC_WARNING(...)

#define	FMT_CPLUSPLUS __cplusplus

#define	FMT_HAS_FEATURE(x) 0

#define	FMT_HAS_INCLUDE(x) 0

#define	FMT_HAS_CPP_ATTRIBUTE(x) 0

#define	FMT_HAS_CPP14_ATTRIBUTE(attribute) (FMT_CPLUSPLUS >= 201402L && FMT_HAS_CPP_ATTRIBUTE(attribute))

#define	FMT_HAS_CPP17_ATTRIBUTE(attribute) (FMT_CPLUSPLUS >= 201703L && FMT_HAS_CPP_ATTRIBUTE(attribute))

#define	FMT_USE_CONSTEXPR 0

#define	FMT_CONSTEXPR

#define	FMT_CONSTEXPR20

#define	FMT_CONSTEXPR_CHAR_TRAITS

#define	FMT_EXCEPTIONS 1

#define	FMT_NORETURN

#define	FMT_NODISCARD

#define	FMT_INLINE inline

#define	FMT_FORWARD(...) static_cast<decltype(__VA_ARGS__)&&>(__VA_ARGS__)

#define	FMT_UNCHECKED_ITERATOR(It) using unchecked_type = It

#define	FMT_BEGIN_NAMESPACE

#define	FMT_END_NAMESPACE

#define	FMT_MODULE_EXPORT

#define	FMT_BEGIN_EXPORT

#define	FMT_END_EXPORT

#define	FMT_API

#define	FMT_UNICODE !FMT_MSC_VERSION

#define	FMT_CONSTEVAL

#define	FMT_USE_NONTYPE_TEMPLATE_ARGS 0

#define	FMT_INLINE_VARIABLE

#define	FMT_ENABLE_IF(...) fmt::enable_if_t<(__VA_ARGS__), int> = 0

#define	FMT_ASSERT(condition, message)

#define	FMT_USE_INT128 0

#define	FMT_TYPE_CONSTANT(Type, constant)

#define	FMT_ENUM_UNDERLYING_TYPE(type) : type

#define	FMT_FORMAT_AS(Type, Base)

Typedefs
template<bool B, typename T = void>
using	enable_if_t = typename std::enable_if< B, T >::type

template<bool B, typename T , typename F >
using	conditional_t = typename std::conditional< B, T, F >::type

template<bool B>
using	bool_constant = std::integral_constant< bool, B >

template<typename T >
using	remove_reference_t = typename std::remove_reference< T >::type

template<typename T >
using	remove_const_t = typename std::remove_const< T >::type

template<typename T >
using	remove_cvref_t = typename std::remove_cv< remove_reference_t< T >>::type

template<typename T >
using	type_identity_t = typename type_identity< T >::type

template<typename T >
using	underlying_t = typename std::underlying_type< T >::type

using	string_view = basic_string_view< char >

template<typename S >
using	char_t = typename detail::char_t_impl< S >::type

using	format_parse_context = basic_format_parse_context< char >

template<typename T , typename Context >
using	has_formatter = std::is_constructible< typename Context::template formatter_type< T >>

template<typename T >
using	detail::buffer_appender = conditional_t< std::is_same< T, char >::value, appender, std::back_insert_iterator< buffer< T >>>

using	detail::long_type = conditional_t< long_short, int, long long >

using	detail::ulong_type = conditional_t< long_short, unsigned, unsigned long long >

template<typename T >
using	detail::format_as_t = typename format_as_result< T >::type

template<typename T , typename Context >
using	detail::mapped_type_constant = type_constant< decltype(arg_mapper< Context >().map(std::declval< const T & >())), typename Context::char_type >

template<typename... >
using	detail::void_t = void

template<typename Char >
using	buffer_context = basic_format_context< detail::buffer_appender< Char >, Char >

using	format_context = buffer_context< char >

template<typename T , typename Char = char>
using	is_formattable = bool_constant<!std::is_base_of< detail::unformattable, decltype(detail::arg_mapper< buffer_context< Char >>().map(std::declval< T >()))>::value >

using	format_args = basic_format_args< format_context >

using	align_t = align::type

using	sign_t = sign::type

template<typename... Args>
using	format_string = basic_format_string< char, type_identity_t< Args >...>

Enumerations
enum	detail::int128_opt

enum	detail::uint128_opt

enum	detail::type { detail::type::none_type, detail::type::int_type, detail::type::uint_type, detail::type::long_long_type, detail::type::ulong_long_type, detail::type::int128_type, detail::type::uint128_type, detail::type::bool_type, detail::type::char_type, detail::type::last_integer_type = char_type, detail::type::float_type, detail::type::double_type, detail::type::long_double_type, detail::type::last_numeric_type = long_double_type, detail::type::cstring_type, detail::type::string_type, detail::type::pointer_type, detail::type::custom_type }

enum	{ detail::sint_set, detail::uint_set, detail::bool_set = set(type::bool_type), detail::char_set = set(type::char_type), detail::float_set, detail::string_set = set(type::string_type), detail::cstring_set = set(type::cstring_type), detail::pointer_set = set(type::pointer_type) }

enum	{ detail::long_short = sizeof(long) == sizeof(int) }

enum	{ detail::packed_arg_bits = 4 }

enum	{ detail::max_packed_args = 62 / packed_arg_bits }

enum	: unsigned long long { detail::is_unpacked_bit = 1ULL << 63 }

enum	: unsigned long long { detail::has_named_args_bit = 1ULL << 62 }

enum	presentation_type : unsigned char { presentation_type::none, presentation_type::dec, presentation_type::oct, presentation_type::hex_lower, presentation_type::hex_upper, presentation_type::bin_lower, presentation_type::bin_upper, presentation_type::hexfloat_lower, presentation_type::hexfloat_upper, presentation_type::exp_lower, presentation_type::exp_upper, presentation_type::fixed_lower, presentation_type::fixed_upper, presentation_type::general_lower, presentation_type::general_upper, presentation_type::chr, presentation_type::string, presentation_type::pointer, presentation_type::debug }

enum	detail::arg_id_kind { detail::arg_id_kind::none, detail::arg_id_kind::index, detail::arg_id_kind::name }

enum	detail::state { detail::state::start, detail::state::align, detail::state::sign, detail::state::hash, detail::state::zero, detail::state::width, detail::state::precision, detail::state::locale }

Functions
template<typename... T>
FMT_CONSTEXPR void	detail::ignore_unused (const T &...)

constexpr FMT_INLINE auto	detail::is_constant_evaluated (bool default_value=false) noexcept-> bool

template<typename T >
constexpr FMT_INLINE auto	detail::const_check (T value) -> T

FMT_NORETURN FMT_API void	detail::assert_fail (const char file, int line, const char message)

template<typename T >
auto	detail::convert_for_visit (T) -> monostate

template<typename Int >
FMT_CONSTEXPR auto	detail::to_unsigned (Int value) -> typename std::make_unsigned< Int >::type

FMT_CONSTEXPR auto	detail::is_utf8 () -> bool

template<typename Char , FMT_ENABLE_IF(is_char< Char >::value) >
FMT_INLINE auto	detail::to_string_view (const Char *s) -> basic_string_view< Char >

template<typename Char , typename Traits , typename Alloc >
auto	detail::to_string_view (const std::basic_string< Char, Traits, Alloc > &s) -> basic_string_view< Char >

template<typename Char >
constexpr auto	detail::to_string_view (basic_string_view< Char > s) -> basic_string_view< Char >

template<typename Char , FMT_ENABLE_IF(!std::is_empty< std_string_view< Char >>::value) >
auto	detail::to_string_view (std_string_view< Char > s) -> basic_string_view< Char >

template<typename S , FMT_ENABLE_IF(is_compile_string< S >::value) >
constexpr auto	detail::to_string_view (const S &s) -> basic_string_view< typename S::char_type >

void	detail::to_string_view (...)

	detail::FMT_TYPE_CONSTANT (int, int_type)

	detail::FMT_TYPE_CONSTANT (unsigned, uint_type)

	detail::FMT_TYPE_CONSTANT (long long, long_long_type)

	detail::FMT_TYPE_CONSTANT (unsigned long long, ulong_long_type)

	detail::FMT_TYPE_CONSTANT (int128_opt, int128_type)

	detail::FMT_TYPE_CONSTANT (uint128_opt, uint128_type)

	detail::FMT_TYPE_CONSTANT (bool, bool_type)

	detail::FMT_TYPE_CONSTANT (Char, char_type)

	detail::FMT_TYPE_CONSTANT (float, float_type)

	detail::FMT_TYPE_CONSTANT (double, double_type)

	detail::FMT_TYPE_CONSTANT (long double, long_double_type)

	detail::FMT_TYPE_CONSTANT (const Char *, cstring_type)

	detail::FMT_TYPE_CONSTANT (basic_string_view< Char >, string_type)

	detail::FMT_TYPE_CONSTANT (const void *, pointer_type)

constexpr bool	detail::is_integral_type (type t)

constexpr bool	detail::is_arithmetic_type (type t)

constexpr auto	detail::set (type rhs) -> int

constexpr auto	detail::in (type t, int set) -> bool

FMT_NORETURN FMT_API void	detail::throw_format_error (const char *message)

template<typename Context , typename T >
constexpr auto	detail::has_const_formatter_impl (T *) -> decltype(typename Context::template formatter_type< T >().format(std::declval< const T & >(), std::declval< Context & >()), true)

template<typename Context >
constexpr auto	detail::has_const_formatter_impl (...) -> bool

template<typename T , typename Context >
constexpr auto	detail::has_const_formatter () -> bool

template<typename Container >
auto	detail::get_container (std::back_insert_iterator< Container > it) -> Container &

template<typename Char , typename InputIt , typename OutputIt >
FMT_CONSTEXPR auto	detail::copy_str (InputIt begin, InputIt end, OutputIt out) -> OutputIt

template<typename Char , typename T , typename U , FMT_ENABLE_IF(std::is_same< remove_const_t< T >, U >::value &&is_char< U >::value) >
FMT_CONSTEXPR auto	detail::copy_str (T begin, T end, U out) -> U

template<typename T , typename OutputIt >
auto	detail::get_buffer (OutputIt out) -> iterator_buffer< OutputIt, T >

template<typename T , typename Buf , FMT_ENABLE_IF(std::is_base_of< buffer< char >, Buf >::value) >
auto	detail::get_buffer (std::back_insert_iterator< Buf > out) -> buffer< char > &

template<typename Buf , typename OutputIt >
FMT_INLINE auto	detail::get_iterator (Buf &buf, OutputIt) -> decltype(buf.out())

template<typename T , typename OutputIt >
auto	detail::get_iterator (buffer< T > &, OutputIt out) -> OutputIt

template<typename Char >
void	detail::init_named_args (named_arg_info< Char > *, int, int)

template<typename Char , typename T , typename... Tail, FMT_ENABLE_IF(!is_named_arg< T >::value) >
void	detail::init_named_args (named_arg_info< Char > *named_args, int arg_count, int named_arg_count, const T &, const Tail &...args)

template<typename... Args>
FMT_CONSTEXPR FMT_INLINE void	detail::init_named_args (std::nullptr_t, int, int, const Args &...)

template<bool B = false>
constexpr auto	detail::count () -> size_t

template<bool B1, bool B2, bool... Tail>
constexpr auto	detail::count () -> size_t

template<typename... Args>
constexpr auto	detail::count_named_args () -> size_t

template<typename... Args>
constexpr auto	detail::count_statically_named_args () -> size_t

template<typename Context , typename T >
FMT_CONSTEXPR auto	detail::make_arg (T &&value) -> basic_format_arg< Context >

template<typename Visitor , typename Context >
FMT_MODULE_EXPORT FMT_CONSTEXPR FMT_INLINE auto	visit_format_arg (Visitor &&vis, const basic_format_arg< Context > &arg) -> decltype(vis(0))

template<typename Char , typename InputIt >
auto	detail::copy_str (InputIt begin, InputIt end, appender out) -> appender

template<typename Char , typename R , typename OutputIt >
FMT_CONSTEXPR auto	detail::copy_str (R &&rng, OutputIt out) -> OutputIt

template<typename >
constexpr auto	detail::encode_types () -> unsigned long long

template<typename Context , typename Arg , typename... Args>
constexpr auto	detail::encode_types () -> unsigned long long

template<typename Context , typename T >
FMT_CONSTEXPR FMT_INLINE auto	detail::make_value (T &&val) -> value< Context >

template<bool IS_PACKED, typename Context , type , typename T , FMT_ENABLE_IF(IS_PACKED) >
FMT_CONSTEXPR FMT_INLINE auto	detail::make_arg (T &&val) -> value< Context >

template<bool IS_PACKED, typename Context , type , typename T , FMT_ENABLE_IF(!IS_PACKED) >
FMT_CONSTEXPR auto	detail::make_arg (T &&value) -> basic_format_arg< Context >

template<typename Context = format_context, typename... T>
constexpr auto	make_format_args (T &&...args) -> format_arg_store< Context, remove_cvref_t< T >...>

template<typename Char , typename T >
auto	arg (const Char *name, const T &arg) -> detail::named_arg< Char, T >

enum type	align::FMT_ENUM_UNDERLYING_TYPE (unsigned char)

enum type	sign::FMT_ENUM_UNDERLYING_TYPE (unsigned char)

template<typename Char , FMT_ENABLE_IF(std::is_integral< Char >::value) >
constexpr auto	detail::to_ascii (Char c) -> char

template<typename Char >
FMT_CONSTEXPR auto	detail::code_point_length (const Char *begin) -> int

template<bool IS_CONSTEXPR, typename T , typename Ptr = const T*>
FMT_CONSTEXPR auto	detail::find (Ptr first, Ptr last, T value, Ptr &out) -> bool

template<>
auto	detail::find< false, char > (const char first, const char last, char value, const char *&out) -> bool

template<typename Char >
FMT_CONSTEXPR auto	detail::parse_nonnegative_int (const Char &begin, const Char end, int error_value) noexcept-> int

FMT_CONSTEXPR auto	detail::parse_align (char c) -> align_t

template<typename Char >
constexpr auto	detail::is_name_start (Char c) -> bool

template<typename Char , typename Handler >
FMT_CONSTEXPR auto	detail::do_parse_arg_id (const Char begin, const Char end, Handler &&handler) -> const Char *

template<typename Char , typename Handler >
FMT_CONSTEXPR FMT_INLINE auto	detail::parse_arg_id (const Char begin, const Char end, Handler &&handler) -> const Char *

template<typename Char >
FMT_CONSTEXPR auto	detail::parse_dynamic_spec (const Char begin, const Char end, int &value, arg_ref< Char > &ref, basic_format_parse_context< Char > &ctx) -> const Char *

template<typename Char >
FMT_CONSTEXPR auto	detail::parse_precision (const Char begin, const Char end, int &value, arg_ref< Char > &ref, basic_format_parse_context< Char > &ctx) -> const Char *

template<typename Char >
FMT_CONSTEXPR FMT_INLINE auto	detail::parse_format_specs (const Char begin, const Char end, dynamic_format_specs< Char > &specs, basic_format_parse_context< Char > &ctx, type arg_type) -> const Char *

template<typename Char , typename Handler >
FMT_CONSTEXPR auto	detail::parse_replacement_field (const Char begin, const Char end, Handler &&handler) -> const Char *

template<bool IS_CONSTEXPR, typename Char , typename Handler >
FMT_CONSTEXPR FMT_INLINE void	detail::parse_format_string (basic_string_view< Char > format_str, Handler &&handler)

template<typename T , typename ParseContext >
FMT_CONSTEXPR auto	detail::parse_format_specs (ParseContext &ctx) -> decltype(ctx.begin())

template<typename Char >
FMT_CONSTEXPR auto	detail::check_char_specs (const format_specs< Char > &specs) -> bool

template<typename... Args, typename Char >
FMT_CONSTEXPR auto	detail::get_arg_index_by_name (basic_string_view< Char > name) -> int

template<typename... , typename S , FMT_ENABLE_IF(!is_compile_string< S >::value) >
FMT_INLINE void	detail::check_format_string (const S &)

template<typename... Args, typename S , FMT_ENABLE_IF(is_compile_string< S >::value) >
void	detail::check_format_string (S format_str)

template<typename Char >
void	detail::vformat_to (buffer< Char > &buf, basic_string_view< Char > fmt, typename vformat_args< Char >::type args, locale_ref loc={})

FMT_API void	detail::vprint_mojibake (std::FILE *, string_view, format_args)

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

auto	runtime (string_view s) -> runtime_format_string<>

FMT_API auto	vformat (string_view fmt, format_args args) -> std::string

template<typename... T>
FMT_NODISCARD FMT_INLINE auto	format (format_string< T...> fmt, T &&...args) -> std::string

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

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

template<typename OutputIt , typename... T, FMT_ENABLE_IF(detail::is_output_iterator< OutputIt, char >::value) >
auto	vformat_to_n (OutputIt out, size_t n, string_view fmt, format_args args) -> format_to_n_result< OutputIt >

template<typename OutputIt , typename... T, FMT_ENABLE_IF(detail::is_output_iterator< OutputIt, char >::value) >
FMT_INLINE auto	format_to_n (OutputIt out, size_t n, format_string< T...> fmt, T &&...args) -> format_to_n_result< OutputIt >

template<typename... T>
FMT_NODISCARD FMT_INLINE auto	formatted_size (format_string< T...> fmt, T &&...args) -> size_t

FMT_API void	vprint (string_view fmt, format_args args)

FMT_API void	vprint (std::FILE *f, string_view fmt, format_args args)

template<typename... T>
FMT_INLINE void	print (format_string< T...> fmt, T &&...args)

template<typename... T>
FMT_INLINE void	print (std::FILE *f, format_string< T...> fmt, T &&...args)

template<typename... T>
FMT_INLINE void	println (std::FILE *f, format_string< T...> fmt, T &&...args)

template<typename... T>
FMT_INLINE void	println (format_string< T...> fmt, T &&...args)

Variables
constexpr FMT_INLINE_VARIABLE int	detail::invalid_arg_index = -1

Macro Definition Documentation

#define FMT_API

Definition at line 204 of file core.h.

#define FMT_ASSERT	(	condition,
		message
	)

Value:

((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
           ? (void)0                                                          \
           : fmt::detail::assert_fail(__FILE__, __LINE__, (message)))

Definition at line 336 of file core.h.

#define FMT_BEGIN_EXPORT

Definition at line 186 of file core.h.

#define FMT_BEGIN_NAMESPACE

Value:

namespace fmt { \

inline namespace v10 {

Definition at line 176 of file core.h.

#define FMT_CLANG_VERSION 0

Definition at line 25 of file core.h.

#define FMT_CONSTEVAL

Definition at line 232 of file core.h.

#define FMT_CONSTEXPR

Definition at line 104 of file core.h.

#define FMT_CONSTEXPR20

Definition at line 112 of file core.h.

#define FMT_CONSTEXPR_CHAR_TRAITS

Definition at line 128 of file core.h.

#define FMT_CPLUSPLUS __cplusplus

Definition at line 63 of file core.h.

#define FMT_ENABLE_IF ( ... ) fmt::enable_if_t<(__VA_ARGS__), int> = 0

Definition at line 289 of file core.h.

#define FMT_END_EXPORT

Definition at line 187 of file core.h.

#define FMT_END_NAMESPACE

Value:

} \

}

Definition at line 179 of file core.h.

#define FMT_ENUM_UNDERLYING_TYPE ( type ) : type

Definition at line 1998 of file core.h.

#define FMT_EXCEPTIONS 1

Definition at line 137 of file core.h.

#define FMT_FORMAT_AS	(	Type,
		Base
	)

Value:

template <typename Char>                                               \
  struct formatter<Type, Char> : formatter<Base, Char> {                 \
    template <typename FormatContext>                                    \
    auto format(const Type& val, FormatContext& ctx) const               \
        -> decltype(ctx.out()) {                                         \
      return formatter<Base, Char>::format(static_cast<Base>(val), ctx); \
    }                                                                    \
  }

Definition at line 2724 of file core.h.

#define FMT_FORWARD ( ... ) static_cast<decltype(__VA_ARGS__)&&>(__VA_ARGS__)

Definition at line 166 of file core.h.

#define FMT_GCC_PRAGMA ( arg )

Definition at line 40 of file core.h.

#define FMT_GCC_VERSION 0

Definition at line 32 of file core.h.

#define FMT_HAS_CPP14_ATTRIBUTE ( attribute ) (FMT_CPLUSPLUS >= 201402L && FMT_HAS_CPP_ATTRIBUTE(attribute))

Definition at line 84 of file core.h.

#define FMT_HAS_CPP17_ATTRIBUTE ( attribute ) (FMT_CPLUSPLUS >= 201703L && FMT_HAS_CPP_ATTRIBUTE(attribute))

Definition at line 87 of file core.h.

#define FMT_HAS_CPP_ATTRIBUTE ( x ) 0

Definition at line 81 of file core.h.

#define FMT_HAS_FEATURE ( x ) 0

Definition at line 69 of file core.h.

#define FMT_HAS_INCLUDE ( x ) 0

Definition at line 75 of file core.h.

#define FMT_ICC_VERSION 0

Definition at line 49 of file core.h.

#define FMT_INLINE inline

Definition at line 161 of file core.h.

#define FMT_INLINE_VARIABLE

Definition at line 250 of file core.h.

#define FMT_MODULE_EXPORT

Definition at line 185 of file core.h.

#define FMT_MSC_VERSION 0

Definition at line 56 of file core.h.

#define FMT_MSC_WARNING ( ... )

Definition at line 57 of file core.h.

#define FMT_NODISCARD

Definition at line 153 of file core.h.

#define FMT_NORETURN

Definition at line 146 of file core.h.

#define FMT_TYPE_CONSTANT	(	Type,
		constant
	)

Value:

template <typename Char>                \
  struct type_constant<Type, Char>        \
      : std::integral_constant<type, type::constant> {}

Definition at line 583 of file core.h.

#define FMT_UNCHECKED_ITERATOR ( It ) using unchecked_type = It

Definition at line 172 of file core.h.

#define FMT_UNICODE !FMT_MSC_VERSION

Definition at line 218 of file core.h.

#define FMT_USE_CONSTEXPR 0

Definition at line 98 of file core.h.

#define FMT_USE_INT128 0

Definition at line 363 of file core.h.

#define FMT_USE_NONTYPE_TEMPLATE_ARGS 0

Definition at line 243 of file core.h.

#define FMT_VERSION 100000

Definition at line 20 of file core.h.

Typedef Documentation

using align_t = align::type

Definition at line 2004 of file core.h.

template<bool B>

using bool_constant = std::integral_constant<bool, B>

Definition at line 267 of file core.h.

template<typename Char >

using buffer_context = basic_format_context<detail::buffer_appender<Char>, Char>

Definition at line 1775 of file core.h.

template<typename S >

using char_t = typename detail::char_t_impl<S>::type

String's character type.

Definition at line 643 of file core.h.

template<bool B, typename T , typename F >

using conditional_t = typename std::conditional<B, T, F>::type

Definition at line 266 of file core.h.

template<bool B, typename T = void>

using enable_if_t = typename std::enable_if<B, T>::type

Definition at line 264 of file core.h.

using format_args = basic_format_args<format_context>

An alias to basic_format_args<format_context>.

Definition at line 1989 of file core.h.

using format_context = buffer_context<char>

Definition at line 1776 of file core.h.

using format_parse_context = basic_format_parse_context<char>

Definition at line 719 of file core.h.

template<typename... Args>

using format_string = basic_format_string<char, type_identity_t<Args>...>

Definition at line 2787 of file core.h.

template<typename T , typename Context >

using has_formatter = std::is_constructible<typename Context::template formatter_type<T>>

Definition at line 799 of file core.h.

template<typename T , typename Char = char>

using is_formattable = bool_constant<!std::is_base_of< detail::unformattable, decltype(detail::arg_mapper<buffer_context<Char>>() .map(std::declval<T>()))>::value>

Definition at line 1781 of file core.h.

template<typename T >

using remove_const_t = typename std::remove_const<T>::type

Definition at line 271 of file core.h.

template<typename T >

using remove_cvref_t = typename std::remove_cv<remove_reference_t<T>>::type

Definition at line 273 of file core.h.

template<typename T >

using remove_reference_t = typename std::remove_reference<T>::type

Definition at line 269 of file core.h.

using sign_t = sign::type

Definition at line 2008 of file core.h.

using string_view = basic_string_view<char>

Definition at line 501 of file core.h.

template<typename T >

using type_identity_t = typename type_identity<T>::type

Definition at line 275 of file core.h.

template<typename T >

using underlying_t = typename std::underlying_type<T>::type

Definition at line 277 of file core.h.

Enumeration Type Documentation

enum presentation_type : unsigned char

strong

Enumerator
none
dec
oct
hex_lower
hex_upper
bin_lower
bin_upper
hexfloat_lower
hexfloat_upper
exp_lower
exp_upper
fixed_lower
fixed_upper
general_lower
general_upper
chr
string
pointer
debug

Definition at line 2037 of file core.h.

Function Documentation

template<typename Char , typename T >

auto arg	(	const Char *	name,
		const T &	arg
	)		-> detail::named_arg<Char, T>

inline

Returns a named argument to be used in a formatting function. It should only be used in a call to a formatting function or dynamic_format_arg_store::push_back.

Example**::

fmt::print("Elapsed time: {s:.2f} seconds", fmt::arg("s", 1.23));

Definition at line 1859 of file core.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... T>

FMT_NODISCARD FMT_INLINE auto format	(	format_string< T...>	fmt,
		T &&...	args
	)		-> std::string

Formats args according to specifications in fmt and returns the result as a string.

Example**::

#include <fmt/core.h> std::string message = fmt::format("The answer is {}.", 42);

Definition at line 2815 of file core.h.

template<typename OutputIt , typename... T, FMT_ENABLE_IF(detail::is_output_iterator< OutputIt, char >::value) >

FMT_INLINE auto format_to	(	OutputIt	out,
		format_string< T...>	fmt,
		T &&...	args
	)		-> OutputIt

Formats args according to specifications in fmt, writes the result to the output iterator out and returns the iterator past the end of the output range. format_to does not append a terminating null character.

Example**::

auto out = std::vector<char>(); fmt::format_to(std::back_inserter(out), "{}", 42);

Definition at line 2843 of file core.h.

template<typename OutputIt , typename... T, FMT_ENABLE_IF(detail::is_output_iterator< OutputIt, char >::value) >

FMT_INLINE auto format_to_n	(	OutputIt	out,
		size_t	n,
		format_string< T...>	fmt,
		T &&...	args
	)		-> format_to_n_result<OutputIt>

Formats args according to specifications in fmt, writes up to n characters of the result to the output iterator out and returns the total (not truncated) output size and the iterator past the end of the output range. format_to_n does not append a terminating null character.

Definition at line 2875 of file core.h.

template<typename... T>

FMT_NODISCARD FMT_INLINE auto formatted_size	(	format_string< T...>	fmt,
		T &&...	args
	)		-> size_t

Returns the number of chars in the output of format(fmt, args...).

Definition at line 2882 of file core.h.

template<typename Context = format_context, typename... T>

constexpr auto make_format_args ( T &&... args ) -> format_arg_store<Context, remove_cvref_t<T>...>

Constructs a ~fmtformat_arg_store object that contains references to arguments and can be implicitly converted to ~fmtformat_args. Context can be omitted in which case it defaults to ~fmt::context. See ~fmtarg for lifetime considerations.

Definition at line 1842 of file core.h.

template<typename... T>

FMT_INLINE void print	(	format_string< T...>	fmt,
		T &&...	args
	)

Formats args according to specifications in fmt and writes the output to stdout.

Example**::

fmt::print("Elapsed time: {0:.2f} seconds", 1.23);

Definition at line 2903 of file core.h.

template<typename... T>

FMT_INLINE void print	(	std::FILE *	f,
		format_string< T...>	fmt,
		T &&...	args
	)

Formats args according to specifications in fmt and writes the output to the file f.

Example**::

fmt::print(stderr, "Don't {}!", "panic");

Definition at line 2920 of file core.h.

template<typename... T>

FMT_INLINE void println	(	std::FILE *	f,
		format_string< T...>	fmt,
		T &&...	args
	)

Formats args according to specifications in fmt and writes the output to the file f followed by a newline.

Definition at line 2931 of file core.h.

template<typename... T>

FMT_INLINE void println	(	format_string< T...>	fmt,
		T &&...	args
	)

Formats args according to specifications in fmt and writes the output to stdout followed by a newline.

Definition at line 2940 of file core.h.

auto runtime ( string_view s ) -> runtime_format_string<>

inline

Creates a runtime format string.

Example**::

Check format string at runtime instead of compile-time. fmt::print(fmt::runtime("{:d}"), "I am not a number");

Definition at line 2798 of file core.h.

FMT_API auto vformat	(	string_view	fmt,
		format_args	args
	)		-> std::string

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

template<typename OutputIt , FMT_ENABLE_IF(detail::is_output_iterator< OutputIt, char >::value) >

auto vformat_to	(	OutputIt	out,
		string_view	fmt,
		format_args	args
	)		-> OutputIt

Formats a string and writes the output to out.

Definition at line 2823 of file core.h.

template<typename OutputIt , typename... T, FMT_ENABLE_IF(detail::is_output_iterator< OutputIt, char >::value) >

auto vformat_to_n	(	OutputIt	out,
		size_t	n,
		string_view	fmt,
		format_args	args
	)		-> format_to_n_result<OutputIt>

Definition at line 2857 of file core.h.

template<typename Visitor , typename Context >

FMT_MODULE_EXPORT FMT_CONSTEXPR FMT_INLINE auto visit_format_arg	(	Visitor &&	vis,
		const basic_format_arg< Context > &	arg
	)		-> decltype(vis(0))

Visits an argument dispatching to the appropriate visit method based on the argument type. For example, if the argument type is double then vis(value) will be called with the value of type double.

Definition at line 1564 of file core.h.

FMT_API void vprint	(	string_view	fmt,
		format_args	args
	)

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

FMT_API void vprint	(	std::FILE *	f,
		string_view	fmt,
		format_args	args
	)

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

Classes

Namespaces

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

Typedef Documentation

Enumeration Type Documentation

Function Documentation