core.h File Reference

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

Go to the source code of this file.

Classes
struct	type_identity< T >
struct	is_contiguous< T >
struct	is_contiguous< std::basic_string< Char > >
struct	monostate
struct	detail::std_string_view< T >
class	basic_string_view< Char >
	An implementation of std::basic_string_view for pre-C++17. More...
struct	is_char< T >
	Specifies if T is a character type. More...
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 >
	\rst Parsing context consisting of a format string range being parsed and an argument counter for automatic indexing. More...
class	detail::compile_parse_context< Char >
class	detail::buffer< T >
	\rst A contiguous memory buffer with an optional growing ability. More...
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	formatter< T, Char, Enable >
class	appender
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 >
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 > >
class	detail::locale_ref
class	basic_format_arg< Context >
class	basic_format_arg< Context >::handle
class	basic_format_context< OutputIt, Char >
class	format_arg_store< Context, Args >
	\rst An array of references to arguments. More...
class	basic_format_args< Context >
	\rst A view of a collection of formatting arguments. More...
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 >
	A compile-time format string. More...
struct	format_to_n_result< OutputIt >

Namespaces
namespace	detail
	detail namespace with internal helper functions
namespace	align
namespace	sign

Macros
#define	FMT_VERSION   100100
#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_UNCHECKED_ITERATOR(It)   using unchecked_type = It
#define	FMT_BEGIN_NAMESPACE
#define	FMT_END_NAMESPACE
#define	FMT_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_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

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
	String's character type. More...
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 >
	An alias to basic_format_args<format_context>. More...
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 class	detail::int128_opt
enum class	detail::uint128_opt
enum class	detail::type {   detail::none_type , detail::int_type , detail::uint_type , detail::long_long_type ,   detail::ulong_long_type , detail::int128_type , detail::uint128_type , detail::bool_type ,   detail::char_type , detail::last_integer_type = char_type , detail::float_type , detail::double_type ,   detail::long_double_type , detail::last_numeric_type = long_double_type , detail::cstring_type , detail::string_type ,   detail::pointer_type , detail::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 class	presentation_type : unsigned char {   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 }
enum class	detail::arg_id_kind { detail::none , detail::index , detail::name }
enum class	detail::state {   detail::start , detail::align , detail::sign , detail::hash ,   detail::zero , detail::width , detail::precision , detail::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 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 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 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 Char , typename InputIt >
auto	detail::copy_str (InputIt begin, InputIt end, appender out) -> appender
template<typename Char , typename InputIt >
auto	detail::copy_str (InputIt begin, InputIt end, std::back_insert_iterator< std::string > out) -> std::back_insert_iterator< std::string >
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<bool PACKED, typename Context , typename T , FMT_ENABLE_IF(PACKED) >
FMT_CONSTEXPR FMT_INLINE auto	detail::make_arg (T &val) -> value< Context >
template<typename Context , typename T >
FMT_CONSTEXPR auto	detail::make_arg (T &val) -> basic_format_arg< Context >
template<bool PACKED, typename Context , typename T , FMT_ENABLE_IF(!PACKED) >
FMT_CONSTEXPR auto	detail::make_arg (T &val) -> basic_format_arg< Context >
template<typename Visitor , typename Context >
FMT_CONSTEXPR FMT_INLINE auto	visit_format_arg (Visitor &&vis, const basic_format_arg< Context > &arg) -> decltype(vis(0))
	\rst Visits an argument dispatching to the appropriate visit method based on the argument type. More...
template<typename Context = format_context, typename... T>
constexpr auto	make_format_args (T &... args) -> format_arg_store< Context, remove_cvref_t< T >... >
	\rst Constructs a ~fmtformat_arg_store object that contains references to arguments and can be implicitly converted to ~fmtformat_args. More...
template<typename Char , typename T >
auto	arg (const Char *name, const T &arg) -> detail::named_arg< Char, T >
	\rst Returns a named argument to be used in a formatting function. More...
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)
auto	runtime (string_view s) -> runtime_format_string<>
	\rst Creates a runtime format string. More...
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
	\rst Formats args according to specifications in fmt and returns the result as a string. More...
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. More...
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
	\rst 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. More...
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 >
	\rst 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. More...
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...). More...
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)
	\rst Formats args according to specifications in fmt and writes the output to stdout. More...
template<typename... T>
FMT_INLINE void	print (std::FILE *f, format_string< T... > fmt, T &&... args)
	\rst Formats args according to specifications in fmt and writes the output to the file f. More...
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. More...
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. More...

Macro Definition Documentation

FMT_API

#define FMT_API

FMT_ASSERT

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

FMT_BEGIN_EXPORT

#define FMT_BEGIN_EXPORT

FMT_BEGIN_NAMESPACE

#define FMT_BEGIN_NAMESPACE

