detail Namespace Reference

Setups a signal handler to handle fatal signals. More...

Classes
struct	all
struct	ansi_color_escape
class	apple_file
class	arg_converter
struct	arg_formatter
struct	arg_pack
union	arg_ref
class	BackendManager
	Provides access to common collection class that are used by both the frontend and the backend components of the logging system There should only be only active instance of this class which is achieved by the LogSystemManagerSingleton. More...
class	BackendWorker
class	BackendWorkerLock
	Ensures that only one instance of the backend worker is active. More...
class	BacktraceStorage
	Stores N max messages per logger name in a vector. More...
struct	basic_fp
struct	big_decimal_fp
class	bigint
struct	bitint
class	BoundedSPSCQueueImpl
	A bounded single producer single consumer ring buffer. More...
class	buffer
	A contiguous memory buffer with an optional growing ability. More...
struct	buffer_traits
class	char_converter
struct	chrono_format_checker
struct	codecvt_result
struct	color_type
class	compile_parse_context
struct	compile_string
class	container_buffer
struct	count_fractional_digits
struct	count_fractional_digits< Num, Den, N, false >
class	counting_buffer
struct	custom_tag
struct	custom_value
struct	default_arg_formatter
class	digit_grouping
struct	duration_formatter
class	dynamic_arg_list
struct	dynamic_format_specs
struct	dynamic_spec_getter
struct	dynamic_spec_handler
class	DynamicArgList
class	fallback_digit_grouping
class	fallback_file
class	file_access
class	file_base
class	file_print_buffer
class	file_print_buffer< F, enable_if_t< has_flockfile< F >::value > >
struct	find_escape_result
class	fixed_buffer_traits
struct	fixed_string
struct	float128
struct	format_arg_store
struct	format_handler
struct	format_string_char
struct	format_string_char< S, enable_if_t< std::is_base_of< detail::compile_string, S >::value > >
struct	format_string_char< S, void_t< decltype(sizeof(detail::to_string_view(std::declval< S >())))> >
class	format_string_checker
struct	format_tuple_element
class	formatbuf
struct	get_cstring
class	get_locale
class	glibc_file
struct	has_back_insert_iterator_container_append
struct	has_back_insert_iterator_container_append< OutputIt, InputIt, void_t< decltype(get_container(std::declval< OutputIt >()) .append(std::declval< InputIt >(), std::declval< InputIt >()))> >
struct	has_const_begin_end
struct	has_const_begin_end< T, void_t< decltype(*detail::range_begin(std::declval< const remove_cvref_t< T > & >())), decltype(detail::range_end(std::declval< const remove_cvref_t< T > & >()))> >
struct	has_flip
struct	has_flip< T, void_t< decltype(std::declval< T >().flip())> >
struct	has_flockfile
struct	has_flockfile< F, void_t< decltype(flockfile(&std::declval< F & >()))> >
struct	has_isfinite
struct	has_isfinite< T, enable_if_t< sizeof(std::isfinite(T())) !=0 > >
struct	has_member_fn_begin_end_t
struct	has_member_fn_begin_end_t< T, void_t< decltype(*std::declval< T >().begin()), decltype(std::declval< T >().end())> >
struct	has_mutable_begin_end
struct	has_mutable_begin_end< T, void_t< decltype(*detail::range_begin(std::declval< T & >())), decltype(detail::range_end(std::declval< T & >())), int > >
struct	has_tm_gmtoff
struct	has_tm_gmtoff< T, void_t< decltype(T::tm_gmtoff)> >
struct	has_tm_zone
struct	has_tm_zone< T, void_t< decltype(T::tm_zone)> >
struct	has_to_string_view
struct	has_to_string_view< T, void_t< decltype(detail::to_string_view(std::declval< T >()))> >
class	InlinedVector
struct	int_checker
struct	int_checker< true >
struct	integer_sequence
struct	is_back_insert_iterator
struct	is_back_insert_iterator< basic_appender< T > >
struct	is_back_insert_iterator< It, bool_constant< std::is_same< decltype(adl::invoke_back_inserter< typename It::container_type >()), It >::value > >
struct	is_bit_reference_like
struct	is_buffer_appender
struct	is_buffer_appender< It, bool_constant< is_back_insert_iterator< It >::value &&std::is_base_of< buffer< typename It::container_type::value_type >, typename It::container_type >::value > >
class	is_container_adaptor_like
struct	is_floating_point
struct	is_floating_point< float128 >
struct	is_formattable_delayed
struct	is_integral
struct	is_integral< int128_opt >
struct	is_integral< uint128_t >
struct	is_locale
struct	is_locale< T, void_t< decltype(T::classic())> >
class	is_map
struct	is_named_arg
struct	is_named_arg< named_arg< Char, T > >
struct	is_output_iterator
struct	is_output_iterator< appender, char >
struct	is_output_iterator< It, T, enable_if_t< std::is_assignable< decltype(*std::declval< decay_t< It > & >()++), T >::value > >
struct	is_range_
struct	is_range_< T, void >
struct	is_reference_wrapper
struct	is_reference_wrapper< std::reference_wrapper< T > >
class	is_set
struct	is_static_named_arg
struct	is_std_string
	std string detection, ignoring the Allocator type More...
struct	is_std_string< std::basic_string< char, std::char_traits< char >, Allocator > >
struct	is_std_string_like
struct	is_std_string_like< T, void_t< decltype(std::declval< T >().find_first_of(typename T::value_type(), 0))> >
class	is_tuple_formattable_
class	is_tuple_formattable_< T, C, true >
class	is_tuple_like_
struct	is_view
struct	is_view< T, bool_constant< sizeof(T) !=0 > >
struct	is_zero_int
class	iterator_buffer
class	iterator_buffer< OutputIt, enable_if_t< is_back_insert_iterator< OutputIt >::value &&is_contiguous< typename OutputIt::container_type >::value, typename OutputIt::container_type::value_type > >
class	iterator_buffer< T *, T >
class	iterator_buffer< T *, T, fixed_buffer_traits >
class	JsonSink
struct	loc_writer
struct	local_t
class	locale_ref
class	LockGuard
struct	locking
struct	locking< T, void_t< typename formatter< remove_cvref_t< T > >::nonlocking > >
class	LoggerBase
class	LoggerManager
struct	make_integer_sequence
struct	make_integer_sequence< T, 0, Ns... >
struct	make_unsigned_or_bool
struct	make_unsigned_or_bool< bool >
struct	make_unsigned_or_unchanged
struct	make_unsigned_or_unchanged< T, true >
struct	named_arg
struct	named_arg_info
struct	named_arg_store
struct	named_arg_value
struct	native_formatter
struct	node
struct	null
struct	null_chrono_spec_handler
struct	parse_dynamic_spec_result
struct	parse_empty_specs
class	printf_arg_formatter
struct	printf_precision_handler
class	printf_width_handler
struct	range_format_kind_
class	RdtscClock
	Converts tsc ticks to nanoseconds since epoch. More...
struct	remove_cvref
	C++14 implementation of C++20's remove_cvref. More...
class	ScopedThreadContext
class	SignalHandlerContext
struct	singleton
class	SinkManager
struct	size_padding
struct	span
class	Spinlock
struct	std_string_view
class	StopWatch
	A stopwatch utility for measuring elapsed time since construction. More...
struct	streamed_view
struct	string_literal
struct	string_value
class	StringFromTime
	A class that converts a timestamp to a string based on the given format. More...
