base.h File Reference

#include <limits.h>
#include <stdio.h>
#include <string.h>
#include <cstddef>
#include <type_traits>

Go to the source code of this file.

Classes
struct	type_identity< T >
struct	monostate
struct	detail::is_std_string_like< T, Enable >
struct	detail::is_std_string_like< T, void_t< decltype(std::declval< T >().find_first_of(typename T::value_type(), 0))> >
struct	detail::is_back_insert_iterator< It, Enable >
struct	detail::is_back_insert_iterator< It, bool_constant< std::is_same< decltype(back_inserter(std::declval< typename It::container_type & >())), It >::value > >
struct	is_contiguous< 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. Can be specialized by users. More...
struct	is_char< char >
struct	detail::has_to_string_view< T, Enable >
struct	detail::has_to_string_view< T, void_t< decltype(detail::to_string_view(std::declval< T >()))> >
struct	detail::string_literal< Char, C >
struct	detail::type_constant< T, Char >
class	basic_format_parse_context< Char >
	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 >
	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< OutputIt, enable_if_t< detail::is_back_insert_iterator< OutputIt >::value &&is_contiguous< typename OutputIt::container_type >::value, typename OutputIt::container_type::value_type > >
class	detail::counting_buffer< T >
struct	formatter< T, Char, Enable >
class	basic_appender< T >
struct	detail::locking< T, Enable >
struct	detail::locking< T, void_t< typename formatter< remove_cvref_t< T > >::nonlocking > >
struct	detail::view
struct	detail::named_arg< Char, T >
struct	detail::named_arg_info< Char >
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< appender, char >
struct	detail::is_output_iterator< It, T, void_t< decltype(*std::declval< It & >()++=std::declval< T >())> >
class	detail::locale_ref
struct	detail::format_arg_store< Context, NUM_ARGS, NUM_NAMED_ARGS, DESC >
struct	detail::format_arg_store< Context, NUM_ARGS, 0, DESC >
class	basic_format_arg< Context >
class	basic_format_arg< Context >::handle
class	basic_format_args< Context >
	A view of a collection of formatting arguments. More...
class	context
struct	detail::fill_t
struct	format_specs
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::compile_string
struct	detail::vformat_args< Char >
struct	detail::vformat_args< char >
struct	detail::native_formatter< T, Char, TYPE >
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 >
struct	format_to_result< OutputIt, Sentinel >

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

Macros
#define	FMT_VERSION   110001
#define	FMT_CLANG_VERSION   0
#define	FMT_GCC_VERSION   0
#define	FMT_ICC_VERSION   0
#define	FMT_MSC_VERSION   0
#define	FMT_GLIBCXX_RELEASE   0
#define	FMT_LIBCPP_VERSION   0
#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_USE_CONSTEVAL   0
#define	FMT_CONSTEVAL
#define	FMT_CONSTEXPR20
#define	FMT_USE_NONTYPE_TEMPLATE_ARGS   0
#define	FMT_USE_CONCEPTS   0
#define	FMT_EXCEPTIONS   1
#define	FMT_TRY   try
#define	FMT_CATCH(x)   catch (x)
#define	FMT_FALLTHROUGH
#define	FMT_NORETURN
#define	FMT_NODISCARD
#define	FMT_DEPRECATED   /* deprecated */
#define	FMT_ALWAYS_INLINE   inline
#define	FMT_INLINE   inline
#define	FMT_VISIBILITY(value)
#define	FMT_GCC_PRAGMA(arg)
#define	FMT_DECLTYPE_THIS
#define	FMT_MSC_WARNING(...)
#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   1
#define	FMT_USE_RTTI   0
#define	FMT_FWD(...)   static_cast<decltype(__VA_ARGS__)&&>(__VA_ARGS__)
#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_MAP_API   FMT_CONSTEXPR FMT_ALWAYS_INLINE
#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	make_unsigned_t = typename std::make_unsigned< T >::type
template<typename T >
using	underlying_t = typename std::underlying_type< T >::type
template<typename... >
using	void_t = void
using	string_view = basic_string_view< char >
template<typename S , typename V = decltype(detail::to_string_view(std::declval<S>()))>
using	char_t = typename V::value_type
	String's character (code unit) 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 > >
