core.h File Reference

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

Include dependency graph for core.h:

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

Go to the source code of this file.

Classes
struct	fmt::v8::type_identity< T >
struct	fmt::v8::monostate
struct	fmt::v8::detail::std_string_view< T >
class	fmt::v8::basic_string_view< Char >
struct	fmt::v8::is_char< T >
struct	fmt::v8::is_char< char >
struct	fmt::v8::compile_string
struct	fmt::v8::is_compile_string< S >
struct	fmt::v8::detail::is_string< S >
struct	fmt::v8::detail::char_t_impl< S, typename >
struct	fmt::v8::detail::char_t_impl< S, enable_if_t< is_string< S >::value > >
struct	fmt::v8::detail::error_handler
class	fmt::v8::basic_format_parse_context< Char, ErrorHandler >
class	fmt::v8::basic_format_arg< Context >
class	fmt::v8::basic_format_args< Context >
class	fmt::v8::dynamic_format_arg_store< Context >
struct	fmt::v8::formatter< T, Char, Enable >
struct	fmt::v8::is_contiguous< T >
struct	fmt::v8::is_contiguous< std::basic_string< Char > >
class	fmt::v8::detail::buffer< T >
struct	fmt::v8::detail::buffer_traits
class	fmt::v8::detail::fixed_buffer_traits
class	fmt::v8::detail::iterator_buffer< OutputIt, T, Traits >
class	fmt::v8::detail::iterator_buffer< T *, T, fixed_buffer_traits >
class	fmt::v8::detail::iterator_buffer< T *, T >
class	fmt::v8::detail::iterator_buffer< std::back_insert_iterator< Container >, enable_if_t< is_contiguous< Container >::value, typename Container::value_type > >
class	fmt::v8::detail::counting_buffer< T >
struct	fmt::v8::detail::fallback_formatter< T, Char, Enable >
struct	fmt::v8::detail::view
struct	fmt::v8::detail::named_arg< Char, T >
struct	fmt::v8::detail::named_arg_info< Char >
struct	fmt::v8::detail::arg_data< T, Char, NUM_ARGS, NUM_NAMED_ARGS >
struct	fmt::v8::detail::arg_data< T, Char, NUM_ARGS, 0 >
struct	fmt::v8::detail::is_named_arg< T >
struct	fmt::v8::detail::is_statically_named_arg< T >
struct	fmt::v8::detail::is_named_arg< named_arg< Char, T > >
struct	fmt::v8::detail::type_constant< T, Char >
struct	fmt::v8::detail::type_constant< int, Char >
struct	fmt::v8::detail::type_constant< unsigned, Char >
struct	fmt::v8::detail::type_constant< long long, Char >
struct	fmt::v8::detail::type_constant< unsigned long long, Char >
struct	fmt::v8::detail::type_constant< int128_t, Char >
struct	fmt::v8::detail::type_constant< uint128_t, Char >
struct	fmt::v8::detail::type_constant< bool, Char >
struct	fmt::v8::detail::type_constant< Char, Char >
struct	fmt::v8::detail::type_constant< float, Char >
struct	fmt::v8::detail::type_constant< double, Char >
struct	fmt::v8::detail::type_constant< long double, Char >
struct	fmt::v8::detail::type_constant< const Char *, Char >
struct	fmt::v8::detail::type_constant< basic_string_view< Char >, Char >
struct	fmt::v8::detail::type_constant< const void *, Char >
struct	fmt::v8::detail::unformattable
struct	fmt::v8::detail::unformattable_char
struct	fmt::v8::detail::unformattable_const
struct	fmt::v8::detail::unformattable_pointer
struct	fmt::v8::detail::string_value< Char >
struct	fmt::v8::detail::named_arg_value< Char >
struct	fmt::v8::detail::custom_value< Context >
class	fmt::v8::detail::value< Context >
struct	fmt::v8::detail::arg_mapper< Context >
struct	fmt::v8::detail::arg_mapper< Context >::formattable< T, U >
class	fmt::v8::appender
class	fmt::v8::basic_format_arg< Context >
class	fmt::v8::basic_format_arg< Context >::handle
struct	fmt::v8::detail::is_output_iterator< It, T, Enable >
struct	fmt::v8::detail::is_output_iterator< It, T, void_t< typename std::iterator_traits< It >::iterator_category, decltype(*std::declval< It >()=std::declval< T >())> >
struct	fmt::v8::detail::is_back_insert_iterator< OutputIt >
struct	fmt::v8::detail::is_back_insert_iterator< std::back_insert_iterator< Container > >
struct	fmt::v8::detail::is_contiguous_back_insert_iterator< OutputIt >
struct	fmt::v8::detail::is_contiguous_back_insert_iterator< std::back_insert_iterator< Container > >
struct	fmt::v8::detail::is_contiguous_back_insert_iterator< appender >
class	fmt::v8::detail::locale_ref
class	fmt::v8::basic_format_context< OutputIt, Char >
class	fmt::v8::format_arg_store< Context, Args >
class	fmt::v8::basic_format_args< Context >
struct	fmt::v8::detail::fill_t< Char >
struct	fmt::v8::basic_format_specs< Char >
struct	fmt::v8::detail::arg_ref< Char >
union	fmt::v8::detail::arg_ref< Char >::value
struct	fmt::v8::detail::dynamic_format_specs< Char >
struct	fmt::v8::detail::auto_id
class	fmt::v8::detail::specs_setter< Char >
class	fmt::v8::detail::dynamic_specs_handler< ParseContext >
class	fmt::v8::detail::compile_parse_context< Char, ErrorHandler >
struct	fmt::v8::detail::float_specs
class	fmt::v8::detail::specs_checker< Handler >
class	fmt::v8::detail::format_string_checker< Char, ErrorHandler, Args >
struct	fmt::v8::formatter< T, Char, enable_if_t< detail::type_constant< T, Char >::value !=detail::type::custom_type > >
struct	fmt::v8::basic_runtime< Char >
class	fmt::v8::basic_format_string< Char, Args >
struct	fmt::v8::format_to_n_result< OutputIt >