struct	styled_arg
struct	thousands_sep_result
class	ThreadContext
class	ThreadContextManager
class	TimestampFormatter
	Formats a timestamp given a format string as a pattern. More...
class	tm_format_checker
class	tm_writer
class	to_utf8
struct	TransitEvent
class	TransitEventBuffer
struct	type_constant
struct	type_is_unformattable_for
struct	type_mapper
struct	ubitint
struct	udl_arg
class	uint128_fallback
class	UnboundedSPSCQueue
	A single-producer single-consumer FIFO circular buffer. More...
struct	use_format_as
struct	use_format_as< T, bool_constant< std::is_arithmetic< format_as_result< T > >::value > >
struct	use_format_as_member
struct	use_format_as_member< T, bool_constant< std::is_arithmetic< format_as_member_result< T > >::value > >
struct	utc_clock
class	utf8_to_utf16
class	value
struct	vformat_args
struct	vformat_args< char >
struct	view
struct	write_int_arg

Typedefs
template<typename Char >
using	unsigned_char = conditional_t< sizeof(Char)==1, unsigned char, unsigned >
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. detail:: is intentional to prevent ADL.
using	long_type = conditional_t< long_short, int, long long >
using	ulong_type = conditional_t< long_short, unsigned, unsigned long long >
template<typename T >
using	format_as_result = remove_cvref_t< decltype(format_as(std::declval< const T & >()))>
template<typename T >
using	format_as_member_result = remove_cvref_t< decltype(formatter< T >::format_as(std::declval< const T & >()))>
template<typename T , typename U = remove_const_t<T>>
using	use_formatter = bool_constant<(std::is_class< T >::value||std::is_enum< T >::value||std::is_union< T >::value||std::is_array< T >::value) &&!has_to_string_view< T >::value &&!is_named_arg< T >::value &&!use_format_as< T >::value &&!use_format_as_member< U >::value >
template<typename T , typename Char >
using	mapped_t = decltype(detail::type_mapper< Char >::map(std::declval< T & >()))
template<typename T , typename Char = char>
using	mapped_type_constant = type_constant< mapped_t< T, Char >, Char >
template<typename T , typename Context , type TYPE = mapped_type_constant<T, typename Context::char_type>::value>
using	stored_type_constant = std::integral_constant< type, Context::builtin_types||TYPE==type::int_type ? TYPE :type::custom_type >
template<typename Context , int NUM_ARGS>
using	arg_t = conditional_t< NUM_ARGS<=max_packed_args, value< Context >, basic_format_arg< Context > >
template<typename T , typename U >
using	is_similar_arithmetic_type = bool_constant<(std::is_integral< T >::value &&std::is_integral< U >::value)||(std::is_floating_point< T >::value &&std::is_floating_point< U >::value)>
using	file_ref = decltype(get_file(static_cast< FILE * >(nullptr), 0))
using	uint128_t = conditional_t< FMTQUILL_USE_INT128, uint128_opt, uint128_fallback >
using	uintptr_t = uint128_t
template<typename OutputIt >
using	reserve_iterator = remove_reference_t< decltype(reserve(std::declval< OutputIt & >(), 0))>
template<typename T >
using	is_signed = std::integral_constant< bool, std::numeric_limits< T >::is_signed||std::is_same< T, int128_opt >::value >
template<typename T >
using	is_integer = bool_constant< is_integral< T >::value &&!std::is_same< T, bool >::value &&!std::is_same< T, char >::value &&!std::is_same< T, wchar_t >::value >
template<typename T >
using	is_float128 = std::is_same< T, float128 >
template<typename T >
using	uint32_or_64_or_128_t = conditional_t< num_bits< T >()<=32 &&!FMTQUILL_REDUCE_INT_INSTANTIATIONS, uint32_t, conditional_t< num_bits< T >()<=64, uint64_t, uint128_t > >
template<typename T >
using	uint64_or_128_t = conditional_t< num_bits< T >()<=64, uint64_t, uint128_t >
using	fp = basic_fp< unsigned long long >
template<typename T , bool doublish = num_bits<T>() == num_bits<double>()>
using	convert_float_result = conditional_t< std::is_same< T, float >::value||doublish, double, T >
template<typename T >
using	is_builtin = bool_constant< std::is_same< T, int >::value||FMTQUILL_BUILTIN_TYPES >
using	format_func = void(*)(detail::buffer< char > &, int, const char *)
template<size_t... N>
using	index_sequence = integer_sequence< size_t, N... >
template<size_t N>
using	make_index_sequence = make_integer_sequence< size_t, N >
template<typename T >
using	tuple_index_sequence = make_index_sequence< std::tuple_size< T >::value >
template<typename Range >
using	range_reference_type = decltype(*detail::range_begin(std::declval< Range & >()))
template<typename Range >
using	uncvref_type = remove_cvref_t< range_reference_type< Range > >
template<range_format K>
using	range_format_constant = std::integral_constant< range_format, K >
template<typename Char , typename Element >
using	range_formatter_type = formatter< remove_cvref_t< Element >, Char >
template<typename R >
using	maybe_const_range = conditional_t< has_const_begin_end< R >::value, const R, R >
template<typename T >
using	is_exotic_char = bool_constant<!std::is_same< T, char >::value >
template<typename S >
using	format_string_char_t = typename format_string_char< S >::type
using	BoundedSPSCQueue = BoundedSPSCQueueImpl< size_t >
template<class T >
using	remove_cvref_t = typename remove_cvref< T >::type
using	FormatArgsDecoder = void(*)(std::byte *&data, DynamicFormatArgStore &args_store)
	Decode functions.
using	SizeCacheVector = InlinedVector< uint32_t, 12 >
	A vector that stores sizes for specific operations using uint32_t to optimize space. More...

Enumerations
enum	int128_opt
enum	uint128_opt
enum	{ is_utf8_enabled = "\u00A7"[1] == '\xA7' }
enum	{ use_utf8 = !FMTQUILL_WIN32 || is_utf8_enabled }
enum	type {   none_type, int_type, uint_type, long_long_type,   ulong_long_type, int128_type, uint128_type, bool_type,   char_type, last_integer_type = char_type, float_type, double_type,   long_double_type, last_numeric_type = long_double_type, cstring_type, string_type,   pointer_type, custom_type }
enum	{   sint_set, uint_set, bool_set = set(type::bool_type), char_set = set(type::char_type),   float_set, string_set = set(type::string_type), cstring_set = set(type::cstring_type), pointer_set = set(type::pointer_type) }
enum	{ long_short = sizeof(long) == sizeof(int) && FMTQUILL_BUILTIN_TYPES }
enum	state {   start, align, sign, hash,   zero, width, precision, locale }
enum	{ packed_arg_bits = 4 }
enum	{ max_packed_args = 62 / packed_arg_bits }
enum	: unsigned long long { is_unpacked_bit = 1ULL << 63 }
enum	: unsigned long long { has_named_args_bit = 1ULL << 62 }
enum	numeric_system { standard, alternative }
enum	pad_type { zero, none, space }
enum	to_utf8_error_policy { abort, replace }
enum	dragon { predecessor_closer = 1, fixup = 2, fixed = 4 }

Functions
QUILL_ATTRIBUTE_COLD void	set_cpu_affinity (uint16_t cpu_id)
QUILL_ATTRIBUTE_COLD void	set_thread_name (char const *name)
QUILL_NODISCARD QUILL_ATTRIBUTE_COLD uint32_t	get_process_id () noexcept
template<typename TFrontendOptions >
void	on_signal (int32_t signal_number)
void	on_alarm (int32_t signal_number)
template<typename TFrontendOptions >
void	init_signal_handler (std::vector< int > const &catchable_signals)
QUILL_NODISCARD QUILL_EXPORT QUILL_ATTRIBUTE_USED std::string	get_thread_name ()
	Returns the name of the thread. More...