using	appender = basic_appender< char >
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 Context , size_t NUM_ARGS>
using	detail::arg_t = conditional_t< NUM_ARGS<=max_packed_args, value< Context >, basic_format_arg< Context > >
template<typename OutputIt , typename Char >
using	basic_format_context = conditional_t< std::is_same< OutputIt, appender >::value, context, generic_context< OutputIt, Char > >
using	format_context = context
template<typename Char >
using	buffered_context = basic_format_context< basic_appender< Char >, Char >
template<typename T , typename Char = char>
using	is_formattable = bool_constant<!std::is_base_of< detail::unformattable, decltype(detail::arg_mapper< buffered_context< Char > >() .map(std::declval< T & >()))>::value >
using	format_args = basic_format_args< format_context >
	An alias for basic_format_args<format_context>. More...
using	align_t = align::type
using	sign_t = sign::type
template<typename Char >
using	detail::unsigned_char = typename conditional_t< std::is_integral< Char >::value, std::make_unsigned< Char >, type_identity< unsigned > >::type
template<typename S >
using	detail::is_compile_string = std::is_base_of< compile_string, S >
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 = 0 , debug = 1 , string = 2 , dec = 3 ,   hex , oct , bin , chr ,   pointer = 3 , exp = 1 , fixed , general ,   hexfloat }
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 auto	detail::is_constant_evaluated (bool default_value=false) noexcept -> bool
template<typename T >
constexpr auto	detail::const_check (T value) -> T
FMT_FUNC 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) -> make_unsigned_t< Int >
constexpr auto	detail::is_utf8_enabled () -> bool
constexpr auto	detail::use_utf8 () -> bool
template<typename Char >
FMT_CONSTEXPR auto	detail::length (const Char *s) -> size_t
template<typename Char >
FMT_CONSTEXPR auto	detail::compare (const Char *s1, const Char *s2, std::size_t n) -> int
template<typename OutputIt >
auto	detail::get_container (OutputIt it) -> typename OutputIt::container_type &
template<typename Char , FMT_ENABLE_IF(is_char< Char >::value) >
auto	detail::to_string_view (const Char *s) -> basic_string_view< Char >
template<typename T , FMT_ENABLE_IF(is_std_string_like< T >::value) >
auto	detail::to_string_view (const T &s) -> basic_string_view< typename T::value_type >
template<typename Char >
constexpr auto	detail::to_string_view (basic_string_view< Char > s) -> basic_string_view< Char >
	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 auto	detail::is_integral_type (type t) -> bool
constexpr auto	detail::is_arithmetic_type (type t) -> bool
constexpr auto	detail::set (type rhs) -> int
constexpr auto	detail::in (type t, int set) -> bool
FMT_NORETURN FMT_API void	report_error (const char *message)
	Reports a format error at compile time or, via a format_error exception, at runtime. More...
FMT_DEPRECATED FMT_NORETURN void	throw_format_error (const char *message)
template<typename T = int>
FMT_CONSTEXPR auto	detail::is_locking () -> bool
template<typename T1 , typename T2 , typename... Tail>
FMT_CONSTEXPR auto	detail::is_locking () -> bool
template<typename T , typename InputIt >
auto	detail::copy (InputIt begin, InputIt end, appender out) -> appender
template<typename T , typename InputIt , typename OutputIt , FMT_ENABLE_IF(is_back_insert_iterator< OutputIt >::value) >
auto	detail::copy (InputIt begin, InputIt end, OutputIt out) -> OutputIt
template<typename T , typename InputIt , typename OutputIt , FMT_ENABLE_IF(!is_back_insert_iterator< OutputIt >::value) >
FMT_CONSTEXPR auto	detail::copy (InputIt begin, InputIt end, OutputIt out) -> OutputIt
template<typename T >
FMT_CONSTEXPR auto	detail::copy (const T *begin, const T *end, T *out) -> T *
template<typename T , typename V , typename OutputIt >
FMT_CONSTEXPR auto	detail::copy (basic_string_view< V > s, OutputIt out) -> OutputIt
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 >
auto	detail::get_buffer (basic_appender< T > out) -> buffer< T > &
template<typename Buf , typename OutputIt >
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<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 >
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, size_t NUM_ARGS = sizeof...(T)>
constexpr unsigned long long	detail::make_descriptor ()
template<bool PACKED, typename Context , typename T , FMT_ENABLE_IF(PACKED) >
FMT_CONSTEXPR 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<typename Char , typename T , FMT_ENABLE_IF(!is_named_arg< T >::value) >
void	detail::init_named_arg (named_arg_info< Char > *, int &arg_index, int &, const T &)
template<typename Visitor , typename Context >
FMT_DEPRECATED FMT_CONSTEXPR auto	visit_format_arg (Visitor &&vis, const basic_format_arg< Context > &arg) -> decltype(vis(0))
template<typename Context = format_context, typename... T, size_t NUM_ARGS = sizeof...(T), size_t NUM_NAMED_ARGS = detail::count_named_args<T...>(), unsigned long long DESC = detail::make_descriptor<Context, T...>(), FMT_ENABLE_IF(NUM_NAMED_ARGS==0) >
constexpr FMT_ALWAYS_INLINE auto	make_format_args (T &... args) -> detail::format_arg_store< Context, NUM_ARGS, 0, DESC >
	Constructs an object that stores references to arguments and can be implicitly converted to format_args. More...
