detail Namespace Reference

Namespaces
namespace	dragonbox

Classes
struct	codecvt_result
class	compiled_string
struct	conditional_helper
class	dynamic_arg_list
struct	fallback_formatter< T, Char, enable_if_t< is_streamable< T, Char >::value > >
class	file_access
class	formatbuf
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_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 >())), enable_if_t< std::is_copy_constructible< T >::value > > >
struct	integer_sequence
struct	is_compiled_string
struct	is_formattable_delayed
class	is_map
struct	is_range_
struct	is_range_< T, void >
struct	is_reference_wrapper
struct	is_reference_wrapper< std::reference_wrapper< T > >
class	is_set
class	is_std_string_like
struct	is_std_string_like< fmt::basic_string_view< Char > >
class	is_streamable
struct	is_streamable< T, Char, enable_if_t< std::is_arithmetic< T >::value||std::is_array< T >::value||std::is_pointer< T >::value||std::is_same< T, char8_type >::value||std::is_convertible< T, fmt::basic_string_view< Char > >::value||std::is_same< T, std_string_view< Char > >::value||(std::is_convertible< T, int >::value &&!std::is_enum< T >::value)> >
class	is_tuple_formattable_
class	is_tuple_formattable_< T, C, true >
class	is_tuple_like_
struct	make_integer_sequence
struct	make_integer_sequence< T, 0, Ns... >
struct	null
struct	range_default_formatter
struct	range_default_formatter< K, R, Char, enable_if_t<(K==range_format::sequence||K==range_format::map||K==range_format::set)> >
struct	range_format_kind_
struct	range_mapper
struct	singleton
struct	streamed_view
struct	string_literal
class	truncating_iterator
class	truncating_iterator< OutputIt, std::false_type >
class	truncating_iterator< OutputIt, std::true_type >
class	truncating_iterator_base
class	uint128_fallback

Typedefs
template<typename T >
using	is_exotic_char = bool_constant<!std::is_same< T, char >::value >
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<typename Range >
using	uncvref_first_type = remove_cvref_t< decltype(std::declval< range_reference_type< Range > >().first)>
template<typename Range >
using	uncvref_second_type = remove_cvref_t< decltype(std::declval< range_reference_type< Range > >().second)>
template<typename Char , typename Element >
using	range_formatter_type = conditional_t< is_formattable< Element, Char >::value, formatter< remove_cvref_t< decltype(range_mapper< buffer_context< Char > >{}.map(std::declval< Element >()))>, Char >, fallback_formatter< Element, Char > >
template<typename R >
using	maybe_const_range = conditional_t< has_const_begin_end< R >::value, const R, R >
template<range_format K>
using	range_format_constant = std::integral_constant< range_format, K >
using	uint128_t = conditional_t< FMT_USE_INT128, uint128_opt, uint128_fallback >
using	uintptr_t = uint128_t
template<typename T >
using	iterator_t = decltype(std::begin(std::declval< T & >()))
template<typename T >
using	sentinel_t = decltype(std::end(std::declval< T & >()))
template<typename T >
using	checked_ptr = T *
template<typename OutputIt >
using	reserve_iterator = remove_reference_t< decltype(reserve(std::declval< OutputIt & >(), 0))>
using	float128 = void
template<typename T >
using	is_float128 = std::is_same< T, float128 >
template<typename T >
using	is_floating_point = bool_constant< std::is_floating_point< T >::value||is_float128< T >::value >

Enumerations
enum	char8_type : unsigned char