QUILL_NODISCARD QUILL_EXPORT QUILL_ATTRIBUTE_USED uint32_t	get_thread_id () noexcept
	Returns the os assigned ID of the thread. More...
template<typename T >
auto	unwrap (const T &v) -> const T &
template<typename T >
auto	unwrap (const std::reference_wrapper< T > &v) -> const T &
template<typename... T>
FMTQUILL_CONSTEXPR void	ignore_unused (const T &...)
constexpr auto	is_constant_evaluated (bool default_value=false) noexcept -> bool
template<typename T >
FMTQUILL_ALWAYS_INLINE constexpr auto	const_check (T val) -> T
FMTQUILL_NORETURN FMTQUILL_API void	assert_fail (const char *file, int line, const char *message)
auto	map (int128_opt) -> monostate
auto	map (uint128_opt) -> monostate
template<typename Int >
FMTQUILL_CONSTEXPR auto	to_unsigned (Int value) -> make_unsigned_t< Int >
template<typename T >
constexpr const char *	narrow (const T *)
constexpr FMTQUILL_ALWAYS_INLINE const char *	narrow (const char *s)
template<typename Char >
FMTQUILL_CONSTEXPR auto	compare (const Char *s1, const Char *s2, std::size_t n) -> int
template<typename OutputIt >
FMTQUILL_CONSTEXPR20 auto	get_container (OutputIt it) -> typename OutputIt::container_type &
template<typename Char , FMTQUILL_ENABLE_IF(is_char< Char >::value) >
constexpr auto	to_string_view (const Char *s) -> basic_string_view< Char >
template<typename T , FMTQUILL_ENABLE_IF(is_std_string_like< T >::value) >
constexpr auto	to_string_view (const T &s) -> basic_string_view< typename T::value_type >
template<typename Char >
constexpr auto	to_string_view (basic_string_view< Char > s) -> basic_string_view< Char >
	FMTQUILL_TYPE_CONSTANT (int, int_type)
	FMTQUILL_TYPE_CONSTANT (unsigned, uint_type)
	FMTQUILL_TYPE_CONSTANT (long long, long_long_type)
	FMTQUILL_TYPE_CONSTANT (unsigned long long, ulong_long_type)
	FMTQUILL_TYPE_CONSTANT (int128_opt, int128_type)
	FMTQUILL_TYPE_CONSTANT (uint128_opt, uint128_type)
	FMTQUILL_TYPE_CONSTANT (bool, bool_type)
	FMTQUILL_TYPE_CONSTANT (Char, char_type)
	FMTQUILL_TYPE_CONSTANT (float, float_type)
	FMTQUILL_TYPE_CONSTANT (double, double_type)
	FMTQUILL_TYPE_CONSTANT (long double, long_double_type)
	FMTQUILL_TYPE_CONSTANT (const Char *, cstring_type)
	FMTQUILL_TYPE_CONSTANT (basic_string_view< Char >, string_type)
	FMTQUILL_TYPE_CONSTANT (const void *, pointer_type)
constexpr auto	is_integral_type (type t) -> bool
constexpr auto	is_arithmetic_type (type t) -> bool
constexpr auto	set (type rhs) -> int
constexpr auto	in (type t, int set) -> bool
template<bool B = false>
constexpr auto	count () -> int
template<bool B1, bool B2, bool... Tail>
constexpr auto	count () -> int
template<typename... Args>
constexpr auto	count_named_args () -> int
template<typename... Args>
constexpr auto	count_static_named_args () -> int
template<typename Char >
FMTQUILL_CONSTEXPR void	check_for_duplicate (named_arg_info< Char > *named_args, int named_arg_index, basic_string_view< Char > arg_name)
template<typename Char , typename T , FMTQUILL_ENABLE_IF(!is_named_arg< T >::value) >
void	init_named_arg (named_arg_info< Char > *, int &arg_index, int &, const T &)
template<typename T , typename Char , FMTQUILL_ENABLE_IF(!is_static_named_arg< T >::value) >
FMTQUILL_CONSTEXPR void	init_static_named_arg (named_arg_info< Char > *, int &arg_index, int &)
template<typename Char , typename T , typename U = remove_const_t<T>>
auto	has_formatter_impl (T *p, buffered_context< Char > *ctx=nullptr) -> decltype(formatter< U, Char >().format(*p, *ctx), std::true_type())
template<typename Char >
auto	has_formatter_impl (...) -> std::false_type
template<typename T , typename Char >
constexpr auto	has_formatter () -> bool
template<typename Char , FMTQUILL_ENABLE_IF(std::is_integral< Char >::value) >
constexpr auto	to_ascii (Char c) -> char
template<typename Char >
FMTQUILL_CONSTEXPR auto	code_point_length (const Char *begin) -> int
template<typename Char >
FMTQUILL_CONSTEXPR auto	parse_nonnegative_int (const Char *&begin, const Char *end, int error_value) noexcept -> int
FMTQUILL_CONSTEXPR auto	parse_align (char c) -> align
template<typename Char >
constexpr auto	is_name_start (Char c) -> bool
template<typename Char , typename Handler >
FMTQUILL_CONSTEXPR auto	parse_arg_id (const Char *begin, const Char *end, Handler &&handler) -> const Char *
template<typename Char >
FMTQUILL_CONSTEXPR auto	parse_dynamic_spec (const Char *begin, const Char *end, int &value, arg_ref< Char > &ref, parse_context< Char > &ctx) -> parse_dynamic_spec_result< Char >
template<typename Char >
FMTQUILL_CONSTEXPR auto	parse_width (const Char *begin, const Char *end, format_specs &specs, arg_ref< Char > &width_ref, parse_context< Char > &ctx) -> const Char *
template<typename Char >
FMTQUILL_CONSTEXPR auto	parse_precision (const Char *begin, const Char *end, format_specs &specs, arg_ref< Char > &precision_ref, parse_context< Char > &ctx) -> const Char *
template<typename Char >
FMTQUILL_CONSTEXPR auto	parse_format_specs (const Char *begin, const Char *end, dynamic_format_specs< Char > &specs, parse_context< Char > &ctx, type arg_type) -> const Char *
template<typename Char , typename Handler >
FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto	parse_replacement_field (const Char *begin, const Char *end, Handler &&handler) -> const Char *
template<typename Char , typename Handler >
FMTQUILL_CONSTEXPR void	parse_format_string (basic_string_view< Char > fmt, Handler &&handler)
FMTQUILL_CONSTEXPR auto	check_char_specs (const format_specs &specs) -> bool
template<typename T , typename Char >
	FMTQUILL_VISIBILITY ("hidden") FMTQUILL_CONSTEXPR auto invoke_parse(parse_context< Char > &ctx) -> const Char *