Namespaces
	fmt
	fmt::v8
	fmt::v8::detail
	fmt::v8::align
	fmt::v8::sign

Macros
#define	FMT_VERSION   80101
#define	FMT_CLANG_VERSION   0
#define	FMT_GCC_VERSION   0
#define	FMT_GCC_PRAGMA(arg)
#define	FMT_ICC_VERSION   0
#define	FMT_NVCC   0
#define	FMT_MSC_VER   0
#define	FMT_MSC_WARNING(...)
#define	FMT_HAS_FEATURE(x)   0
#define	FMT_HAS_INCLUDE(x)   0
#define	FMT_HAS_CPP_ATTRIBUTE(x)   0
#define	FMT_CPLUSPLUS   __cplusplus
#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
#define	FMT_CONSTEXPR
#define	FMT_CONSTEXPR_DECL
#define	FMT_CONSTEXPR20
#define	FMT_CONSTEXPR_CHAR_TRAITS
#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_FALLTHROUGH
#define	FMT_NODISCARD
#define	FMT_USE_FLOAT   1
#define	FMT_USE_DOUBLE   1
#define	FMT_USE_LONG_DOUBLE   1
#define	FMT_INLINE   inline
#define	FMT_DEPRECATED   /* deprecated */
#define	FMT_BEGIN_NAMESPACE
#define	FMT_END_NAMESPACE
#define	FMT_MODULE_EXPORT
#define	FMT_MODULE_EXPORT_BEGIN
#define	FMT_MODULE_EXPORT_END
#define	FMT_BEGIN_DETAIL_NAMESPACE   namespace detail {
#define	FMT_END_DETAIL_NAMESPACE   }
#define	FMT_CLASS_API
#define	FMT_API
#define	FMT_UNICODE   !FMT_MSC_VER
#define	FMT_CONSTEVAL
#define	FMT_USE_NONTYPE_TEMPLATE_PARAMETERS   0
#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, typename T = void>
using	fmt::v8::enable_if_t = typename std::enable_if< B, T >::type
template<bool B, typename T , typename F >
using	fmt::v8::conditional_t = typename std::conditional< B, T, F >::type
template<bool B>
using	fmt::v8::bool_constant = std::integral_constant< bool, B >
template<typename T >
using	fmt::v8::remove_reference_t = typename std::remove_reference< T >::type
template<typename T >
using	fmt::v8::remove_const_t = typename std::remove_const< T >::type
template<typename T >
using	fmt::v8::remove_cvref_t = typename std::remove_cv< remove_reference_t< T > >::type
template<typename T >
using	fmt::v8::type_identity_t = typename type_identity< T >::type
using	fmt::v8::string_view = basic_string_view< char >
template<typename S >
using	fmt::v8::char_t = typename detail::char_t_impl< S >::type
using	fmt::v8::format_parse_context = basic_format_parse_context< char >
template<typename T , typename Context >
using	fmt::v8::has_formatter = std::is_constructible< typename Context::template formatter_type< T > >
template<typename T >
using	fmt::v8::detail::buffer_appender = conditional_t< std::is_same< T, char >::value, appender, std::back_insert_iterator< buffer< T > >>
template<typename T , typename Char >
using	fmt::v8::detail::has_fallback_formatter = std::is_constructible< fallback_formatter< T, Char > >
using	fmt::v8::detail::long_type = conditional_t< long_short, int, long long >
using	fmt::v8::detail::ulong_type = conditional_t< long_short, unsigned, unsigned long long >
template<typename T , typename Context >
using	fmt::v8::detail::mapped_type_constant = type_constant< decltype(arg_mapper< Context >().map(std::declval< const T & >())), typename Context::char_type >
template<typename... >
using	fmt::v8::detail::void_t = void
template<typename Char >
using	fmt::v8::buffer_context = basic_format_context< detail::buffer_appender< Char >, Char >
using	fmt::v8::format_context = buffer_context< char >
template<typename T , typename Char = char>
using	fmt::v8::is_formattable = bool_constant< !std::is_base_of< detail::unformattable, decltype(detail::arg_mapper< buffer_context< Char > >().map(std::declval< T >()))>::value &&!detail::has_fallback_formatter< T, Char >::value >
using	fmt::v8::format_args = basic_format_args< format_context >
using	fmt::v8::align_t = align::type
using	fmt::v8::sign_t = sign::type
using	fmt::v8::format_specs = basic_format_specs< char >
template<typename... Args>
using	fmt::v8::format_string = basic_format_string< char, type_identity_t< Args >... >

