template <typename Char>

struct type_mapper

Defined at line 1154 of file ../../third_party/fmtlib/src/include/fmt/base.h

Maps formatting argument types to natively supported types or user-defined

types with formatters. Returns void on errors to be SFINAE-friendly.

Public Methods

int map (signed char )

unsigned int map (unsigned char )

int map (short )

unsigned int map (unsigned short )

int map (int )

unsigned int map (unsigned int )

long_type map (long )

ulong_type map (unsigned long )

long long map (long long )

unsigned long long map (unsigned long long )

int128_opt map (int128_opt )

uint128_opt map (uint128_opt )

bool map (bool )

template <int N>

conditional_t<N <= 64, long long, void> map (bitint<N> )

template <int N>

conditional_t<N <= 64, unsigned long long, void> map (ubitint<N> )

template <typename T, FMT_ENABLE_IF(is_char<T>::value)>

conditional_t<std::is_same<T, char>::value || std::is_same<T, Char>::value, Char, void> map (T )

float map (float )

double map (double )

long double map (long double )

const Char * map (Char * )

const Char * map (const Char * )

template <typename T, typename C = char_t<T>, FMT_ENABLE_IF(!std::is_pointer<T>::value)>

conditional_t<std::is_same<C, Char>::value, basic_string_view<C>, void> map (const T & )

const void * map (void * )

const void * map (const void * )

const void * map (volatile void * )

const void * map (const volatile void * )

const void * map (nullptr_t )

template <typename T, FMT_ENABLE_IF(std::is_pointer<T>::value ||
                                                          std::is_member_pointer<T>::value)>

void map (const T & )

template <typename T, FMT_ENABLE_IF(use_format_as<T>::value)>

decltype(map(format_as(x))) map (const T & x)

template <typename T, FMT_ENABLE_IF(use_format_as_member<T>::value)>

decltype(map(formatter<T>::format_as(x))) map (const T & x)

template <typename T, FMT_ENABLE_IF(use_formatter<T>::value)>

conditional_t<has_formatter<T, Char>(), T &, void> map (T & )

template <typename T, FMT_ENABLE_IF(is_named_arg<T>::value)>

decltype(map(named_arg.value)) map (const T & named_arg)