template<typename T , typename InputIt , typename OutputIt , FMTQUILL_ENABLE_IF(is_back_insert_iterator< OutputIt >::value && has_back_insert_iterator_container_append< OutputIt, InputIt >::value) >
FMTQUILL_CONSTEXPR20 auto	copy (InputIt begin, InputIt end, OutputIt out) -> OutputIt
template<typename T , typename InputIt , typename OutputIt , FMTQUILL_ENABLE_IF(!is_back_insert_iterator< OutputIt >::value) >
FMTQUILL_CONSTEXPR auto	copy (InputIt begin, InputIt end, OutputIt out) -> OutputIt
template<typename T , typename V , typename OutputIt >
FMTQUILL_CONSTEXPR auto	copy (basic_string_view< V > s, OutputIt out) -> OutputIt
template<typename T , typename OutputIt , FMTQUILL_ENABLE_IF(!is_buffer_appender< OutputIt >::value) >
auto	get_buffer (OutputIt out) -> iterator_buffer< OutputIt, T >
template<typename Buf , typename OutputIt >
auto	get_iterator (Buf &buf, OutputIt) -> decltype(buf.out())
template<typename T , typename OutputIt >
auto	get_iterator (buffer< T > &, OutputIt out) -> OutputIt
template<typename >
constexpr auto	encode_types () -> unsigned long long
template<typename Context , typename Arg , typename... Args>
constexpr auto	encode_types () -> unsigned long long
template<typename Context , typename... T, size_t NUM_ARGS = sizeof...(T)>
constexpr auto	make_descriptor () -> unsigned long long
template<typename T = int>
FMTQUILL_CONSTEXPR auto	is_locking () -> bool
template<typename T1 , typename T2 , typename... Tail>
FMTQUILL_CONSTEXPR auto	is_locking () -> bool
FMTQUILL_API void	vformat_to (buffer< char > &buf, string_view fmt, format_args args, locale_ref loc={})
void	vprint_mojibake (FILE *, string_view, const format_args &, bool)
auto localtime_r	FMTQUILL_NOMACRO (...) -> null<>
auto	localtime_s (...) -> null<>
auto	gmtime_r (...) -> null<>
auto	gmtime_s (...) -> null<>
auto	get_classic_locale () -> const std::locale &
template<typename CodeUnit >
void	write_codecvt (codecvt_result< CodeUnit > &out, string_view in, const std::locale &loc)
template<typename OutputIt >
auto	write_encoded_tm_str (OutputIt out, string_view in, const std::locale &loc) -> OutputIt
template<typename Char , typename OutputIt , FMTQUILL_ENABLE_IF(!std::is_same< Char, char >::value) >
auto	write_tm_str (OutputIt out, string_view sv, const std::locale &loc) -> OutputIt
template<typename Char >
void	do_write (buffer< Char > &buf, const std::tm &time, const std::locale &loc, char format, char modifier)
template<typename Char , typename OutputIt , FMTQUILL_ENABLE_IF(!std::is_same< Char, char >::value) >
auto	write (OutputIt out, const std::tm &time, const std::locale &loc, char format, char modifier=0) -> OutputIt
FMTQUILL_NORETURN void	throw_duration_error ()
template<typename To , typename FromRep , typename FromPeriod , FMTQUILL_ENABLE_IF(std::is_integral< FromRep >::value && std::is_integral< typename To::rep >::value) >
auto	duration_cast (std::chrono::duration< FromRep, FromPeriod > from) -> To
template<typename Duration >
auto	to_time_t (sys_time< Duration > time_point) -> std::time_t
void	tzset_once ()
void	write_digit2_separated (char *buf, unsigned a, unsigned b, unsigned c, char sep)
template<typename Period >
FMTQUILL_CONSTEXPR auto	get_units () -> const char *
template<typename OutputIt >
auto	write_padding (OutputIt out, pad_type pad, int width) -> OutputIt
template<typename OutputIt >
auto	write_padding (OutputIt out, pad_type pad) -> OutputIt
template<typename Char , typename Handler >
FMTQUILL_CONSTEXPR auto	parse_chrono_format (const Char *begin, const Char *end, Handler &&handler) -> const Char *
auto	tm_wday_full_name (int wday) -> const char *
auto	tm_wday_short_name (int wday) -> const char *
auto	tm_mon_full_name (int mon) -> const char *
auto	tm_mon_short_name (int mon) -> const char *
template<typename T , FMTQUILL_ENABLE_IF(has_tm_zone< T >::value) >
bool	set_tm_zone (T &time, char *tz)
char *	utc ()
template<typename T , typename Int , FMTQUILL_ENABLE_IF(std::is_integral< T >::value) >
auto	to_nonnegative_int (T value, Int upper) -> Int
constexpr auto	pow10 (std::uint32_t n) -> long long
template<typename Char , typename OutputIt , typename Duration >
void	write_fractional_seconds (OutputIt &out, Duration d, int precision=-1)
template<typename Duration >
void	write_floating_seconds (memory_buffer &buf, Duration duration, int num_fractional_digits=-1)
template<typename T , FMTQUILL_ENABLE_IF(std::is_integral< T >::value &&has_isfinite< T >::value) >
auto	isfinite (T) -> bool
template<typename T , FMTQUILL_ENABLE_IF(std::is_integral< T >::value) >
auto	mod (T x, int y) -> T
template<typename Rep , typename Period , FMTQUILL_ENABLE_IF(std::is_integral< Rep >::value) >
auto	get_milliseconds (std::chrono::duration< Rep, Period > d) -> std::chrono::duration< Rep, std::milli >
template<typename Char , typename Rep , typename OutputIt , FMTQUILL_ENABLE_IF(std::is_integral< Rep >::value) >
auto	format_duration_value (OutputIt out, Rep val, int) -> OutputIt
template<typename Char , typename OutputIt >
auto	copy_unit (string_view unit, OutputIt out, Char) -> OutputIt
template<typename OutputIt >
auto	copy_unit (string_view unit, OutputIt out, wchar_t) -> OutputIt
template<typename Char , typename Period , typename OutputIt >
auto	format_duration_unit (OutputIt out) -> OutputIt
template<typename Char >
FMTQUILL_CONSTEXPR auto	make_foreground_color (color_type foreground) noexcept -> ansi_color_escape< Char >
template<typename Char >
FMTQUILL_CONSTEXPR auto	make_background_color (color_type background) noexcept -> ansi_color_escape< Char >
template<typename Char >
FMTQUILL_CONSTEXPR auto	make_emphasis (emphasis em) noexcept -> ansi_color_escape< Char >
template<typename Char >
void	reset_color (buffer< Char > &buffer)
template<typename Char >
void	vformat_to (buffer< Char > &buf, text_style ts, basic_string_view< Char > fmt, basic_format_args< buffered_context< Char >> args)
template<typename T , typename... Tail>
auto	first (const T &value, const Tail &...) -> const T &
FMTQUILL_FUNC void	format_error_code (detail::buffer< char > &out, int error_code, string_view message) noexcept
FMTQUILL_FUNC void	do_report_error (format_func func, int error_code, const char *message) noexcept
void	fwrite_all (const void *ptr, size_t count, FILE *stream)
template<typename Char >
FMTQUILL_FUNC auto	thousands_sep_impl (locale_ref loc) -> thousands_sep_result< Char >
template<typename Char >
FMTQUILL_FUNC auto	decimal_point_impl (locale_ref loc) -> Char
FMTQUILL_FUNC auto	write_loc (appender out, loc_value value, const format_specs &specs, locale_ref loc) -> bool
template<typename F >
auto	operator== (basic_fp< F > x, basic_fp< F > y) -> bool
FMTQUILL_CONSTEXPR auto	rotr (uint32_t n, uint32_t r) noexcept -> uint32_t
FMTQUILL_CONSTEXPR auto	rotr (uint64_t n, uint32_t r) noexcept -> uint64_t
template<typename F >
auto	flockfile (F *f) -> decltype(_lock_file(f))
template<typename F >
auto	funlockfile (F *f) -> decltype(_unlock_file(f))
template<typename F >
auto	getc_unlocked (F *f) -> decltype(_fgetc_nolock(f))
template<typename F , FMTQUILL_ENABLE_IF(sizeof(F::_p) !=0 &&!FMTQUILL_USE_FALLBACK_FILE) >
auto	get_file (F *f, int) -> apple_file< F >
auto	get_file (FILE *f,...) -> fallback_file< FILE >
FMTQUILL_FUNC auto	write_console (int, string_view) -> bool
FMTQUILL_FUNC void	print (std::FILE *f, string_view text)
auto	is_printable (uint16_t x, const singleton *singletons, size_t singletons_size, const unsigned char *singleton_lowers, const unsigned char *normal, size_t normal_size) -> bool
FMTQUILL_FUNC auto	is_printable (uint32_t cp) -> bool
FMTQUILL_CONSTEXPR void	abort_fuzzing_if (bool condition)
template<typename To , typename From , FMTQUILL_ENABLE_IF(sizeof(To)==sizeof(From)) >
FMTQUILL_CONSTEXPR20 auto	bit_cast (const From &from) -> To
auto	is_big_endian () -> bool
template<typename T >
constexpr auto	max_value () -> T
template<typename T >
constexpr auto	num_bits () -> int
template<>
constexpr auto	num_bits< int128_opt > () -> int
template<>
constexpr auto	num_bits< uint128_opt > () -> int
template<>
constexpr auto	num_bits< uint128_fallback > () -> int
template<typename To , typename From , FMTQUILL_ENABLE_IF(sizeof(To) > sizeof(From)) >
auto	bit_cast (const From &from) -> To
template<typename UInt >
FMTQUILL_CONSTEXPR20 auto	countl_zero_fallback (UInt n) -> int
FMTQUILL_CONSTEXPR20 auto	countl_zero (uint32_t n) -> int
FMTQUILL_CONSTEXPR20 auto	countl_zero (uint64_t n) -> int
FMTQUILL_INLINE void	assume (bool condition)
template<typename OutputIt , FMTQUILL_ENABLE_IF(is_back_insert_iterator< OutputIt >::value && is_contiguous< typename OutputIt::container >::value) >
FMTQUILL_CONSTEXPR20 auto	reserve (OutputIt it, size_t n) -> typename OutputIt::value_type *
template<typename T >
FMTQUILL_CONSTEXPR20 auto	reserve (basic_appender< T > it, size_t n) -> basic_appender< T >
template<typename Iterator >
constexpr auto	reserve (Iterator &it, size_t) -> Iterator &
template<typename T , typename OutputIt >
constexpr auto	to_pointer (OutputIt, size_t) -> T *
template<typename T >
FMTQUILL_CONSTEXPR20 auto	to_pointer (basic_appender< T > it, size_t n) -> T *
template<typename OutputIt , FMTQUILL_ENABLE_IF(is_back_insert_iterator< OutputIt >::value && is_contiguous< typename OutputIt::container >::value) >
auto	base_iterator (OutputIt it, typename OutputIt::container_type::value_type *) -> OutputIt
template<typename Iterator >
constexpr auto	base_iterator (Iterator, Iterator it) -> Iterator
template<typename OutputIt , typename Size , typename T >
FMTQUILL_CONSTEXPR auto	fill_n (OutputIt out, Size count, const T &value) -> OutputIt
template<typename T , typename Size >
FMTQUILL_CONSTEXPR20 auto	fill_n (T *out, Size count, char value) -> T *
template<typename OutChar , typename InputIt , typename OutputIt >
FMTQUILL_CONSTEXPR FMTQUILL_NOINLINE auto	copy_noinline (InputIt begin, InputIt end, OutputIt out) -> OutputIt
FMTQUILL_CONSTEXPR auto	utf8_decode (const char *s, uint32_t *c, int *e) -> const char *
template<typename F >
FMTQUILL_CONSTEXPR void	for_each_codepoint (string_view s, F f)
template<typename Char >
auto	compute_width (basic_string_view< Char > s) -> size_t
FMTQUILL_CONSTEXPR auto	compute_width (string_view s) -> size_t
template<typename Char >
auto	code_point_index (basic_string_view< Char > s, size_t n) -> size_t
auto	code_point_index (string_view s, size_t n) -> size_t
FMTQUILL_API void	print (FILE *, string_view)
template<typename Char , size_t N>
FMTQUILL_EXPORT constexpr auto	compile_string_to_view (const Char(&s)[N]) -> basic_string_view< Char >
template<typename Char >
FMTQUILL_EXPORT constexpr auto	compile_string_to_view (basic_string_view< Char > s) -> basic_string_view< Char >
template<typename T , FMTQUILL_ENABLE_IF(is_signed< T >::value) >
constexpr auto	is_negative (T value) -> bool
auto	digits2 (size_t value) -> const char *
template<typename Char >
constexpr auto	getsign (sign s) -> Char
template<typename T >
FMTQUILL_CONSTEXPR auto	count_digits_fallback (T n) -> int
FMTQUILL_CONSTEXPR20 auto	count_digits (uint64_t n) -> int
template<int BITS, typename UInt >
FMTQUILL_CONSTEXPR auto	count_digits (UInt n) -> int
FMTQUILL_CONSTEXPR20 auto	count_digits (uint32_t n) -> int
template<typename Int >
constexpr auto	digits10 () noexcept -> int
template<>
constexpr auto	digits10< int128_opt > () noexcept -> int
template<>
constexpr auto	digits10< uint128_t > () noexcept -> int
template<typename Char >
FMTQUILL_API auto	thousands_sep_impl (locale_ref loc) -> thousands_sep_result< Char >
template<typename Char >
auto	thousands_sep (locale_ref loc) -> thousands_sep_result< Char >
template<>
auto	thousands_sep (locale_ref loc) -> thousands_sep_result< wchar_t >
template<typename Char >
FMTQUILL_API auto	decimal_point_impl (locale_ref loc) -> Char
template<typename Char >
auto	decimal_point (locale_ref loc) -> Char
template<>
auto	decimal_point (locale_ref loc) -> wchar_t
template<typename Char >
auto	equal2 (const Char *lhs, const char *rhs) -> bool
auto	equal2 (const char *lhs, const char *rhs) -> bool
template<typename Char >
FMTQUILL_CONSTEXPR20 FMTQUILL_INLINE void	write2digits (Char *out, size_t value)
template<typename Char , typename UInt >
FMTQUILL_CONSTEXPR20 auto	do_format_decimal (Char *out, UInt value, int size) -> Char *
template<typename Char , typename UInt >
FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto	format_decimal (Char *out, UInt value, int num_digits) -> Char *
template<typename Char , typename UInt , typename OutputIt , FMTQUILL_ENABLE_IF(!std::is_pointer< remove_cvref_t< OutputIt >>::value) >
FMTQUILL_CONSTEXPR auto	format_decimal (OutputIt out, UInt value, int num_digits) -> OutputIt
template<typename Char , typename UInt >
FMTQUILL_CONSTEXPR auto	do_format_base2e (int base_bits, Char *out, UInt value, int size, bool upper=false) -> Char *
template<typename Char , typename UInt >
FMTQUILL_CONSTEXPR auto	format_base2e (int base_bits, Char *out, UInt value, int num_digits, bool upper=false) -> Char *
template<typename Char , typename OutputIt , typename UInt , FMTQUILL_ENABLE_IF(is_back_insert_iterator< OutputIt >::value) >
FMTQUILL_CONSTEXPR auto	format_base2e (int base_bits, OutputIt out, UInt value, int num_digits, bool upper=false) -> OutputIt
auto	umul128 (uint64_t x, uint64_t y) noexcept -> uint128_fallback
template<typename Float >
constexpr auto	has_implicit_bit () -> bool
template<typename Float >
constexpr auto	num_significand_bits () -> int
template<typename Float >
constexpr auto	exponent_mask () -> typename dragonbox::float_info< Float >::carrier_uint
template<typename Float >
constexpr auto	exponent_bias () -> int
template<typename Char , typename OutputIt >
FMTQUILL_CONSTEXPR auto	write_exponent (int exp, OutputIt out) -> OutputIt
template<int SHIFT = 0, typename F >
FMTQUILL_CONSTEXPR auto	normalize (basic_fp< F > value) -> basic_fp< F >
FMTQUILL_CONSTEXPR auto	multiply (uint64_t lhs, uint64_t rhs) -> uint64_t
FMTQUILL_CONSTEXPR auto	operator* (fp x, fp y) -> fp
template<typename T >
constexpr auto	convert_float (T value) -> convert_float_result< T >
template<typename Char , typename OutputIt >
FMTQUILL_CONSTEXPR FMTQUILL_NOINLINE auto	fill (OutputIt it, size_t n, const basic_specs &specs) -> OutputIt
template<typename Char , align default_align = align::left, typename OutputIt , typename F >
FMTQUILL_CONSTEXPR auto	write_padded (OutputIt out, const format_specs &specs, size_t size, size_t width, F &&f) -> OutputIt
template<typename Char , align default_align = align::left, typename OutputIt , typename F >
constexpr auto	write_padded (OutputIt out, const format_specs &specs, size_t size, F &&f) -> OutputIt
template<typename Char , align default_align = align::left, typename OutputIt >
FMTQUILL_CONSTEXPR auto	write_bytes (OutputIt out, string_view bytes, const format_specs &specs={}) -> OutputIt
template<typename Char , typename OutputIt , typename UIntPtr >
auto	write_ptr (OutputIt out, UIntPtr value, const format_specs *specs) -> OutputIt
auto	needs_escape (uint32_t cp) -> bool
template<typename Char >
auto	find_escape (const Char *begin, const Char *end) -> find_escape_result< Char >
auto	find_escape (const char *begin, const char *end) -> find_escape_result< char >
template<size_t width, typename Char , typename OutputIt >
auto	write_codepoint (OutputIt out, char prefix, uint32_t cp) -> OutputIt
template<typename OutputIt , typename Char >
auto	write_escaped_cp (OutputIt out, const find_escape_result< Char > &escape) -> OutputIt
template<typename Char , typename OutputIt >
auto	write_escaped_string (OutputIt out, basic_string_view< Char > str) -> OutputIt
template<typename Char , typename OutputIt >
auto	write_escaped_char (OutputIt out, Char v) -> OutputIt
template<typename Char , typename OutputIt >
FMTQUILL_CONSTEXPR auto	write_char (OutputIt out, Char value, const format_specs &specs) -> OutputIt
template<typename Char , typename OutputIt >
FMTQUILL_CONSTEXPR auto	write (OutputIt out, Char value, const format_specs &specs, locale_ref loc={}) -> OutputIt
FMTQUILL_CONSTEXPR void	prefix_append (unsigned &prefix, unsigned value)
template<typename OutputIt , typename UInt , typename Char >
auto	write_int (OutputIt out, UInt value, unsigned prefix, const format_specs &specs, const digit_grouping< Char > &grouping) -> OutputIt
template<typename OutputIt >
auto	write_loc (OutputIt, const loc_value &, const format_specs &, locale_ref) -> bool
template<typename T >
FMTQUILL_CONSTEXPR auto	make_write_int_arg (T value, sign s) -> write_int_arg< uint32_or_64_or_128_t< T >>
template<typename Char , typename OutputIt , typename T >
FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto	write_int (OutputIt out, write_int_arg< T > arg, const format_specs &specs) -> OutputIt
template<typename Char , typename OutputIt , typename T >
FMTQUILL_CONSTEXPR FMTQUILL_NOINLINE auto	write_int_noinline (OutputIt out, write_int_arg< T > arg, const format_specs &specs) -> OutputIt
template<typename Char , typename T , FMTQUILL_ENABLE_IF(is_integral< T >::value && !std::is_same< T, bool >::value && !std::is_same< T, Char >::value) >
FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto	write (basic_appender< Char > out, T value, const format_specs &specs, locale_ref loc) -> basic_appender< Char >
template<typename Char , typename OutputIt , typename T , FMTQUILL_ENABLE_IF(is_integral< T >::value && !std::is_same< T, bool >::value && !std::is_same< T, Char >::value && !std::is_same< OutputIt, basic_appender< Char >>::value) >
FMTQUILL_CONSTEXPR FMTQUILL_INLINE auto	write (OutputIt out, T value, const format_specs &specs, locale_ref loc) -> OutputIt
template<typename Char , typename OutputIt >
FMTQUILL_CONSTEXPR auto	write (OutputIt out, basic_string_view< Char > s, const format_specs &specs) -> OutputIt
template<typename Char , typename OutputIt >
FMTQUILL_CONSTEXPR auto	write (OutputIt out, basic_string_view< Char > s, const format_specs &specs, locale_ref) -> OutputIt
template<typename Char , typename OutputIt >
FMTQUILL_CONSTEXPR auto	write (OutputIt out, const Char *s, const format_specs &specs, locale_ref) -> OutputIt
template<typename Char , typename OutputIt , typename T , FMTQUILL_ENABLE_IF(is_integral< T >::value && !std::is_same< T, bool >::value && !std::is_same< T, Char >::value) >
FMTQUILL_CONSTEXPR auto	write (OutputIt out, T value) -> OutputIt
template<typename Char >
FMTQUILL_CONSTEXPR auto	parse_align (const Char *begin, const Char *end, format_specs &specs) -> const Char *
template<typename Char , typename OutputIt >
FMTQUILL_CONSTEXPR20 auto	write_nonfinite (OutputIt out, bool isnan, format_specs specs, sign s) -> OutputIt
constexpr auto	get_significand_size (const big_decimal_fp &f) -> int
template<typename T >
auto	get_significand_size (const dragonbox::decimal_fp< T > &f) -> int
template<typename Char , typename OutputIt >
constexpr auto	write_significand (OutputIt out, const char *significand, int significand_size) -> OutputIt
template<typename Char , typename OutputIt , typename UInt >
auto	write_significand (OutputIt out, UInt significand, int significand_size) -> OutputIt
template<typename Char , typename OutputIt , typename T , typename Grouping >
FMTQUILL_CONSTEXPR20 auto	write_significand (OutputIt out, T significand, int significand_size, int exponent, const Grouping &grouping) -> OutputIt
template<typename Char , typename UInt , FMTQUILL_ENABLE_IF(std::is_integral< UInt >::value) >
auto	write_significand (Char *out, UInt significand, int significand_size, int integral_size, Char decimal_point) -> Char *
template<typename OutputIt , typename UInt , typename Char , FMTQUILL_ENABLE_IF(!std::is_pointer< remove_cvref_t< OutputIt >>::value) >
auto	write_significand (OutputIt out, UInt significand, int significand_size, int integral_size, Char decimal_point) -> OutputIt
template<typename OutputIt , typename Char >
FMTQUILL_CONSTEXPR auto	write_significand (OutputIt out, const char *significand, int significand_size, int integral_size, Char decimal_point) -> OutputIt
template<typename OutputIt , typename Char , typename T , typename Grouping >
FMTQUILL_CONSTEXPR20 auto	write_significand (OutputIt out, T significand, int significand_size, int integral_size, Char decimal_point, const Grouping &grouping) -> OutputIt
template<typename Char , typename OutputIt , typename DecimalFP , typename Grouping = digit_grouping<Char>>
FMTQUILL_CONSTEXPR20 auto	do_write_float (OutputIt out, const DecimalFP &f, const format_specs &specs, sign s, int exp_upper, locale_ref loc) -> OutputIt
template<typename Char , typename OutputIt , typename DecimalFP >
FMTQUILL_CONSTEXPR20 auto	write_float (OutputIt out, const DecimalFP &f, const format_specs &specs, sign s, int exp_upper, locale_ref loc) -> OutputIt
template<typename T >
constexpr auto	isnan (T value) -> bool
template<typename T , FMTQUILL_ENABLE_IF(is_floating_point< T >::value &&has_isfinite< T >::value) >
FMTQUILL_CONSTEXPR20 auto	isfinite (T value) -> bool
template<typename T , FMTQUILL_ENABLE_IF(!has_isfinite< T >::value) >
FMTQUILL_CONSTEXPR auto	isfinite (T value) -> bool
template<typename T , FMTQUILL_ENABLE_IF(is_floating_point< T >::value) >
FMTQUILL_INLINE FMTQUILL_CONSTEXPR bool	signbit (T value)
FMTQUILL_CONSTEXPR20 void	adjust_precision (int &precision, int exp10)
FMTQUILL_CONSTEXPR20 void	format_dragon (basic_fp< uint128_t > value, unsigned flags, int num_digits, buffer< char > &buf, int &exp10)
template<typename Float , FMTQUILL_ENABLE_IF(!is_double_double< Float >::value) >
FMTQUILL_CONSTEXPR20 void	format_hexfloat (Float value, format_specs specs, buffer< char > &buf)
constexpr auto	fractional_part_rounding_thresholds (int index) -> uint32_t
template<typename Float >
FMTQUILL_CONSTEXPR20 auto	format_float (Float value, int precision, const format_specs &specs, bool binary32, buffer< char > &buf) -> int
template<typename T >
constexpr auto	exp_upper () -> int
template<typename Char , typename OutputIt , typename T >
FMTQUILL_CONSTEXPR20 auto	write_float (OutputIt out, T value, format_specs specs, locale_ref loc) -> OutputIt
template<typename Char , typename OutputIt , typename T , FMTQUILL_ENABLE_IF(is_floating_point< T >::value) >
FMTQUILL_CONSTEXPR20 auto	write (OutputIt out, T value, format_specs specs, locale_ref loc={}) -> OutputIt
template<typename Char , typename OutputIt , typename T , FMTQUILL_ENABLE_IF(is_fast_float< T >::value) >
FMTQUILL_CONSTEXPR20 auto	write (OutputIt out, T value) -> OutputIt
template<typename Char , typename OutputIt , typename T , FMTQUILL_ENABLE_IF(is_floating_point< T >::value && !is_fast_float< T >::value) >
auto	write (OutputIt out, T value) -> OutputIt
template<typename Char , typename OutputIt >
auto	write (OutputIt out, monostate, format_specs={}, locale_ref={}) -> OutputIt
template<typename Char , typename OutputIt >
FMTQUILL_CONSTEXPR auto	write (OutputIt out, basic_string_view< Char > value) -> OutputIt
template<typename Char , typename OutputIt , typename T , FMTQUILL_ENABLE_IF(has_to_string_view< T >::value) >
constexpr auto	write (OutputIt out, const T &value) -> OutputIt
template<typename Char , typename OutputIt , typename T , bool check = std::is_enum<T>::value && !std::is_same<T, Char>::value && mapped_type_constant<T, Char>::value != type::custom_type, FMTQUILL_ENABLE_IF(check) >
FMTQUILL_CONSTEXPR auto	write (OutputIt out, T value) -> OutputIt
template<typename Char , typename OutputIt , typename T , FMTQUILL_ENABLE_IF(std::is_same< T, bool >::value) >
FMTQUILL_CONSTEXPR auto	write (OutputIt out, T value, const format_specs &specs={}, locale_ref={}) -> OutputIt
template<typename Char , typename OutputIt >
FMTQUILL_CONSTEXPR auto	write (OutputIt out, Char value) -> OutputIt
template<typename Char , typename OutputIt >
FMTQUILL_CONSTEXPR20 auto	write (OutputIt out, const Char *value) -> OutputIt
template<typename Char , typename OutputIt , typename T , FMTQUILL_ENABLE_IF(std::is_same< T, void >::value) >
auto	write (OutputIt out, const T *value, const format_specs &specs={}, locale_ref={}) -> OutputIt
template<typename Char , typename OutputIt , typename T , FMTQUILL_ENABLE_IF(mapped_type_constant< T, Char >::value== type::custom_type && !std::is_fundamental< T >::value) >
FMTQUILL_CONSTEXPR auto	write (OutputIt out, const T &value) -> OutputIt
template<typename Context , typename ID >
FMTQUILL_CONSTEXPR auto	get_arg (Context &ctx, ID id) -> basic_format_arg< Context >
template<typename Context >
FMTQUILL_CONSTEXPR int	get_dynamic_spec (arg_id_kind kind, const arg_ref< typename Context::char_type > &ref, Context &ctx)
template<typename Context >
FMTQUILL_CONSTEXPR void	handle_dynamic_spec (arg_id_kind kind, int &value, const arg_ref< typename Context::char_type > &ref, Context &ctx)
template<typename Char >
void	vformat_to (buffer< Char > &buf, basic_string_view< Char > fmt, typename vformat_args< Char >::type args, locale_ref loc={})
template<typename Char >
void	write_buffer (std::basic_ostream< Char > &os, buffer< Char > &buf)
template<bool IS_CONSTEXPR, typename T , typename Ptr = const T*>
FMTQUILL_CONSTEXPR auto	find (Ptr first, Ptr last, T value, Ptr &out) -> bool
template<>
auto	find< false, char > (const char *first, const char *last, char value, const char *&out) -> bool
template<typename T , typename Context , typename Char >
void	convert_arg (basic_format_arg< Context > &arg, Char type)
template<typename Char >
auto	make_arg_formatter (basic_appender< Char > iter, format_specs &s) -> arg_formatter< Char >
template<typename Char >
void	parse_flags (format_specs &specs, const Char *&it, const Char *end)
template<typename Char , typename GetArg >
auto	parse_header (const Char *&it, const Char *end, format_specs &specs, GetArg get_arg) -> int
auto	parse_printf_presentation_type (char c, type t, bool &upper) -> presentation_type
template<typename Char , typename Context >
void	vprintf (buffer< Char > &buf, basic_string_view< Char > format, basic_format_args< Context > args)
template<typename T , std::size_t N>
auto	range_begin (const T(&arr)[N]) -> const T *
template<typename T , std::size_t N>
auto	range_end (const T(&arr)[N]) -> const T *
template<typename T >
auto	range_begin (T &&rng) -> decltype(static_cast< T &&>(rng).begin())
template<typename T >
auto	range_end (T &&rng) -> decltype(static_cast< T &&>(rng).end())
template<typename Tuple , typename F , size_t... Is>
FMTQUILL_CONSTEXPR void	for_each (index_sequence< Is... >, Tuple &&t, F &&f)
template<typename Tuple , typename F >
FMTQUILL_CONSTEXPR void	for_each (Tuple &&t, F &&f)
template<typename Tuple1 , typename Tuple2 , typename F , size_t... Is>
void	for_each2 (index_sequence< Is... >, Tuple1 &&t1, Tuple2 &&t2, F &&f)
template<typename Tuple1 , typename Tuple2 , typename F >
void	for_each2 (Tuple1 &&t1, Tuple2 &&t2, F &&f)
template<typename Formatter >
FMTQUILL_CONSTEXPR auto	maybe_set_debug_format (Formatter &f, bool set) -> decltype(f.set_debug_format(set))
template<typename Formatter >
FMTQUILL_CONSTEXPR void	maybe_set_debug_format (Formatter &,...)
auto	write_loc (basic_appender< wchar_t > out, loc_value value, const format_specs &specs, locale_ref loc) -> bool
template<typename TClock >
QUILL_NODISCARD QUILL_ATTRIBUTE_HOT std::chrono::nanoseconds	get_timestamp () noexcept
template<typename TClock >
QUILL_NODISCARD QUILL_ATTRIBUTE_HOT uint64_t	get_timestamp_ns () noexcept
template<typename Arg >
void	codec_not_found_for_type ()
QUILL_NODISCARD size_t	safe_strnlen (char const *str, size_t maxlen) noexcept
QUILL_NODISCARD size_t	safe_strnlen (char const *str) noexcept
template<typename... Args>
QUILL_NODISCARD QUILL_ATTRIBUTE_HOT size_t	compute_encoded_size_and_cache_string_lengths (QUILL_MAYBE_UNUSED SizeCacheVector &conditional_arg_size_cache, Args const &... args)
	Calculates the total size required to encode the provided arguments. More...