Enumerations
enum	fmt::v8::detail::byte : unsigned char
enum	fmt::v8::detail::int128_t
enum	fmt::v8::detail::uint128_t
enum	fmt::v8::detail::type {   fmt::v8::detail::type::none_type, fmt::v8::detail::type::int_type, fmt::v8::detail::type::uint_type, fmt::v8::detail::type::long_long_type,   fmt::v8::detail::type::ulong_long_type, fmt::v8::detail::type::int128_type, fmt::v8::detail::type::uint128_type, fmt::v8::detail::type::bool_type,   fmt::v8::detail::type::char_type, fmt::v8::detail::type::last_integer_type = char_type, fmt::v8::detail::type::float_type, fmt::v8::detail::type::double_type,   fmt::v8::detail::type::long_double_type, fmt::v8::detail::type::last_numeric_type = long_double_type, fmt::v8::detail::type::cstring_type, fmt::v8::detail::type::string_type,   fmt::v8::detail::type::pointer_type, fmt::v8::detail::type::custom_type }
enum	{ fmt::v8::detail::long_short = sizeof(long) == sizeof(int) }
enum	{ fmt::v8::detail::packed_arg_bits = 4 }
enum	{ fmt::v8::detail::max_packed_args = 62 / packed_arg_bits }
enum	: unsigned long long { fmt::v8::detail::is_unpacked_bit = 1ULL << 63 }
enum	: unsigned long long { fmt::v8::detail::has_named_args_bit = 1ULL << 62 }
enum	fmt::v8::align::type {   fmt::v8::align::none, fmt::v8::align::left, fmt::v8::align::right, fmt::v8::align::center,   fmt::v8::align::numeric }
enum	fmt::v8::sign::type { fmt::v8::sign::none, fmt::v8::sign::minus, fmt::v8::sign::plus, fmt::v8::sign::space }
enum	fmt::v8::presentation_type : unsigned char {   fmt::v8::presentation_type::none, fmt::v8::presentation_type::dec, fmt::v8::presentation_type::oct, fmt::v8::presentation_type::hex_lower,   fmt::v8::presentation_type::hex_upper, fmt::v8::presentation_type::bin_lower, fmt::v8::presentation_type::bin_upper, fmt::v8::presentation_type::hexfloat_lower,   fmt::v8::presentation_type::hexfloat_upper, fmt::v8::presentation_type::exp_lower, fmt::v8::presentation_type::exp_upper, fmt::v8::presentation_type::fixed_lower,   fmt::v8::presentation_type::fixed_upper, fmt::v8::presentation_type::general_lower, fmt::v8::presentation_type::general_upper, fmt::v8::presentation_type::chr,   fmt::v8::presentation_type::string, fmt::v8::presentation_type::pointer }
enum	fmt::v8::detail::arg_id_kind { fmt::v8::detail::arg_id_kind::none, fmt::v8::detail::arg_id_kind::index, fmt::v8::detail::arg_id_kind::name }
enum	fmt::v8::detail::float_format : unsigned char { fmt::v8::detail::float_format::general, fmt::v8::detail::float_format::exp, fmt::v8::detail::float_format::fixed, fmt::v8::detail::float_format::hex }