Functions
null localtime_r	FMT_NOMACRO (...)
null	localtime_s (...)
null	gmtime_r (...)
null	gmtime_s (...)
const std::locale &	get_classic_locale ()
template<typename CodeUnit >
void	write_codecvt (codecvt_result< CodeUnit > &out, string_view in_buf, 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 , FMT_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 , FMT_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
template<typename Char , typename InputIt >
FMT_CONSTEXPR counting_iterator	copy_str (InputIt begin, InputIt end, counting_iterator it)
template<typename T , typename... Tail>
const T &	first (const T &value, const Tail &...)
template<typename T >
const T &	unwrap (const T &v)
template<typename T >
const T &	unwrap (const std::reference_wrapper< T > &v)
bool	write_ostream_unicode (std::ostream &os, fmt::string_view data)
bool	write_ostream_unicode (std::wostream &, fmt::basic_string_view< wchar_t >)
template<typename Char >
void	write_buffer (std::basic_ostream< Char > &os, buffer< Char > &buf)
template<typename Char , typename T >
void	format_value (buffer< Char > &buf, const T &value, locale_ref loc=locale_ref())
void	vprint_directly (std::ostream &os, string_view format_str, format_args args)
template<typename RangeT , typename OutputIterator >
OutputIterator	copy (const RangeT &range, OutputIterator out)
template<typename OutputIterator >
OutputIterator	copy (const char *str, OutputIterator out)
template<typename OutputIterator >
OutputIterator	copy (char ch, OutputIterator out)
template<typename OutputIterator >
OutputIterator	copy (wchar_t ch, OutputIterator out)
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) FMT_DECLTYPE_RETURN(static_cast< T && >(rng).begin())
template<typename T >
auto	range_end (T &&rng) FMT_DECLTYPE_RETURN(static_cast< T && >(rng).end())
template<typename T >
auto	range_begin (T &&rng) -> enable_if_t<!has_member_fn_begin_end_t< T && >::value, decltype(begin(static_cast< T && >(rng)))>
template<typename T >
auto	range_end (T &&rng) -> enable_if_t<!has_member_fn_begin_end_t< T && >::value, decltype(end(static_cast< T && >(rng)))>
template<class Tuple , class F , size_t... Is>
void	for_each (index_sequence< Is... >, Tuple &&tup, F &&f) noexcept
template<class T >
FMT_CONSTEXPR make_index_sequence< std::tuple_size< T >::value >	get_indexes (T const &)
template<class Tuple , class F >
void	for_each (Tuple &&tup, F &&f)
template<typename OutputIt >
OutputIt	write_delimiter (OutputIt out)
template<typename Char , typename OutputIt >
auto	write_range_entry (OutputIt out, basic_string_view< Char > str) -> OutputIt
template<typename Char , typename OutputIt , typename T , FMT_ENABLE_IF(std::is_convertible< T, std_string_view< char > >::value) >
auto	write_range_entry (OutputIt out, const T &str) -> OutputIt
template<typename Char , typename OutputIt , typename Arg , FMT_ENABLE_IF(std::is_same< Arg, Char >::value) >
OutputIt	write_range_entry (OutputIt out, const Arg v)
template<typename Char , typename OutputIt , typename Arg , FMT_ENABLE_IF(!is_std_string_like< typename std::decay< Arg >::type >::value && !std::is_same< Arg, Char >::value) >
OutputIt	write_range_entry (OutputIt out, const Arg &v)
FMT_FUNC void	assert_fail (const char *file, int line, const char *message)
FMT_FUNC void	throw_format_error (const char *message)
FMT_FUNC void	format_error_code (detail::buffer< char > &out, int error_code, string_view message) noexcept
FMT_FUNC void	report_error (format_func func, int error_code, const char *message) noexcept
void	fwrite_fully (const void *ptr, size_t size, size_t count, FILE *stream)
template<typename Char >
FMT_FUNC auto	thousands_sep_impl (locale_ref loc) -> thousands_sep_result< Char >
template<typename Char >
FMT_FUNC Char	decimal_point_impl (locale_ref loc)
template<typename F >
bool	operator== (basic_fp< F > x, basic_fp< F > y)
FMT_CONSTEXPR uint32_t	rotr (uint32_t n, uint32_t r) noexcept
FMT_CONSTEXPR uint64_t	rotr (uint64_t n, uint32_t r) noexcept
uint128_fallback	umul128 (uint64_t x, uint64_t y) noexcept
FMT_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
FMT_FUNC auto	is_printable (uint32_t cp) -> bool
FMT_CONSTEXPR void	abort_fuzzing_if (bool condition)
template<typename To , typename From , FMT_ENABLE_IF(sizeof(To)==sizeof(From)) >
FMT_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_t > () -> int
template<typename To , typename From , FMT_ENABLE_IF(sizeof(To) > sizeof(From)) >
auto	bit_cast (const From &from) -> To
FMT_INLINE void	assume (bool condition)
template<typename Char >
auto	get_data (std::basic_string< Char > &s) -> Char *
template<typename Container >
auto	get_data (Container &c) -> typename Container::value_type *
template<typename T >
constexpr auto	make_checked (T *p, size_t) -> T *
template<typename Container , FMT_ENABLE_IF(is_contiguous< Container >::value) >
auto	reserve (std::back_insert_iterator< Container > it, size_t n) -> checked_ptr< typename Container::value_type >
template<typename T >
auto	reserve (buffer_appender< T > it, size_t n) -> buffer_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 >
auto	to_pointer (buffer_appender< T > it, size_t n) -> T *
template<typename Container , FMT_ENABLE_IF(is_contiguous< Container >::value) >
auto	base_iterator (std::back_insert_iterator< Container > &it, checked_ptr< typename Container::value_type >) -> std::back_insert_iterator< Container >
template<typename Iterator >
constexpr auto	base_iterator (Iterator, Iterator it) -> Iterator
template<typename OutputIt , typename Size , typename T >
FMT_CONSTEXPR auto	fill_n (OutputIt out, Size count, const T &value) -> OutputIt
template<typename T , typename Size >
FMT_CONSTEXPR20 auto	fill_n (T *out, Size count, char value) -> T *
template<typename OutChar , typename InputIt , typename OutputIt >
FMT_CONSTEXPR FMT_NOINLINE auto	copy_str_noinline (InputIt begin, InputIt end, OutputIt out) -> OutputIt
FMT_CONSTEXPR auto	utf8_decode (const char *s, uint32_t *c, int *e) -> const char *
template<typename F >
FMT_CONSTEXPR void	for_each_codepoint (string_view s, F f)
template<typename Char >
auto	compute_width (basic_string_view< Char > s) -> size_t
FMT_CONSTEXPR size_t	compute_width (string_view s)
auto	compute_width (basic_string_view< char8_type > 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
auto	code_point_index (basic_string_view< char8_type > s, size_t n) -> size_t

Variables
constexpr uint32_t	invalid_code_point = ~uint32_t()

Typedef Documentation

checked_ptr

template<typename T >

using detail::checked_ptr = typedef T*

float128

using detail::float128 = typedef void

index_sequence

template<size_t... N>

using detail::index_sequence = typedef integer_sequence<size_t, N...>

is_exotic_char

template<typename T >

using detail::is_exotic_char = typedef bool_constant<!std::is_same<T, char>::value>

is_float128

template<typename T >

using detail::is_float128 = typedef std::is_same<T, float128>

is_floating_point

template<typename T >

using detail::is_floating_point = typedef bool_constant<std::is_floating_point<T>::value || is_float128<T>::value>

iterator_t

template<typename T >

using detail::iterator_t = typedef decltype(std::begin(std::declval<T&>()))

make_index_sequence

template<size_t N>

using detail::make_index_sequence = typedef make_integer_sequence<size_t, N>

maybe_const_range

template<typename R >

using detail::maybe_const_range = typedef conditional_t<has_const_begin_end<R>::value, const R, R>

range_format_constant

template<range_format K>

using detail::range_format_constant = typedef std::integral_constant<range_format, K>

range_formatter_type

template<typename Char , typename Element >

using detail::range_formatter_type = typedef conditional_t< is_formattable<Element, Char>::value, formatter<remove_cvref_t<decltype(range_mapper<buffer_context<Char> >{}.map( std::declval<Element>()))>, Char>, fallback_formatter<Element, Char> >

range_reference_type

template<typename Range >

using detail::range_reference_type = typedef decltype(*detail::range_begin(std::declval<Range&>()))

reserve_iterator

template<typename OutputIt >

using detail::reserve_iterator = typedef remove_reference_t<decltype(reserve(std::declval<OutputIt&>(), 0))>

sentinel_t

template<typename T >

using detail::sentinel_t = typedef decltype(std::end(std::declval<T&>()))

tuple_index_sequence

template<typename T >

using detail::tuple_index_sequence = typedef make_index_sequence<std::tuple_size<T>::value>

uint128_t

using detail::uint128_t = typedef conditional_t<FMT_USE_INT128, uint128_opt, uint128_fallback>

uintptr_t

using detail::uintptr_t = typedef uint128_t

uncvref_first_type

template<typename Range >

using detail::uncvref_first_type = typedef remove_cvref_t<decltype(std::declval<range_reference_type<Range> >().first)>

uncvref_second_type

template<typename Range >

using detail::uncvref_second_type = typedef remove_cvref_t< decltype(std::declval<range_reference_type<Range> >().second)>

uncvref_type

template<typename Range >

using detail::uncvref_type = typedef remove_cvref_t<range_reference_type<Range> >

Enumeration Type Documentation

char8_type

enum detail::char8_type : unsigned char

Function Documentation

abort_fuzzing_if()

FMT_CONSTEXPR void detail::abort_fuzzing_if ( bool  condition )

inline

assert_fail()

FMT_FUNC void detail::assert_fail	(	const char *	file,
		int	line,
		const char *	message
	)

assume()

FMT_INLINE void detail::assume

(

bool

condition

)

base_iterator() [1/2]

template<typename Iterator >

constexpr auto detail::base_iterator ( Iterator  , Iterator  it  ) -> Iterator

constexpr

base_iterator() [2/2]

template<typename Container , FMT_ENABLE_IF(is_contiguous< Container >::value) >

auto detail::base_iterator ( std::back_insert_iterator< Container > &  it, checked_ptr< typename Container::value_type >    ) -> std::back_insert_iterator<Container>

inline

bit_cast() [1/2]

template<typename To , typename From , FMT_ENABLE_IF(sizeof(To)==sizeof(From)) >

FMT_CONSTEXPR20 auto detail::bit_cast

(

const From &

from

)

-> To

bit_cast() [2/2]

template<typename To , typename From , FMT_ENABLE_IF(sizeof(To) > sizeof(From)) >

auto detail::bit_cast ( const From &  from ) -> To

inline

code_point_index() [1/3]

template<typename Char >

auto detail::code_point_index ( basic_string_view< Char >  s, size_t  n  ) -> size_t

inline

code_point_index() [2/3]

auto detail::code_point_index ( basic_string_view< char8_type >  s, size_t  n  ) -> size_t

inline

code_point_index() [3/3]

auto detail::code_point_index ( string_view  s, size_t  n  ) -> size_t

inline

compute_width() [1/3]

template<typename Char >

auto detail::compute_width ( basic_string_view< Char >  s ) -> size_t

inline

compute_width() [2/3]

auto detail::compute_width ( basic_string_view< char8_type >  s ) -> size_t

inline

compute_width() [3/3]

FMT_CONSTEXPR size_t detail::compute_width ( string_view  s )

inline

copy() [1/4]

template<typename OutputIterator >

OutputIterator detail::copy	(	char	ch,
		OutputIterator	out
	)

copy() [2/4]

template<typename OutputIterator >

OutputIterator detail::copy	(	const char *	str,
		OutputIterator	out
	)

copy() [3/4]

template<typename RangeT , typename OutputIterator >

OutputIterator detail::copy	(	const RangeT &	range,
		OutputIterator	out
	)

copy() [4/4]

template<typename OutputIterator >

OutputIterator detail::copy	(	wchar_t	ch,
		OutputIterator	out
	)

copy_str()

template<typename Char , typename InputIt >

FMT_CONSTEXPR counting_iterator detail::copy_str ( InputIt  begin, InputIt  end, counting_iterator  it  )

inline

copy_str_noinline()

template<typename OutChar , typename InputIt , typename OutputIt >

FMT_CONSTEXPR FMT_NOINLINE auto detail::copy_str_noinline	(	InputIt	begin,
		InputIt	end,
		OutputIt	out
	)		-> OutputIt

decimal_point_impl()

template<typename Char >

FMT_FUNC Char detail::decimal_point_impl

(

locale_ref

loc

)

do_write()

template<typename Char >

void detail::do_write ( buffer< Char > &  buf, const std::tm &  time, const std::locale &  loc, char  format, char  modifier  )

inline

fill_n() [1/2]

template<typename OutputIt , typename Size , typename T >

FMT_CONSTEXPR auto detail::fill_n	(	OutputIt	out,
		Size	count,
		const T &	value
	)		-> OutputIt

fill_n() [2/2]

template<typename T , typename Size >

FMT_CONSTEXPR20 auto detail::fill_n	(	T *	out,
		Size	count,
		char	value
	)		-> T*

first()

template<typename T , typename... Tail>

const T & detail::first	(	const T &	value,
		const Tail &	...
	)

FMT_NOMACRO()

null localtime_r detail::FMT_NOMACRO (   ... )

inline

for_each() [1/2]

template<class Tuple , class F , size_t... Is>

void detail::for_each ( index_sequence< Is... >  , Tuple &&  tup, F &&  f  )

noexcept

for_each() [2/2]

template<class Tuple , class F >

void detail::for_each	(	Tuple &&	tup,
		F &&	f
	)

for_each_codepoint()

template<typename F >

FMT_CONSTEXPR void detail::for_each_codepoint	(	string_view	s,
		F	f
	)

format_error_code()

FMT_FUNC void detail::format_error_code ( detail::buffer< char > &  out, int  error_code, string_view  message  )

noexcept

format_value()

template<typename Char , typename T >

void detail::format_value	(	buffer< Char > &	buf,
		const T &	value,
		locale_ref	loc = locale_ref()
	)

fwrite_fully()

void detail::fwrite_fully ( const void *  ptr, size_t  size, size_t  count, FILE *  stream  )

inline

get_classic_locale()

const std::locale & detail::get_classic_locale ( )

inline

get_data() [1/2]

template<typename Container >

auto detail::get_data ( Container &  c ) -> typename Container::value_type*

inline

get_data() [2/2]

template<typename Char >

auto detail::get_data ( std::basic_string< Char > &  s ) -> Char*

inline

get_indexes()

template<class T >

FMT_CONSTEXPR make_index_sequence< std::tuple_size< T >::value > detail::get_indexes

(

T const &

)

gmtime_r()

null detail::gmtime_r (   ... )

inline

gmtime_s()

null detail::gmtime_s (   ... )

inline

is_big_endian()

auto detail::is_big_endian ( ) -> bool

inline

is_printable() [1/2]

auto detail::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

inline

is_printable() [2/2]

FMT_FUNC auto detail::is_printable

(

uint32_t

cp

)

-> bool

localtime_s()

null detail::localtime_s (   ... )

inline

make_checked()

template<typename T >

constexpr auto detail::make_checked ( T *  p, size_t    ) -> T*

constexpr

max_value()

template<typename T >

constexpr auto detail::max_value ( ) -> T

constexpr

num_bits()

template<typename T >

constexpr auto detail::num_bits ( ) -> int

constexpr

num_bits< int128_opt >()

template<>

constexpr auto detail::num_bits< int128_opt > ( ) -> int

constexpr

num_bits< uint128_t >()

template<>

constexpr auto detail::num_bits< uint128_t > ( ) -> int

constexpr

operator==()

template<typename F >

bool detail::operator== ( basic_fp< F >  x, basic_fp< F >  y  )

inline

print()

FMT_API void detail::print	(	std::FILE *	f,
		string_view	text
	)

range_begin() [1/3]

template<typename T , std::size_t N>

auto detail::range_begin

(

const T(&)

arr[N]

)

-> const T*

range_begin() [2/3]

template<typename T >

auto detail::range_begin

(

T &&

rng

)

-> enable_if_t<!has_member_fn_begin_end_t<T&&>::value, decltype(begin(static_cast<T&&>(rng)))>

range_begin() [3/3]

template<typename T >

auto detail::range_begin

(

T &&

rng

)

&&

range_end() [1/3]

template<typename T , std::size_t N>

auto detail::range_end

(

const T(&)

arr[N]

)

-> const T*

range_end() [2/3]

template<typename T >

auto detail::range_end

(

T &&

rng

)

-> enable_if_t<!has_member_fn_begin_end_t<T&&>::value, decltype(end(static_cast<T&&>(rng)))>

range_end() [3/3]

template<typename T >

auto detail::range_end

(

T &&

rng

)

&&

report_error()

FMT_FUNC void detail::report_error ( format_func  func, int  error_code, const char *  message  )

noexcept

reserve() [1/3]

template<typename T >

auto detail::reserve ( buffer_appender< T >  it, size_t  n  ) -> buffer_appender<T>

inline

reserve() [2/3]

template<typename Iterator >

constexpr auto detail::reserve ( Iterator &  it, size_t    ) -> Iterator&

constexpr

reserve() [3/3]

template<typename Container , FMT_ENABLE_IF(is_contiguous< Container >::value) >

auto detail::reserve ( std::back_insert_iterator< Container >  it, size_t  n  ) -> checked_ptr<typename Container::value_type>

inline

rotr() [1/2]

FMT_CONSTEXPR uint32_t detail::rotr ( uint32_t  n, uint32_t  r  )

inlinenoexcept

rotr() [2/2]

FMT_CONSTEXPR uint64_t detail::rotr ( uint64_t  n, uint32_t  r  )

inlinenoexcept

thousands_sep_impl()

template<typename Char >

FMT_FUNC auto detail::thousands_sep_impl

(

locale_ref

loc

)

-> thousands_sep_result<Char>

throw_format_error()

FMT_FUNC void detail::throw_format_error

(

const char *

message

)

to_pointer() [1/2]

template<typename T >

auto detail::to_pointer	(	buffer_appender< T >	it,
		size_t	n
	)		-> T*

to_pointer() [2/2]

template<typename T , typename OutputIt >

constexpr auto detail::to_pointer ( OutputIt  , size_t    ) -> T*

constexpr

umul128()

uint128_fallback detail::umul128 ( uint64_t  x, uint64_t  y  )

inlinenoexcept

unwrap() [1/2]

template<typename T >

const T & detail::unwrap

(

const std::reference_wrapper< T > &

v

)

unwrap() [2/2]

template<typename T >

const T & detail::unwrap

(

const T &

v

)

utf8_decode()

FMT_CONSTEXPR auto detail::utf8_decode ( const char *  s, uint32_t *  c, int *  e  ) -> const char*

inline

vprint_directly()

void detail::vprint_directly ( std::ostream &  os, string_view  format_str, format_args  args  )

inline

write()

template<typename Char , typename OutputIt , FMT_ENABLE_IF(!std::is_same< Char, char >::value) >

auto detail::write	(	OutputIt	out,
		const std::tm &	time,
		const std::locale &	loc,
		char	format,
		char	modifier = 0
	)		-> OutputIt

write_buffer()

template<typename Char >

void detail::write_buffer	(	std::basic_ostream< Char > &	os,
		buffer< Char > &	buf
	)

write_codecvt()

template<typename CodeUnit >

void detail::write_codecvt	(	codecvt_result< CodeUnit > &	out,
		string_view	in_buf,
		const std::locale &	loc
	)

write_delimiter()

template<typename OutputIt >

OutputIt detail::write_delimiter

(

OutputIt

out

)

write_encoded_tm_str()

template<typename OutputIt >

auto detail::write_encoded_tm_str	(	OutputIt	out,
		string_view	in,
		const std::locale &	loc
	)		-> OutputIt

write_ostream_unicode() [1/2]

bool detail::write_ostream_unicode ( std::ostream &  os, fmt::string_view  data  )

inline

write_ostream_unicode() [2/2]

bool detail::write_ostream_unicode ( std::wostream &  , fmt::basic_string_view< wchar_t >    )

inline

write_range_entry() [1/4]

template<typename Char , typename OutputIt >

auto detail::write_range_entry	(	OutputIt	out,
		basic_string_view< Char >	str
	)		-> OutputIt

write_range_entry() [2/4]

template<typename Char , typename OutputIt , typename Arg , FMT_ENABLE_IF(!is_std_string_like< typename std::decay< Arg >::type >::value && !std::is_same< Arg, Char >::value) >

OutputIt detail::write_range_entry	(	OutputIt	out,
		const Arg &	v
	)

write_range_entry() [3/4]

template<typename Char , typename OutputIt , typename Arg , FMT_ENABLE_IF(std::is_same< Arg, Char >::value) >

OutputIt detail::write_range_entry	(	OutputIt	out,
		const Arg	v
	)

write_range_entry() [4/4]

template<typename Char , typename OutputIt , typename T , FMT_ENABLE_IF(std::is_convertible< T, std_string_view< char > >::value) >

auto detail::write_range_entry ( OutputIt  out, const T &  str  ) -> OutputIt

inline

write_tm_str()

template<typename Char , typename OutputIt , FMT_ENABLE_IF(!std::is_same< Char, char >::value) >

auto detail::write_tm_str	(	OutputIt	out,
		string_view	sv,
		const std::locale &	loc
	)		-> OutputIt

Variable Documentation

invalid_code_point

constexpr uint32_t detail::invalid_code_point = ~uint32_t()

constexpr