template<typename... Args>
QUILL_ATTRIBUTE_HOT void	encode (std::byte *&buffer, SizeCacheVector const &conditional_arg_size_cache, Args const &... args)
	Encodes multiple arguments into a buffer. More...
template<typename... Args>
void	decode_and_store_arg (std::byte *&buffer, QUILL_MAYBE_UNUSED DynamicFormatArgStore *args_store)
template<typename... Args>
void	decode_and_store_args (std::byte *&buffer, DynamicFormatArgStore &args_store)
QUILL_NODISCARD QUILL_ATTRIBUTE_HOT std::string_view	log_level_to_string (LogLevel log_level, std::string const *log_levels_strings, size_t log_levels_strings_size)
QUILL_NODISCARD constexpr bool	is_power_of_two (uint64_t number) noexcept
	Check if a number is a power of 2. More...
template<typename T >
QUILL_NODISCARD constexpr T	max_power_of_two () noexcept
	Helper function to calculate the maximum power of two for type T. More...
template<typename T >
QUILL_NODISCARD T	next_power_of_two (T n) noexcept
	Round up to the next power of 2. More...
QUILL_NODISCARD QUILL_ATTRIBUTE_HOT uint64_t	rdtsc () noexcept
	Get the TSC counter. More...
template<typename TFrontendOptions >
QUILL_NODISCARD QUILL_ATTRIBUTE_HOT ThreadContext *	get_local_thread_context () noexcept
tm *	gmtime_rs (time_t const *timer, tm *buf)
	Portable gmtime_r or _s per operating system. More...