template<typename Context = format_context, typename... T, size_t NUM_NAMED_ARGS = detail::count_named_args<T...>(), unsigned long long DESC = detail::make_descriptor<Context, T...>() | static_cast<unsigned long long>(detail::has_named_args_bit), FMT_ENABLE_IF(NUM_NAMED_ARGS !=0) >
constexpr auto	make_format_args (T &... args) -> detail::format_arg_store< Context, sizeof...(T), NUM_NAMED_ARGS, DESC >
template<typename Char , typename T >
auto	arg (const Char *name, const T &arg) -> detail::named_arg< Char, T >
	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 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 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 void	detail::parse_format_string (basic_string_view< Char > format_str, Handler &&handler)
template<typename T , typename ParseContext >
	detail::FMT_VISIBILITY ("hidden") FMT_CONSTEXPR auto parse_format_specs(ParseContext &ctx) -> decltype(ctx.begin())
FMT_CONSTEXPR auto	detail::check_char_specs (const format_specs &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_ALWAYS_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)
void	detail::report_truncation (bool truncated)
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 (FILE *, string_view, format_args, bool=false)
auto	runtime (string_view s) -> runtime_format_string<>
	Creates a runtime format string. More...
template<typename OutputIt , FMT_ENABLE_IF(detail::is_output_iterator< remove_cvref_t< OutputIt >, char >::value) >
auto	vformat_to (OutputIt &&out, string_view fmt, format_args args) -> remove_cvref_t< OutputIt >
	Formats a string and writes the output to out. More...
template<typename OutputIt , typename... T, FMT_ENABLE_IF(detail::is_output_iterator< remove_cvref_t< OutputIt >, char >::value) >
FMT_INLINE auto	format_to (OutputIt &&out, format_string< T... > fmt, T &&... args) -> remove_cvref_t< 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. 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 >
	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<size_t N>
auto	vformat_to (char(&out)[N], string_view fmt, format_args args) -> format_to_result< char * >
template<size_t N, typename... T>
FMT_INLINE auto	format_to (char(&out)[N], format_string< T... > fmt, T &&... args) -> format_to_result< char * >
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 (FILE *f, string_view fmt, format_args args)
FMT_API void	vprint_buffered (FILE *f, string_view fmt, format_args args)
FMT_API void	vprintln (FILE *f, string_view fmt, format_args args)
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. More...
template<typename... T>
FMT_INLINE void	print (FILE *f, format_string< T... > fmt, T &&... args)
	Formats args according to specifications in fmt and writes the output to the file f. More...