Functions
template<typename... T>
void	fmt::v8::detail::ignore_unused (const T &...)
constexpr auto	fmt::v8::detail::is_constant_evaluated (bool default_value=false) -> bool throw ()
template<typename T >
constexpr auto	fmt::v8::detail::const_check (T value) -> T
void	fmt::v8::detail::assert_fail (const char *file, int line, const char *message)
template<typename T >
auto	fmt::v8::detail::convert_for_visit (T) -> monostate
template<typename Int >
auto	fmt::v8::detail::to_unsigned (Int value) -> typename std::make_unsigned< Int >::type
constexpr auto	fmt::v8::detail::is_utf8 () -> bool
template<typename Char , enable_if_t<(is_char< Char >::value), int > = 0>
auto	fmt::v8::to_string_view (const Char *s) -> basic_string_view< Char >
template<typename Char , typename Traits , typename Alloc >
auto	fmt::v8::to_string_view (const std::basic_string< Char, Traits, Alloc > &s) -> basic_string_view< Char >
template<typename Char >
constexpr auto	fmt::v8::to_string_view (basic_string_view< Char > s) -> basic_string_view< Char >
template<typename Char , enable_if_t<(!std::is_empty< detail::std_string_view< Char >>::value), int > = 0>
auto	fmt::v8::to_string_view (detail::std_string_view< Char > s) -> basic_string_view< Char >
template<typename S , enable_if_t<(is_compile_string< S >::value), int > = 0>
constexpr auto	fmt::v8::to_string_view (const S &s) -> basic_string_view< typename S::char_type >
void	fmt::v8::detail::to_string_view (...)
template<typename... , typename S , enable_if_t<(!is_compile_string< S >::value), int > = 0>
void	fmt::v8::detail::check_format_string (const S &)
template<typename... , typename S , enable_if_t<(is_compile_string< S >::value), int > = 0>
void	fmt::v8::detail::check_format_string (S)
void	fmt::v8::detail::throw_format_error (const char *message)
template<typename Context , typename T >
constexpr auto	fmt::v8::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	fmt::v8::detail::has_const_formatter_impl (...) -> bool
template<typename T , typename Context >
constexpr auto	fmt::v8::detail::has_const_formatter () -> bool
template<typename Container >
auto	fmt::v8::detail::get_container (std::back_insert_iterator< Container > it) -> Container &
template<typename Char , typename InputIt , typename OutputIt >
auto	fmt::v8::detail::copy_str (InputIt begin, InputIt end, OutputIt out) -> OutputIt
template<typename Char , typename T , typename U , enable_if_t<(std::is_same< remove_const_t< T >, U >::value &&is_char< U >::value), int > = 0>
auto	fmt::v8::detail::copy_str (T *begin, T *end, U *out) -> U *
template<typename T , typename OutputIt >
auto	fmt::v8::detail::get_buffer (OutputIt out) -> iterator_buffer< OutputIt, T >
template<typename Buffer >
auto	fmt::v8::detail::get_iterator (Buffer &buf) -> decltype(buf.out())
template<typename T >
auto	fmt::v8::detail::get_iterator (buffer< T > &buf) -> buffer_appender< T >
template<typename Char >
void	fmt::v8::detail::init_named_args (named_arg_info< Char > *, int, int)
template<typename Char , typename T , typename... Tail, enable_if_t<(!is_named_arg< T >::value), int > = 0>
void	fmt::v8::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>
void	fmt::v8::detail::init_named_args (std::nullptr_t, int, int, const Args &...)
template<bool B = false>
constexpr auto	fmt::v8::detail::count () -> size_t
template<bool B1, bool B2, bool... Tail>
constexpr auto	fmt::v8::detail::count () -> size_t
template<typename... Args>
constexpr auto	fmt::v8::detail::count_named_args () -> size_t
template<typename... Args>
constexpr auto	fmt::v8::detail::count_statically_named_args () -> size_t
constexpr bool	fmt::v8::detail::is_integral_type (type t)
constexpr bool	fmt::v8::detail::is_arithmetic_type (type t)
template<typename Context , typename T >
auto	fmt::v8::detail::make_arg (const T &value) -> basic_format_arg< Context >
template<typename Visitor , typename Context >
auto	fmt::v8::visit_format_arg (Visitor &&vis, const basic_format_arg< Context > &arg) -> decltype(vis(0))
template<typename Char , typename InputIt >
auto	fmt::v8::detail::copy_str (InputIt begin, InputIt end, appender out) -> appender
template<typename >
constexpr auto	fmt::v8::detail::encode_types () -> unsigned long long
template<typename Context , typename Arg , typename... Args>
constexpr auto	fmt::v8::detail::encode_types () -> unsigned long long
template<bool IS_PACKED, typename Context , type , typename T , enable_if_t<(IS_PACKED), int > = 0>
auto	fmt::v8::detail::make_arg (T &&val) -> value< Context >
template<bool IS_PACKED, typename Context , type , typename T , enable_if_t<(!IS_PACKED), int > = 0>
auto	fmt::v8::detail::make_arg (const T &value) -> basic_format_arg< Context >
template<typename Context = format_context, typename... Args>
constexpr auto	fmt::v8::make_format_args (Args &&... args) -> format_arg_store< Context, remove_cvref_t< Args >... >
template<typename Char , typename T >
auto	fmt::v8::arg (const Char *name, const T &arg) -> detail::named_arg< Char, T >
template<typename Char >
constexpr bool	fmt::v8::detail::is_ascii_letter (Char c)
template<typename Char , enable_if_t<(std::is_integral< Char >::value), int > = 0>
constexpr auto	fmt::v8::detail::to_ascii (Char value) -> Char
template<typename Char >
auto	fmt::v8::detail::code_point_length (const Char *begin) -> int
template<bool IS_CONSTEXPR, typename T , typename Ptr = const T*>
auto	fmt::v8::detail::find (Ptr first, Ptr last, T value, Ptr &out) -> bool
template<>
auto	fmt::v8::detail::find< false, char > (const char *first, const char *last, char value, const char *&out) -> bool
template<typename Char >
auto	fmt::v8::detail::parse_nonnegative_int (const Char *&begin, const Char *end, int error_value) noexcept -> int
template<typename Char , typename Handler >
auto	fmt::v8::detail::parse_align (const Char *begin, const Char *end, Handler &&handler) -> const Char *
template<typename Char >
bool	fmt::v8::detail::is_name_start (Char c)
template<typename Char , typename IDHandler >
auto	fmt::v8::detail::do_parse_arg_id (const Char *begin, const Char *end, IDHandler &&handler) -> const Char *
template<typename Char , typename IDHandler >
auto	fmt::v8::detail::parse_arg_id (const Char *begin, const Char *end, IDHandler &&handler) -> const Char *
template<typename Char , typename Handler >
auto	fmt::v8::detail::parse_width (const Char *begin, const Char *end, Handler &&handler) -> const Char *
template<typename Char , typename Handler >
auto	fmt::v8::detail::parse_precision (const Char *begin, const Char *end, Handler &&handler) -> const Char *
template<typename Char >
auto	fmt::v8::detail::parse_presentation_type (Char type) -> presentation_type
template<typename Char , typename SpecHandler >
auto	fmt::v8::detail::parse_format_specs (const Char *begin, const Char *end, SpecHandler &&handler) -> const Char *
template<typename Char , typename Handler >
auto	fmt::v8::detail::parse_replacement_field (const Char *begin, const Char *end, Handler &&handler) -> const Char *
template<bool IS_CONSTEXPR, typename Char , typename Handler >
void	fmt::v8::detail::parse_format_string (basic_string_view< Char > format_str, Handler &&handler)
template<typename T , typename ParseContext >
auto	fmt::v8::detail::parse_format_specs (ParseContext &ctx) -> decltype(ctx.begin())
template<typename ErrorHandler >
void	fmt::v8::detail::check_int_type_spec (presentation_type type, ErrorHandler &&eh)
template<typename Char , typename ErrorHandler = error_handler>
auto	fmt::v8::detail::check_char_specs (const basic_format_specs< Char > &specs, ErrorHandler &&eh={}) -> bool
template<typename ErrorHandler = error_handler, typename Char >
auto	fmt::v8::detail::parse_float_type_spec (const basic_format_specs< Char > &specs, ErrorHandler &&eh={}) -> float_specs
template<typename ErrorHandler = error_handler>
auto	fmt::v8::detail::check_cstring_type_spec (presentation_type type, ErrorHandler &&eh={}) -> bool
template<typename ErrorHandler = error_handler>
void	fmt::v8::detail::check_string_type_spec (presentation_type type, ErrorHandler &&eh={})
template<typename ErrorHandler >
void	fmt::v8::detail::check_pointer_type_spec (presentation_type type, ErrorHandler &&eh)
template<typename... Args, typename Char >
auto	fmt::v8::detail::get_arg_index_by_name (basic_string_view< Char > name) -> int
template<typename Char >
void	fmt::v8::detail::vformat_to (buffer< Char > &buf, basic_string_view< Char > fmt, basic_format_args< basic_format_context< detail::buffer_appender< type_identity_t< Char > >, type_identity_t< Char > >> args, locale_ref loc={})
void	fmt::v8::detail::vprint_mojibake (std::FILE *, string_view, format_args)
template<typename S >
auto	fmt::v8::runtime (const S &s) -> basic_runtime< char_t< S >>
auto	fmt::v8::vformat (string_view fmt, format_args args) -> std::string
template<typename... T>
auto	fmt::v8::format (format_string< T... > fmt, T &&... args) -> std::string
template<typename OutputIt , enable_if_t<(detail::is_output_iterator< OutputIt, char >::value), int > = 0>
auto	fmt::v8::vformat_to (OutputIt out, string_view fmt, format_args args) -> OutputIt
template<typename OutputIt , typename... T, enable_if_t<(detail::is_output_iterator< OutputIt, char >::value), int > = 0>
auto	fmt::v8::format_to (OutputIt out, format_string< T... > fmt, T &&... args) -> OutputIt
template<typename OutputIt , typename... T, enable_if_t<(detail::is_output_iterator< OutputIt, char >::value), int > = 0>
auto	fmt::v8::vformat_to_n (OutputIt out, size_t n, string_view fmt, format_args args) -> format_to_n_result< OutputIt >
template<typename OutputIt , typename... T, enable_if_t<(detail::is_output_iterator< OutputIt, char >::value), int > = 0>
auto	fmt::v8::format_to_n (OutputIt out, size_t n, format_string< T... > fmt, T &&... args) -> format_to_n_result< OutputIt >
template<typename... T>
auto	fmt::v8::formatted_size (format_string< T... > fmt, T &&... args) -> size_t
void	fmt::v8::vprint (string_view fmt, format_args args)
void	fmt::v8::vprint (std::FILE *f, string_view fmt, format_args args)
template<typename... T>
void	fmt::v8::print (format_string< T... > fmt, T &&... args)
template<typename... T>
void	fmt::v8::print (std::FILE *f, format_string< T... > fmt, T &&... args)