tm *	localtime_rs (time_t const *timer, tm *buf)
	Portable localtime_r or _s per operating system. More...
time_t	timegm (tm *tm)
	inverses of gmtime More...

Variables
constexpr FMTQUILL_INLINE_VARIABLE uint32_t	invalid_code_point = ~uint32_t()
template<class >
constexpr bool	always_false_v = false

Detailed Description

Setups a signal handler to handle fatal signals.

Typedef Documentation

SizeCacheVector

using detail::SizeCacheVector = typedef InlinedVector<uint32_t, 12>

A vector that stores sizes for specific operations using uint32_t to optimize space.

The capacity of 12 is chosen to fit within a full cache line for better performance.

Function Documentation

compute_encoded_size_and_cache_string_lengths()

template<typename... Args>

QUILL_NODISCARD QUILL_ATTRIBUTE_HOT size_t detail::compute_encoded_size_and_cache_string_lengths	(	QUILL_MAYBE_UNUSED SizeCacheVector &	conditional_arg_size_cache,
		Args const &...	args
	)

Calculates the total size required to encode the provided arguments.

Parameters

conditional_arg_size_cache	Storage to avoid repeating calculations eg. cache strlen
args	The arguments to be encoded.

Returns

The total size required to encode the arguments.

encode()

template<typename... Args>