Value:

    namespace fmt {           \
    inline namespace v10 {

FMT_CLANG_VERSION

#define FMT_CLANG_VERSION   0

FMT_CONSTEVAL

#define FMT_CONSTEVAL

FMT_CONSTEXPR

#define FMT_CONSTEXPR

FMT_CONSTEXPR20

#define FMT_CONSTEXPR20

FMT_CONSTEXPR_CHAR_TRAITS

#define FMT_CONSTEXPR_CHAR_TRAITS

FMT_CPLUSPLUS

#define FMT_CPLUSPLUS   __cplusplus

FMT_ENABLE_IF

#define FMT_ENABLE_IF

(

...

)

fmt::enable_if_t<(__VA_ARGS__), int> = 0

FMT_END_EXPORT

#define FMT_END_EXPORT

FMT_END_NAMESPACE

#define FMT_END_NAMESPACE

Value:

    }                       \
    }

FMT_ENUM_UNDERLYING_TYPE

#define FMT_ENUM_UNDERLYING_TYPE

(

type

)

: type

FMT_EXCEPTIONS

#define FMT_EXCEPTIONS   1

FMT_EXPORT

#define FMT_EXPORT

FMT_GCC_PRAGMA

#define FMT_GCC_PRAGMA

(

arg

)

FMT_GCC_VERSION

#define FMT_GCC_VERSION   0

FMT_HAS_CPP14_ATTRIBUTE

#define FMT_HAS_CPP14_ATTRIBUTE

(

attribute

)

(FMT_CPLUSPLUS >= 201402L && FMT_HAS_CPP_ATTRIBUTE(attribute))

FMT_HAS_CPP17_ATTRIBUTE

#define FMT_HAS_CPP17_ATTRIBUTE

(

attribute

)

(FMT_CPLUSPLUS >= 201703L && FMT_HAS_CPP_ATTRIBUTE(attribute))

FMT_HAS_CPP_ATTRIBUTE

#define FMT_HAS_CPP_ATTRIBUTE

(

x

)

0

FMT_HAS_FEATURE

#define FMT_HAS_FEATURE

(

x

)

0

FMT_HAS_INCLUDE

#define FMT_HAS_INCLUDE

(

x

)

0

FMT_ICC_VERSION

#define FMT_ICC_VERSION   0

FMT_INLINE

#define FMT_INLINE   inline

FMT_MSC_VERSION

#define FMT_MSC_VERSION   0

FMT_MSC_WARNING

#define FMT_MSC_WARNING

(

...

)

FMT_NODISCARD

#define FMT_NODISCARD

FMT_NORETURN

#define FMT_NORETURN

FMT_TYPE_CONSTANT

#define FMT_TYPE_CONSTANT	(		Type,
			constant
	)

Value:

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

FMT_UNCHECKED_ITERATOR

#define FMT_UNCHECKED_ITERATOR

(

It

)

using unchecked_type = It

FMT_UNICODE

#define FMT_UNICODE   !FMT_MSC_VERSION

FMT_USE_CONSTEXPR

#define FMT_USE_CONSTEXPR   0

FMT_USE_INT128

#define FMT_USE_INT128   0

FMT_USE_NONTYPE_TEMPLATE_ARGS

#define FMT_USE_NONTYPE_TEMPLATE_ARGS   0

FMT_VERSION

#define FMT_VERSION   100100

Typedef Documentation

align_t

using align_t = align::type

bool_constant

template<bool B>

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

buffer_context

template<typename Char >

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

char_t

template<typename S >

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

String's character type.

conditional_t

template<bool B, typename T , typename F >

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

enable_if_t

template<bool B, typename T = void>

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

format_args

using format_args = basic_format_args<format_context>

An alias to basic_format_args<format_context>.

format_context

using format_context = buffer_context<char>

format_parse_context

using format_parse_context = basic_format_parse_context<char>

format_string

template<typename... Args>

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

has_formatter

template<typename T , typename Context >

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

is_formattable

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>

remove_const_t

template<typename T >

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

remove_cvref_t

template<typename T >

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

remove_reference_t

template<typename T >

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

sign_t

using sign_t = sign::type

string_view

using string_view = basic_string_view<char>

type_identity_t

template<typename T >

using type_identity_t = typename type_identity<T>::type

underlying_t

template<typename T >

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

Enumeration Type Documentation

presentation_type

enum class 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

Function Documentation

arg()

template<typename Char , typename T >

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

inline

\rst 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)); \endrst

format()

template<typename... T>

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

\rst 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); \endrst

format_to()

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

\rst 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); \endrst

format_to_n()

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>

\rst 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. \endrst

formatted_size()

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

make_format_args()

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

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

constexpr

\rst 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 ~fmtformat_context. See ~fmtarg for lifetime considerations. \endrst

print() [1/2]

template<typename... T>

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

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

Example**::

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

print() [2/2]

template<typename... T>

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

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

Example**::

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

println() [1/2]

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.

println() [2/2]

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.

runtime()

auto runtime ( string_view  s ) -> runtime_format_string<>

inline

\rst 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"); \endrst

vformat()

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

vformat_to()

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.

vformat_to_n()

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>

visit_format_arg()

template<typename Visitor , typename Context >

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

\rst 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. \endrst

vprint() [1/2]

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

vprint() [2/2]

FMT_API void vprint	(	string_view	fmt,
		format_args	args
	)