Variables
constexpr unsigned char	fmt::v8::detail::micro [] = "\u00B5"
constexpr int	fmt::v8::detail::invalid_arg_index = -1

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_DETAIL_NAMESPACE

#define FMT_BEGIN_DETAIL_NAMESPACE   namespace detail {

FMT_BEGIN_NAMESPACE

#define FMT_BEGIN_NAMESPACE

Value:

    namespace fmt {           \
    inline namespace v8 {

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_CONSTEVAL

#define FMT_CONSTEVAL

FMT_CONSTEXPR

#define FMT_CONSTEXPR

FMT_CONSTEXPR20

#define FMT_CONSTEXPR20

FMT_CONSTEXPR_CHAR_TRAITS

#define FMT_CONSTEXPR_CHAR_TRAITS

FMT_CONSTEXPR_DECL

#define FMT_CONSTEXPR_DECL

FMT_CPLUSPLUS

#define FMT_CPLUSPLUS   __cplusplus

FMT_DEPRECATED

#define FMT_DEPRECATED   /* 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_DETAIL_NAMESPACE

#define FMT_END_DETAIL_NAMESPACE   }

FMT_END_NAMESPACE

#define FMT_END_NAMESPACE

Value:

    }                       \
    }

FMT_EXCEPTIONS

#define FMT_EXCEPTIONS   1