QUILL_ATTRIBUTE_HOT void detail::encode	(	std::byte *&	buffer,
		SizeCacheVector const &	conditional_arg_size_cache,
		Args const &...	args
	)

Encodes multiple arguments into a buffer.

Parameters

buffer	Pointer to the buffer for encoding.
conditional_arg_size_cache	Storage to avoid repeating calculations eg. cache strlen
args	The arguments to be encoded.

get_thread_id()

QUILL_NODISCARD QUILL_EXPORT QUILL_ATTRIBUTE_USED uint32_t detail::get_thread_id ( )

inlinenoexcept

Returns the os assigned ID of the thread.

Returns

the thread ID of the calling thread

get_thread_name()

QUILL_NODISCARD QUILL_EXPORT QUILL_ATTRIBUTE_USED std::string detail::get_thread_name ( )

inline

Returns the name of the thread.

We forward declare these to avoid including ThreadUtilities.h.

By default, each thread is unnamed. If set_thread_name has not been used to set the name of the specified thread, a null string is retrieved into name.

Returns

the thread name

gmtime_rs()

tm* detail::gmtime_rs ( time_t const *  timer, tm *  buf  )

inline

Portable gmtime_r or _s per operating system.

Parameters

timer	to a time_t object to convert
buf	to a struct tm object to store the result

