fmt::internal Namespace Reference

Classes
struct	Arg
struct	ArgArray
struct	ArgArray< N, false >
struct	ArgArray< N, true >
class	ArgFormatterBase
class	ArgMap
struct	ArgType
class	ArgVisitor
class	BasicArgFormatter
class	BasicCharTraits
struct	BasicData
singleton	CharTraits
class	CharTraits< char >
class	CharTraits< wchar_t >
struct	Conditional
struct	Conditional< false, T, F >
struct	ConvertToInt
struct	ConvertToIntImpl
struct	ConvertToIntImpl2
struct	ConvertToIntImpl2< T, true >
struct	ConvertToIntImpl< T, true >
struct	DummyInt
struct	DummyStream
struct	EnableIf
struct	EnableIf< true, T >
class	FixedBuffer
class	FormatBuf
class	FormatterBase
struct	IntTraits
class	MakeArg
struct	MakeUnsigned
class	MakeValue
class	MemoryBuffer
struct	NamedArg
struct	Not
struct	Not< false >
struct	Null
singleton	PrintfArgFormatter
class	PrintfFormatter
class	RuntimeError
struct	SignChecker
struct	SignChecker< false >
struct	TypeSelector
struct	TypeSelector< false >
struct	Value
struct	WCharHelper
struct	WCharHelper< T, wchar_t >

Typedefs
typedef std::numeric_limits < fmt::internal::DummyInt >	FPUtil
typedef BasicData	Data
typedef char	Yes [1]
typedef char	No [2]

Enumerations
enum	{ INLINE_BUFFER_SIZE = 500 }

Functions
DummyInt	signbit (...)
DummyInt	_ecvt_s (...)
DummyInt	isinf (...)
DummyInt	_finite (...)
DummyInt	isnan (...)
DummyInt	_isnan (...)
template<typename T >
T	check (T value)
	FMT_SPECIALIZE_MAKE_UNSIGNED (char, unsigned char)
	FMT_SPECIALIZE_MAKE_UNSIGNED (signed char, unsigned char)
	FMT_SPECIALIZE_MAKE_UNSIGNED (short, unsigned short)
	FMT_SPECIALIZE_MAKE_UNSIGNED (int, unsigned)
	FMT_SPECIALIZE_MAKE_UNSIGNED (long, unsigned long)
	FMT_SPECIALIZE_MAKE_UNSIGNED (LongLong, ULongLong)
template<typename Int >
MakeUnsigned< Int >::Type	to_unsigned (Int value)
template<typename T >
T *	make_ptr (T *ptr, std::size_t)
template<typename T >
bool	is_negative (T value)
FMT_API void	report_unknown_type (char code, const char *type)
unsigned	count_digits (uint64_t n)
template<typename UInt , typename Char >
void	format_decimal (Char *buffer, UInt value, unsigned num_digits)
FMT_API void	format_system_error (fmt::Writer &out, int error_code, fmt::StringRef message) FMT_NOEXCEPT
Yes &	convert (fmt::ULongLong)
Yes &	convert (std::ostream &)
No &	convert (...)
template<typename T >
T &	get ()
No &	operator<< (std::ostream &, int)
	FMT_DISABLE_CONVERSION_TO_INT (float)
	FMT_DISABLE_CONVERSION_TO_INT (double)
	FMT_DISABLE_CONVERSION_TO_INT (long double)
uint64_t	make_type ()
template<typename T >
uint64_t	make_type (const T &arg)
uint64_t	make_type (FMT_GEN15(FMT_ARG_TYPE_DEFAULT))
template<typename Char >
bool	is_name_start (Char c)
template<typename Char >
unsigned	parse_nonnegative_int (const Char *&s)
void	require_numeric_argument (const Arg &arg, char spec)
template<typename Char >
void	check_sign (const Char *&s, const Arg &arg)

Typedef Documentation

typedef BasicData fmt::internal::Data

typedef std::numeric_limits<fmt::internal::DummyInt> fmt::internal::FPUtil

typedef char fmt::internal::No[2]

typedef char fmt::internal::Yes[1]

Enumeration Type Documentation

anonymous enum

Enumerator
INLINE_BUFFER_SIZE

{ INLINE_BUFFER_SIZE = 500 };

Function Documentation

DummyInt fmt::internal::_ecvt_s (   ... )

inline

{ return DummyInt(); }

Here is the caller graph for this function:

DummyInt fmt::internal::_finite (   ... )

inline

{ return DummyInt(); }

Here is the caller graph for this function:

DummyInt fmt::internal::_isnan (   ... )

inline

{ return DummyInt(); }

Here is the caller graph for this function:

template<typename T >

T fmt::internal::check ( T  value )

inline

{ return value; }

Here is the caller graph for this function:

template<typename Char >

