WPILibC++ 2024.3.2
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_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) -> 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_FUNC 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_FUNC void assert_fail(const char *file, int line, const char *message)
Definition: format-inl.h:30

◆ 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

An alias to basic_format_args<format_context>.

◆ format_context

◆ format_parse_context

◆ 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

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