Returns

copy of the buf pointer, or throws on error

Exceptions

std::system_error

on failure

is_power_of_two()

QUILL_NODISCARD constexpr bool detail::is_power_of_two ( uint64_t  number )

noexcept

Check if a number is a power of 2.

Parameters

number

the number to check against

Returns

true if the number is power of 2 false otherwise

localtime_rs()

tm* detail::localtime_rs ( time_t const *  timer, tm *  buf  )

inline

Portable localtime_r or _s per operating system.

Parameters

timer	to a time_t object to convert
buf	to a struct tm object to store the result

Returns

copy of the buf pointer, or throws on error

Exceptions

std::system_error

on failure

max_power_of_two()

template<typename T >

QUILL_NODISCARD constexpr T detail::max_power_of_two ( )

noexcept

Helper function to calculate the maximum power of two for type T.

Returns

maximum power of two for type T

next_power_of_two()

template<typename T >

QUILL_NODISCARD T detail::next_power_of_two ( T  n )

noexcept

Round up to the next power of 2.

Parameters

n

input

Returns

the next power of 2

rdtsc()

QUILL_NODISCARD QUILL_ATTRIBUTE_HOT uint64_t detail::rdtsc ( )

inlinenoexcept

Get the TSC counter.

Returns

rdtsc timestamp

timegm()

time_t detail::timegm ( tm *  tm )

inline

inverses of gmtime

Parameters

tm	struct tm to convert

Exceptions

on	invalid input