void fmt::internal::check_sign	(	const Char *&	s,
		const Arg &	arg
	)

 {
 char sign = static_cast<char>(*s);
 require_numeric_argument(arg, sign);
 if (arg.type == Arg::UINT || arg.type == Arg::ULONG_LONG) {
 FMT_THROW(FormatError(fmt::format(
 "format specifier '{}' requires signed argument", sign)));
 }
 ++s;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Yes& fmt::internal::convert

(

fmt::ULongLong

)

Here is the caller graph for this function:

Yes& fmt::internal::convert

(

std::ostream &

)

No& fmt::internal::convert

(

...

)

Here is the caller graph for this function:

unsigned fmt::internal::count_digits ( uint64_t  n )

inline

 {
 unsigned count = 1;
 for (;;) {
 // Integer division is slow so do it for a group of four digits instead
 // of for every digit. The idea comes from the talk by Alexandrescu
 // "Three Optimization Tips for C++". See speed-test for a comparison.
 if (n < 10) return count;
 if (n < 100) return count + 1;
 if (n < 1000) return count + 2;
 if (n < 10000) return count + 3;
 n /= 10000u;
 count += 4;
 }
}

Here is the caller graph for this function:

fmt::internal::FMT_DISABLE_CONVERSION_TO_INT

(

float

)

fmt::internal::FMT_DISABLE_CONVERSION_TO_INT

(

double

)

fmt::internal::FMT_DISABLE_CONVERSION_TO_INT

(

long

double

)

fmt::internal::FMT_SPECIALIZE_MAKE_UNSIGNED	(	char	,
		unsigned	char
	)

fmt::internal::FMT_SPECIALIZE_MAKE_UNSIGNED	(	signed	char,
		unsigned	char
	)

fmt::internal::FMT_SPECIALIZE_MAKE_UNSIGNED	(	short	,
		unsigned	short
	)

fmt::internal::FMT_SPECIALIZE_MAKE_UNSIGNED	(	int	,
		unsigned
	)

fmt::internal::FMT_SPECIALIZE_MAKE_UNSIGNED	(	long	,
		unsigned	long
	)

fmt::internal::FMT_SPECIALIZE_MAKE_UNSIGNED	(	LongLong	,
		ULongLong
	)

template<typename UInt , typename Char >

void fmt::internal::format_decimal ( Char *  buffer, UInt  value, unsigned  num_digits  )

inline

 {
 buffer += num_digits;
 while (value >= 100) {
 // Integer division is slow so do it for a group of two digits instead
 // of for every digit. The idea comes from the talk by Alexandrescu
 // "Three Optimization Tips for C++". See speed-test for a comparison.
 unsigned index = static_cast<unsigned>((value % 100) * 2);
 value /= 100;
 *--buffer = Data::DIGITS[index + 1];
 *--buffer = Data::DIGITS[index];
 }
 if (value < 10) {
 *--buffer = static_cast<char>('0' + value);
 return;
 }
 unsigned index = static_cast<unsigned>(value * 2);
 *--buffer = Data::DIGITS[index + 1];
 *--buffer = Data::DIGITS[index];
}

FMT_API void fmt::internal::format_system_error	(	fmt::Writer &	out,
		int	error_code,
		fmt::StringRef	message
	)

template<typename T >

T& fmt::internal::get

(

)

Here is the caller graph for this function:

template<typename Char >

bool fmt::internal::is_name_start ( Char  c )

inline

 {
 return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c;
}

Here is the caller graph for this function:

template<typename T >

bool fmt::internal::is_negative ( T  value )

inline

 {
 return SignChecker<std::numeric_limits<T>::is_signed>::is_negative(value);
}

Here is the caller graph for this function:

DummyInt fmt::internal::isinf (   ... )

inline

{ return DummyInt(); }

Here is the caller graph for this function:

DummyInt fmt::internal::isnan (   ... )

inline

{ return DummyInt(); }

template<typename T >

T* fmt::internal::make_ptr ( T *  ptr, std::size_t    )

inline

{ return ptr; }

Here is the caller graph for this function:

uint64_t fmt::internal::make_type ( )

inline

{ return 0; }

template<typename T >

uint64_t fmt::internal::make_type ( const T &  arg )

inline

 {
 return MakeValue< BasicFormatter<char> >::type(arg);
}

uint64_t fmt::internal::make_type ( FMT_GEN15(FMT_ARG_TYPE_DEFAULT)  )

inline

 {
 return t0.type | (t1.type << 4) | (t2.type << 8) | (t3.type << 12) |
 (t4.type << 16) | (t5.type << 20) | (t6.type << 24) | (t7.type << 28) |
 (t8.type << 32) | (t9.type << 36) | (t10.type << 40) | (t11.type << 44) |
 (t12.type << 48) | (t13.type << 52) | (t14.type << 56);
}

No& fmt::internal::operator<<	(	std::ostream &	,
		int
	)

template<typename Char >

unsigned fmt::internal::parse_nonnegative_int

(

const Char *&

s

)

 {
 assert('0' <= *s && *s <= '9');
 unsigned value = 0;
 do {
 unsigned new_value = value * 10 + (*s++ - '0');
 // Check if value wrapped around.
 if (new_value < value) {
 value = (std::numeric_limits<unsigned>::max)();
 break;
 }
 value = new_value;
 } while ('0' <= *s && *s <= '9');
 // Convert to unsigned to prevent a warning.
 unsigned max_int = (std::numeric_limits<int>::max)();
 if (value > max_int)
 FMT_THROW(FormatError("number is too big"));
 return value;
}

Here is the call graph for this function:

Here is the caller graph for this function:

FMT_API void fmt::internal::report_unknown_type	(	char	code,
		const char *	type
	)

Here is the caller graph for this function:

void fmt::internal::require_numeric_argument ( const Arg &  arg, char  spec  )

inline

 {
 if (arg.type > Arg::LAST_NUMERIC_TYPE) {
 std::string message =
 fmt::format("format specifier '{}' requires numeric argument", spec);
 FMT_THROW(fmt::FormatError(message));
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

DummyInt fmt::internal::signbit (   ... )

inline

{ return DummyInt(); }

Here is the caller graph for this function:

template<typename Int >

MakeUnsigned<Int>::Type fmt::internal::to_unsigned ( Int  value )

inline

 {
 FMT_ASSERT(value >= 0, "negative value");
 return static_cast<typename MakeUnsigned<Int>::Type>(value);
}

Here is the caller graph for this function: