core.h File Reference

#include <cstdio>
#include <cstring>
#include <functional>
#include <iterator>
#include <memory>
#include <string>
#include <type_traits>
#include <vector>

Classes
struct	type_identity< T >
struct	monostate
struct	detail::std_string_view< T >
struct	detail::int128_t
struct	detail::uint128_t
class	basic_string_view< Char >
struct	is_char< T >
struct	is_char< char >
struct	is_char< wchar_t >
struct	is_char< detail::char8_type >
struct	is_char< char16_t >
struct	is_char< char32_t >
struct	compile_string
struct	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::error_handler
class	basic_format_parse_context< Char, ErrorHandler >
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 >
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 >
class	detail::buffer_appender< T >
struct	detail::fallback_formatter< T, Char, Enable >
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_named_arg< named_arg< Char, T > >
struct	detail::type_constant< T, Char >
struct	detail::string_value< Char >
struct	detail::named_arg_value< Char >
struct	detail::custom_value< Context >
class	detail::value< Context >
struct	detail::unformattable
struct	detail::arg_mapper< Context >
class	basic_format_arg< Context >
class	basic_format_arg< Context >::handle
struct	formattable< T >
struct	detail::void_t_impl< Ts >
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< OutputIt >
struct	detail::is_back_insert_iterator< std::back_insert_iterator< Container > >
struct	detail::is_contiguous_back_insert_iterator< OutputIt >
struct	detail::is_contiguous_back_insert_iterator< std::back_insert_iterator< Container > >
struct	detail::is_contiguous_back_insert_iterator< buffer_appender< Char > >
class	detail::locale_ref
struct	detail::is_reference_wrapper< T >
struct	detail::is_reference_wrapper< std::reference_wrapper< T > >
class	detail::dynamic_arg_list
struct	detail::dynamic_arg_list::node< typename >
struct	detail::dynamic_arg_list::typed_node< T >
class	basic_format_context< OutputIt, Char >
class	format_arg_store< Context, Args >
class	dynamic_format_arg_store< Context >
struct	dynamic_format_arg_store< Context >::need_copy< T >
class	basic_format_args< Context >
struct	format_args
struct	wformat_args
struct	format_to_n_result< OutputIt >

Namespaces
	detail

Macros
#define	FMT_VERSION   70103
#define	FMT_CLANG_VERSION   0
#define	FMT_GCC_VERSION   0
#define	FMT_ICC_VERSION   0
#define	FMT_HAS_GXX_CXX11   0
#define	FMT_NVCC   0
#define	FMT_MSC_VER   0
#define	FMT_SUPPRESS_MSC_WARNING(n)
#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)    (__cplusplus >= 201402L && FMT_HAS_CPP_ATTRIBUTE(attribute))
#define	FMT_HAS_CPP17_ATTRIBUTE(attribute)    (__cplusplus >= 201703L && FMT_HAS_CPP_ATTRIBUTE(attribute))
#define	FMT_USE_CONSTEXPR
#define	FMT_CONSTEXPR   inline
#define	FMT_CONSTEXPR_DECL
#define	FMT_OVERRIDE
#define	FMT_EXCEPTIONS   1
#define	FMT_USE_NOEXCEPT   0
#define	FMT_DETECTED_NOEXCEPT   throw()
#define	FMT_HAS_CXX11_NOEXCEPT   0
#define	FMT_NOEXCEPT   FMT_DETECTED_NOEXCEPT
#define	FMT_NORETURN
#define	FMT_DEPRECATED   /* deprecated */
using	FMT_DEPRECATED_ALIAS   FMT_DEPRECATED
#define	FMT_INLINE   inline
#define	FMT_USE_INLINE_NAMESPACES   0
#define	FMT_INLINE_NAMESPACE   namespace
#define	FMT_END_NAMESPACE
#define	FMT_BEGIN_NAMESPACE
#define	FMT_CLASS_API
#define	FMT_API
#define	FMT_EXTERN_TEMPLATE_API
#define	FMT_INSTANTIATION_DEF_API   FMT_API
#define	FMT_EXTERN   extern
#define	FMT_UNICODE   !FMT_MSC_VER
#define	FMT_ENABLE_IF(...)   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_BUFFER_CONTEXT(Char)    basic_format_context<detail::buffer_appender<Char>, Char>

Typedefs
template<bool B, class T = void>
using	enable_if_t = typename std::enable_if< B, T >::type
template<bool B, class T , class 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
using	string_view = basic_string_view< char >
using	wstring_view = basic_string_view< wchar_t >
template<typename S >
using	char_t = typename detail::char_t_impl< S >::type
using	format_parse_context = basic_format_parse_context< char >
using	wformat_parse_context = basic_format_parse_context< wchar_t >
template<typename T , typename Context >
using	has_formatter = std::is_constructible< typename Context::template formatter_type< T > >
template<typename T , typename Context >
using	detail::has_fallback_formatter = std::is_constructible< fallback_formatter< T, typename Context::char_type > >
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 , typename Context >
using	detail::mapped_type_constant = type_constant< decltype(arg_mapper< Context >().map(std::declval< const T & >())), typename Context::char_type >
template<typename... Ts>
using	detail::void_t = typename detail::void_t_impl< Ts... >::type
template<typename Char >
using	buffer_context = basic_format_context< detail::buffer_appender< Char >, Char >
using	format_context = buffer_context< char >
using	wformat_context = buffer_context< wchar_t >

Enumerations
enum	detail::char8_type : unsigned char
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::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 }

Functions
template<typename T >
constexpr T	detail::const_check (T value)
FMT_NORETURN FMT_API void	detail::assert_fail (const char *file, int line, const char *message)
template<typename Int >
FMT_CONSTEXPR std::make_unsigned< Int >::type	detail::to_unsigned (Int value)
	detail::FMT_SUPPRESS_MSC_WARNING (4566) const expr unsigned char micro[]
template<typename Char >
constexpr bool	detail::is_unicode ()
template<typename Char , FMT_ENABLE_IF(is_char< Char >::value) >
basic_string_view< Char >	to_string_view (const Char *s)
template<typename Char , typename Traits , typename Alloc >
basic_string_view< Char >	to_string_view (const std::basic_string< Char, Traits, Alloc > &s)
template<typename Char >
basic_string_view< Char >	to_string_view (basic_string_view< Char > s)
template<typename Char , FMT_ENABLE_IF(!std::is_empty< detail::std_string_view< Char >>::value) >
basic_string_view< Char >	to_string_view (detail::std_string_view< Char > s)
template<typename S , FMT_ENABLE_IF(is_compile_string< S >::value) >
constexpr basic_string_view< typename S::char_type >	to_string_view (const S &s)
void	detail::to_string_view (...)
template<typename... , typename S , FMT_ENABLE_IF(!is_compile_string< S >::value) >
FMT_INLINE void	detail::check_format_string (const S &)
template<typename... , typename S , FMT_ENABLE_IF(is_compile_string< S >::value) >
void	detail::check_format_string (S)
template<typename Container >
Container &	detail::get_container (std::back_insert_iterator< Container > it)
template<typename T , typename OutputIt >
iterator_buffer< OutputIt, T >	detail::get_buffer (OutputIt)
template<typename T >
buffer< T > &	detail::get_buffer (buffer_appender< T >)
template<typename OutputIt >
OutputIt	detail::get_buffer_init (OutputIt out)
template<typename T >
buffer< T > &	detail::get_buffer_init (buffer_appender< T > out)
template<typename Buffer >
auto	detail::get_iterator (Buffer &buf) -> decltype(buf.out())
template<typename T >
buffer_appender< T >	detail::get_iterator (buffer< T > &buf)
template<typename Char >
void	detail::init_named_args (named_arg_info< Char > *, int, int)
template<typename Char , typename T , typename... Tail>
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 Char , typename T , typename... Tail>
void	detail::init_named_args (named_arg_info< Char > *named_args, int arg_count, int named_arg_count, const named_arg< Char, T > &arg, const Tail &... args)
template<typename... Args>
FMT_INLINE void	detail::init_named_args (std::nullptr_t, int, int, const Args &...)
template<bool B = false>
constexpr size_t	detail::count ()
template<bool B1, bool B2, bool... Tail>
constexpr size_t	detail::count ()
template<typename... Args>
constexpr size_t	detail::count_named_args ()
	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_t, int128_type)
	detail::FMT_TYPE_CONSTANT (uint128_t, 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)
template<typename Context , typename T >
FMT_CONSTEXPR basic_format_arg< Context >	detail::make_arg (const T &value)
template<typename Visitor , typename Context >
FMT_CONSTEXPR_DECL FMT_INLINE auto	visit_format_arg (Visitor &&vis, const basic_format_arg< Context > &arg) -> decltype(vis(0))
template<typename >
constexpr unsigned long long	detail::encode_types ()
template<typename Context , typename Arg , typename... Args>
constexpr unsigned long long	detail::encode_types ()
template<typename T >
int	detail::check (unformattable)
template<typename T , typename U >
const U &	detail::check (const U &val)
template<bool IS_PACKED, typename Context , type , typename T , FMT_ENABLE_IF(IS_PACKED) >
value< Context >	detail::make_arg (const T &val)
template<bool IS_PACKED, typename Context , type , typename T , FMT_ENABLE_IF(!IS_PACKED) >
basic_format_arg< Context >	detail::make_arg (const T &value)
template<typename T >
const T &	detail::unwrap (const T &v)
template<typename T >
const T &	detail::unwrap (const std::reference_wrapper< T > &v)
template<typename Context = format_context, typename... Args>
format_arg_store< Context, Args... >	make_format_args (const Args &... args)
template<typename... Args, typename S , typename Char = char_t<S>>
auto	make_args_checked (const S &format_str, const remove_reference_t< Args > &... args) -> format_arg_store< buffer_context< Char >, remove_reference_t< Args >... >
template<typename Char , typename T >
detail::named_arg< Char, T >	arg (const Char *name, const T &arg)
template<typename Char , FMT_ENABLE_IF(!std::is_same< Char, char >::value) >
std::basic_string< Char >	detail::vformat (basic_string_view< Char > format_str, basic_format_args< buffer_context< type_identity_t< Char >>> args)
FMT_API std::string	detail::vformat (string_view format_str, format_args args)
template<typename Char >
void	detail::vformat_to (buffer< Char > &buf, basic_string_view< Char > format_str, basic_format_args< FMT_BUFFER_CONTEXT(type_identity_t< Char >)> args, detail::locale_ref loc={})
template<typename Char , typename Args , FMT_ENABLE_IF(!std::is_same< Char, char >::value) >
void	detail::vprint_mojibake (std::FILE *, basic_string_view< Char >, const Args &)
FMT_API void	detail::vprint_mojibake (std::FILE *, string_view, format_args)
template<typename OutputIt , typename S , typename Char = char_t<S>, bool enable = detail::is_output_iterator<OutputIt, Char>::value>
auto	vformat_to (OutputIt out, const S &format_str, basic_format_args< buffer_context< type_identity_t< Char >>> args) -> typename std::enable_if< enable, OutputIt >::type
template<typename OutputIt , typename S , typename... Args, bool enable = detail::is_output_iterator<OutputIt, char_t<S>>::value>
auto	format_to (OutputIt out, const S &format_str, Args &&... args) -> typename std::enable_if< enable, OutputIt >::type
template<typename OutputIt , typename Char , typename... Args, FMT_ENABLE_IF(detail::is_output_iterator< OutputIt, Char >::value) >
format_to_n_result< OutputIt >	vformat_to_n (OutputIt out, size_t n, basic_string_view< Char > format_str, basic_format_args< buffer_context< type_identity_t< Char >>> args)
template<typename OutputIt , typename S , typename... Args, bool enable = detail::is_output_iterator<OutputIt, char_t<S>>::value>
auto	format_to_n (OutputIt out, size_t n, const S &format_str, const Args &... args) -> typename std::enable_if< enable, format_to_n_result< OutputIt >>::type
template<typename... Args>
size_t	formatted_size (string_view format_str, Args &&... args)
template<typename S , typename Char = char_t<S>>
FMT_INLINE std::basic_string< Char >	vformat (const S &format_str, basic_format_args< buffer_context< type_identity_t< Char >>> args)
template<typename S , typename... Args, typename Char = char_t<S>>
FMT_INLINE std::basic_string< Char >	format (const S &format_str, Args &&... args)
FMT_API void	vprint (string_view, format_args)
FMT_API void	vprint (std::FILE *, string_view, format_args)
template<typename S , typename... Args, typename Char = char_t<S>>
void	print (std::FILE *f, const S &format_str, Args &&... args)
template<typename S , typename... Args, typename Char = char_t<S>>
void	print (const S &format_str, Args &&... args)

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_NAMESPACE

#define FMT_BEGIN_NAMESPACE

Value:

    namespace fmt {           \
    FMT_INLINE_NAMESPACE v7 {

FMT_BUFFER_CONTEXT

#define FMT_BUFFER_CONTEXT

(

Char

)

basic_format_context<detail::buffer_appender<Char>, Char>

FMT_CLANG_VERSION

#define FMT_CLANG_VERSION   0

FMT_CLASS_API

#define FMT_CLASS_API

FMT_CONSTEXPR

#define FMT_CONSTEXPR   inline

FMT_CONSTEXPR_DECL

#define FMT_CONSTEXPR_DECL

FMT_DEPRECATED

#define FMT_DEPRECATED   /* deprecated */

FMT_DEPRECATED_ALIAS

typedef basic_format_args< buffer_context< Char > > FMT_DEPRECATED_ALIAS   FMT_DEPRECATED

FMT_DETECTED_NOEXCEPT

#define FMT_DETECTED_NOEXCEPT   throw()

FMT_ENABLE_IF

#define FMT_ENABLE_IF

(

...

)

enable_if_t<(__VA_ARGS__), int> = 0

FMT_END_NAMESPACE

#define FMT_END_NAMESPACE

Value:

      }                       \
      using namespace v7;     \
      }

FMT_EXCEPTIONS

#define FMT_EXCEPTIONS   1

FMT_EXTERN

#define FMT_EXTERN   extern

FMT_EXTERN_TEMPLATE_API

#define FMT_EXTERN_TEMPLATE_API

FMT_GCC_VERSION

#define FMT_GCC_VERSION   0

FMT_HAS_CPP14_ATTRIBUTE

#define FMT_HAS_CPP14_ATTRIBUTE

(

attribute

)

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

FMT_HAS_CPP17_ATTRIBUTE

#define FMT_HAS_CPP17_ATTRIBUTE

(

attribute

)

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

FMT_HAS_CPP_ATTRIBUTE

#define FMT_HAS_CPP_ATTRIBUTE

(

x

)

0

FMT_HAS_CXX11_NOEXCEPT

#define FMT_HAS_CXX11_NOEXCEPT   0

FMT_HAS_FEATURE

#define FMT_HAS_FEATURE

(

x

)

0

FMT_HAS_GXX_CXX11

#define FMT_HAS_GXX_CXX11   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_INLINE_NAMESPACE

#define FMT_INLINE_NAMESPACE   namespace

FMT_INSTANTIATION_DEF_API

#define FMT_INSTANTIATION_DEF_API   FMT_API

FMT_MSC_VER

#define FMT_MSC_VER   0

FMT_NOEXCEPT

#define FMT_NOEXCEPT   FMT_DETECTED_NOEXCEPT

FMT_NORETURN

#define FMT_NORETURN

FMT_NVCC

#define FMT_NVCC   0

FMT_OVERRIDE

#define FMT_OVERRIDE

FMT_SUPPRESS_MSC_WARNING

#define FMT_SUPPRESS_MSC_WARNING

(

n

)

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_UNICODE

#define FMT_UNICODE   !FMT_MSC_VER

FMT_USE_CONSTEXPR

#define FMT_USE_CONSTEXPR

Value:

    (FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VER >= 1910 || \
     (FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L)) &&           \
        !FMT_NVCC && !FMT_ICC_VERSION

FMT_USE_INLINE_NAMESPACES

#define FMT_USE_INLINE_NAMESPACES   0

FMT_USE_INT128

#define FMT_USE_INT128   0

FMT_USE_NOEXCEPT

#define FMT_USE_NOEXCEPT   0

FMT_VERSION

#define FMT_VERSION   70103

Typedef Documentation

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, class T , class F >

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

enable_if_t

template<bool B, class T = void>

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

format_context

using format_context = buffer_context<char>

format_parse_context

using format_parse_context = basic_format_parse_context<char>

has_formatter

template<typename T , typename Context >

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

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

string_view

using string_view = basic_string_view<char>

type_identity_t

template<typename T >

using type_identity_t = typename type_identity<T>::type

wformat_context

using wformat_context = buffer_context<wchar_t>

wformat_parse_context

using wformat_parse_context = basic_format_parse_context<wchar_t>

wstring_view

using wstring_view = basic_string_view<wchar_t>

Function Documentation

arg()

template<typename Char , typename T >

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

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.

Example**::

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

References name.

Referenced by bind_std_array(), bind_std_forward_list(), bind_std_functional_hash(), bind_std_stl_deque(), bind_std_stl_function(), bind_std_stl_list(), bind_std_stl_multiset(), bind_std_stl_vector(), bind_std_stl_vector_1(), bind_std_unordered_map(), bind_std_unordered_set(), bind_T00_basic(), bind_T02_function(), bind_T05_default(), bind_T07_class(), bind_T08_constructor(), bind_T09_overload(), bind_T10_inheritance(), bind_T10_virtual_inheritance(), bind_T11_override(), bind_T12_operator(), bind_T15_inner_class(), bind_T15_inner_class_1(), bind_T15_inner_class_2(), bind_T15_inner_class_3(), bind_T15_inner_class_fwd(), bind_T20_template(), bind_T20_template_variadic(), bind_T30_include(), bind_T32_call_guard(), bind_T40_stl(), bind_T42_stl_names(), bind_T42_stl_names_map(), bind_T42_stl_names_multi(), bind_T42_stl_names_multimap(), bind_T42_stl_names_multiset(), bind_T42_stl_names_set(), bind_T43_stl_pybind11_include_stl(), bind_T60_pybind11(), bind_T70_options(), bind_T80_custom_trampoline(), bind_T81_custom_trampoline_with_args(), detail::convert_arg(), utility::factory::Factory< P >::create(), dynamic_format_arg_store< Context >::emplace_arg(), basic_printf_context< OutputIt, Char >::format(), formatter< tuple_arg_join< Char, T... >, Char >::format_args(), detail::value< Context >::format_custom_arg(), ui::network::FunctionSetupDialog::FunctionSetupDialog(), basic_format_args< Context >::get(), detail::get_arg(), detail::get_dynamic_spec(), detail::init_named_args(), utility::options::OptionCollection::load(), main(), detail::make_arg(), ui::network::Bowman::on_bowman_thread_specification_received(), ui::task::JobSubmit::on_delete_job_clicked(), detail::format_handler< OutputIt, Char, Context >::on_format_specs(), ui::widgets::PoseEditor::on_functions_double_clicked(), detail::format_handler< OutputIt, Char, Context >::on_replacement_field(), operator>>(), ui::task::operator>>(), detail::dynamic_arg_list::push(), dynamic_format_arg_store< Context >::push_back(), repack(), run(), ui::task::TaskCancelDialog::run(), binder::template_specialization(), FunctorTest::test_functor_async_sequence(), FunctorTest::test_functor_sequence(), FunctorTest::test_task_upload(), ui::viewers::ScoreFileView::update_ui_from_file_data(), detail::vformat(), detail::cf::vformat_to(), and visit_format_arg().

format()

template<typename S , typename... Args, typename Char = char_t<S>>

FMT_INLINE std::basic_string<Char> format	(	const S &	format_str,
		Args &&...	args
	)

\rst Formats arguments and returns the result as a string.

Example**::

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

References find_lowest_scoring_relaxed_struct::args, make_args_checked(), to_string_view(), and detail::vformat().

format_to()

template<typename OutputIt , typename S , typename... Args, bool enable = detail::is_output_iterator<OutputIt, char_t<S>>::value>

auto format_to ( OutputIt  out, const S &  format_str, Args &&...  args  ) -> typename std::enable_if<enable, OutputIt>::type

inline

\rst Formats arguments, writes the result to the output iterator out and returns the iterator past the end of the output range.

Example**::

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

References find_lowest_scoring_relaxed_struct::args, make_args_checked(), to_string_view(), and vformat_to().

format_to_n()

template<typename OutputIt , typename S , typename... Args, bool enable = detail::is_output_iterator<OutputIt, char_t<S>>::value>

auto format_to_n ( OutputIt  out, size_t  n, const S &  format_str, const Args &...  args  ) -> typename std::enable_if<enable, format_to_n_result<OutputIt>>::type

inline

\rst Formats arguments, writes up to n characters of the result to the output iterator out and returns the total output size and the iterator past the end of the output range. \endrst

References find_lowest_scoring_relaxed_struct::args, make_args_checked(), kmeans_adaptive_kernel_density_bb_dependent_rotlib::n, to_string_view(), and vformat_to_n().

formatted_size()

template<typename... Args>

size_t formatted_size ( string_view  format_str, Args &&...  args  )

inline

Returns the number of characters in the output of format(format_str, args...).

References find_lowest_scoring_relaxed_struct::args, cal_vdw_radius_pool::buf, make_args_checked(), and detail::vformat_to().

make_args_checked()

template<typename... Args, typename S , typename Char = char_t<S>>

auto make_args_checked ( const S &  format_str, const remove_reference_t< Args > &...  args  ) -> format_arg_store<buffer_context<Char>, remove_reference_t<Args>...>

inline

\rst Constructs a ~fmtformat_arg_store object that contains references to arguments and can be implicitly converted to ~fmtformat_args. If format_str is a compile-time string then make_args_checked checks its validity at compile time. \endrst

References find_lowest_scoring_relaxed_struct::args, detail::check_format_string(), detail::count(), and value.

Referenced by format(), format_to(), format_to_n(), formatted_size(), and print().

make_format_args()

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

format_arg_store<Context, Args...> make_format_args ( const Args &...  args )

inline

\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 ~fmt::context. See ~fmtarg for lifetime considerations. \endrst

References find_lowest_scoring_relaxed_struct::args.

Referenced by buffered_file::print(), and system_error::system_error().

print() [1/2]

template<typename S , typename... Args, typename Char = char_t<S>>

void print ( const S &  format_str, Args &&...  args  )

inline

\rst Formats args according to specifications in format_str and writes the output to stdout. Strings are assumed to be Unicode-encoded unless the FMT_UNICODE macro is set to 0.

Example**::

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

References find_lowest_scoring_relaxed_struct::args, make_args_checked(), build::stdout, to_string_view(), vprint(), and detail::vprint_mojibake().

print() [2/2]

template<typename S , typename... Args, typename Char = char_t<S>>

void print ( std::FILE *  f, const S &  format_str, Args &&...  args  )

inline

\rst Formats args according to specifications in format_str and writes the output to the file f. Strings are assumed to be Unicode-encoded unless the FMT_UNICODE macro is set to 0.

Example**::

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

References find_lowest_scoring_relaxed_struct::args, create_a3b_hbs::f, make_args_checked(), to_string_view(), vprint(), and detail::vprint_mojibake().

to_string_view() [1/5]

template<typename Char >

basic_string_view<Char> to_string_view ( basic_string_view< Char >  s )

inline

References docking::s.

to_string_view() [2/5]

template<typename Char , FMT_ENABLE_IF(is_char< Char >::value) >

basic_string_view<Char> to_string_view ( const Char *  s )

inline

\rst Returns a string view of s. In order to add custom string type support to {fmt} provide an overload of to_string_view for it in the same namespace as the type for the argument-dependent lookup to work.

Example**::

namespace my_ns { inline string_view to_string_view(const my_string& s) { return {s.data(), s.length()}; } } std::string message = fmt::format(my_string("The answer is {}"), 42); \endrst

References docking::s.

Referenced by detail::check_format_string(), format(), format_to(), format_to_n(), fprintf(), print(), printf(), sprintf(), vformat(), vformat_to(), vfprintf(), vprint(), vprintf(), and vsprintf().

to_string_view() [3/5]

template<typename S , FMT_ENABLE_IF(is_compile_string< S >::value) >

constexpr basic_string_view<typename S::char_type> to_string_view ( const S &  s )

constexpr

References docking::s.

to_string_view() [4/5]

template<typename Char , typename Traits , typename Alloc >

basic_string_view<Char> to_string_view ( const std::basic_string< Char, Traits, Alloc > &  s )

inline

References docking::s.

to_string_view() [5/5]

template<typename Char , FMT_ENABLE_IF(!std::is_empty< detail::std_string_view< Char >>::value) >

basic_string_view<Char> to_string_view ( detail::std_string_view< Char >  s )

inline

References docking::s.

vformat()

template<typename S , typename Char = char_t<S>>

FMT_INLINE std::basic_string<Char> vformat	(	const S &	format_str,
		basic_format_args< buffer_context< type_identity_t< Char >>>	args
	)

References find_lowest_scoring_relaxed_struct::args, to_string_view(), and detail::vformat().

vformat_to()

template<typename OutputIt , typename S , typename Char = char_t<S>, bool enable = detail::is_output_iterator<OutputIt, Char>::value>

auto vformat_to	(	OutputIt	out,
		const S &	format_str,
		basic_format_args< buffer_context< type_identity_t< Char >>>	args
	)		-> typename std::enable_if<enable, OutputIt>::type

Formats a string and writes the output to out.

References find_lowest_scoring_relaxed_struct::args, cal_vdw_radius_pool::buf, detail::get_buffer_init(), detail::get_iterator(), to_string_view(), and detail::vformat_to().

Referenced by format_to().

vformat_to_n()

template<typename OutputIt , typename Char , typename... Args, FMT_ENABLE_IF(detail::is_output_iterator< OutputIt, Char >::value) >

format_to_n_result<OutputIt> vformat_to_n ( OutputIt  out, size_t  n, basic_string_view< Char >  format_str, basic_format_args< buffer_context< type_identity_t< Char >>>  args  )

inline

References find_lowest_scoring_relaxed_struct::args, cal_vdw_radius_pool::buf, kmeans_adaptive_kernel_density_bb_dependent_rotlib::n, and detail::vformat_to().

Referenced by format_to_n().

visit_format_arg()

template<typename Visitor , typename Context >

FMT_CONSTEXPR_DECL 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

References arg(), detail::bool_type, detail::char_type, detail::cstring_type, detail::custom_type, detail::double_type, detail::float_type, detail::int128_type, detail::int_type, detail::long_double_type, detail::long_long_type, detail::none_type, detail::pointer_type, detail::string_type, detail::uint128_type, detail::uint_type, and detail::ulong_long_type.

Referenced by detail::convert_arg(), basic_printf_context< OutputIt, Char >::format(), formatter< T, Char, enable_if_t< detail::type_constant< T, Char >::value !=detail::type::custom_type > >::format(), dynamic_formatter< Char >::format(), detail::format_arg(), detail::get_dynamic_spec(), detail::format_handler< OutputIt, Char, Context >::on_format_specs(), detail::format_handler< OutputIt, Char, Context >::on_replacement_field(), basic_printf_context< OutputIt, Char >::parse_header(), detail::vformat(), and detail::cf::vformat_to().

vprint() [1/2]

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

References find_lowest_scoring_relaxed_struct::args, detail::utf8_to_utf16::c_str(), detail::buffer< T >::data(), create_a3b_hbs::f, FMT_THROW, detail::fwrite_fully(), detail::utf8_to_utf16::size(), detail::buffer< T >::size(), and detail::vformat_to().

Referenced by vprint().

vprint() [2/2]

FMT_API void vprint	(	string_view	format_str,
		format_args	args
	)

References find_lowest_scoring_relaxed_struct::args, build::stdout, and vprint().

Referenced by print().