FMT_FALLTHROUGH

#define FMT_FALLTHROUGH

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_CXX11_NOEXCEPT

#define FMT_HAS_CXX11_NOEXCEPT   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_MODULE_EXPORT

#define FMT_MODULE_EXPORT

FMT_MODULE_EXPORT_BEGIN

#define FMT_MODULE_EXPORT_BEGIN

FMT_MODULE_EXPORT_END

#define FMT_MODULE_EXPORT_END

FMT_MSC_VER

#define FMT_MSC_VER   0

FMT_MSC_WARNING

#define FMT_MSC_WARNING

(

...

)

FMT_NODISCARD

#define FMT_NODISCARD

FMT_NOEXCEPT

#define FMT_NOEXCEPT   FMT_DETECTED_NOEXCEPT

FMT_NORETURN

#define FMT_NORETURN

FMT_NVCC

#define FMT_NVCC   0

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 >= 1912 || \
     (FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L)) &&           \
        !FMT_NVCC && !FMT_ICC_VERSION

FMT_USE_DOUBLE

#define FMT_USE_DOUBLE   1

FMT_USE_FLOAT

#define FMT_USE_FLOAT   1

FMT_USE_INT128

#define FMT_USE_INT128   0

FMT_USE_LONG_DOUBLE

#define FMT_USE_LONG_DOUBLE   1

FMT_USE_NOEXCEPT

#define FMT_USE_NOEXCEPT   0

FMT_USE_NONTYPE_TEMPLATE_PARAMETERS

#define FMT_USE_NONTYPE_TEMPLATE_PARAMETERS   0

FMT_VERSION

#define FMT_VERSION   80101