template<typename... T>
FMT_INLINE void	println (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_ALWAYS_INLINE

#define FMT_ALWAYS_INLINE   inline

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 v11 {

FMT_CATCH

#define FMT_CATCH

(

x

)

catch (x)

FMT_CLANG_VERSION

#define FMT_CLANG_VERSION   0

FMT_CONSTEVAL

#define FMT_CONSTEVAL

FMT_CONSTEXPR

#define FMT_CONSTEXPR

FMT_CONSTEXPR20

#define FMT_CONSTEXPR20

FMT_CPLUSPLUS

#define FMT_CPLUSPLUS   __cplusplus

FMT_DECLTYPE_THIS

#define FMT_DECLTYPE_THIS

FMT_DEPRECATED

#define FMT_DEPRECATED   /* deprecated */

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_FALLTHROUGH

#define FMT_FALLTHROUGH

FMT_FWD

#define FMT_FWD

(

...

)

static_cast<decltype(__VA_ARGS__)&&>(__VA_ARGS__)

FMT_GCC_PRAGMA

#define FMT_GCC_PRAGMA

(

arg

)

FMT_GCC_VERSION

#define FMT_GCC_VERSION   0

FMT_GLIBCXX_RELEASE

#define FMT_GLIBCXX_RELEASE   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_LIBCPP_VERSION

#define FMT_LIBCPP_VERSION   0

FMT_MAP_API

#define FMT_MAP_API   FMT_CONSTEXPR FMT_ALWAYS_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_TRY

#define FMT_TRY   try

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   1

FMT_USE_CONCEPTS

#define FMT_USE_CONCEPTS   0

FMT_USE_CONSTEVAL

#define FMT_USE_CONSTEVAL   0

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_USE_RTTI

#define FMT_USE_RTTI   0

FMT_VERSION

#define FMT_VERSION   110001

FMT_VISIBILITY

#define FMT_VISIBILITY

(

value

)

Typedef Documentation

align_t

using align_t = align::type

appender

using appender = basic_appender<char>

basic_format_context

template<typename OutputIt , typename Char >

using basic_format_context = conditional_t<std::is_same<OutputIt, appender>::value, context, generic_context<OutputIt, Char> >

bool_constant

template<bool B>

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

buffered_context

template<typename Char >

using buffered_context = basic_format_context<basic_appender<Char>, Char>

char_t

template<typename S , typename V = decltype(detail::to_string_view(std::declval<S>()))>

using char_t = typename V::value_type

String's character (code unit) 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 for basic_format_args<format_context>.

format_context

using format_context = context

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<buffered_context<Char> >() .map(std::declval<T&>()))>::value>

make_unsigned_t

template<typename T >

using make_unsigned_t = typename std::make_unsigned<T>::type

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

void_t

template<typename... >

using void_t = void

Enumeration Type Documentation

presentation_type

enum class presentation_type : unsigned char

strong

Enumerator
none
debug
string
dec
hex
oct
bin
chr
pointer
exp
fixed
general
hexfloat

Function Documentation

arg()

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("The answer is {answer}.", fmt::arg("answer", 42));

format_to() [1/2]

template<size_t N, typename... T>

FMT_INLINE auto format_to	(	char(&)	out[N],
		format_string< T... >	fmt,
		T &&...	args
	)		-> format_to_result<char*>

format_to() [2/2]

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

FMT_INLINE auto format_to	(	OutputIt &&	out,
		format_string< T... >	fmt,
		T &&...	args
	)		-> remove_cvref_t<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);

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>

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.

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() [1/2]

template<typename Context = format_context, typename... T, size_t NUM_ARGS = sizeof...(T), size_t NUM_NAMED_ARGS = detail::count_named_args<T...>(), unsigned long long DESC = detail::make_descriptor<Context, T...>(), FMT_ENABLE_IF(NUM_NAMED_ARGS==0) >

constexpr FMT_ALWAYS_INLINE auto make_format_args ( T &...  args ) -> detail::format_arg_store<Context, NUM_ARGS, 0, DESC>

constexpr

Constructs an object that stores references to arguments and can be implicitly converted to format_args.

Context can be omitted in which case it defaults to format_context. See arg for lifetime considerations.

make_format_args() [2/2]

template<typename Context = format_context, typename... T, size_t NUM_NAMED_ARGS = detail::count_named_args<T...>(), unsigned long long DESC = detail::make_descriptor<Context, T...>() | static_cast<unsigned long long>(detail::has_named_args_bit), FMT_ENABLE_IF(NUM_NAMED_ARGS !=0) >

constexpr auto make_format_args ( T &...  args ) -> detail::format_arg_store<Context, sizeof...(T), NUM_NAMED_ARGS, DESC>

constexpr

print() [1/2]

template<typename... T>

FMT_INLINE void print	(	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");

print() [2/2]

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("The answer is {}.", 42);

println() [1/2]

template<typename... T>

FMT_INLINE void println	(	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.

println() [2/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.

report_error()

FMT_NORETURN FMT_API void report_error

(

const char *

message

)

Reports a format error at compile time or, via a format_error exception, at runtime.

runtime()

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

throw_format_error()

FMT_DEPRECATED FMT_NORETURN void throw_format_error ( const char *  message )

inline

vformat_to() [1/2]

template<size_t N>

auto vformat_to	(	char(&)	out[N],
		string_view	fmt,
		format_args	args
	)		-> format_to_result<char*>

vformat_to() [2/2]

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

auto vformat_to	(	OutputIt &&	out,
		string_view	fmt,
		format_args	args
	)		-> remove_cvref_t<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_DEPRECATED FMT_CONSTEXPR auto visit_format_arg	(	Visitor &&	vis,
		const basic_format_arg< Context > &	arg
	)		-> decltype(vis(0))

vprint() [1/2]

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

vprint() [2/2]

FMT_API void vprint	(	string_view	fmt,
		format_args	args
	)

vprint_buffered()

FMT_API void vprint_buffered	(	FILE *	f,
		string_view	fmt,
		format_args	args
	)

vprintln()

FMT_API void vprintln	(	FILE *	f,
		string_view	fmt,
		format_args	args
	)