Agora  1.2.0
Agora project
Classes | Public Types | Public Member Functions | List of all members
fmt::v8::detail::arg_mapper< Context > Struct Template Reference

#include <core.h>

Classes

struct  formattable
 

Public Types

using char_type = typename Context::char_type
 
using cstring_result = conditional_t< std::is_same< char_type, char >::value, const char *, unformattable_pointer >
 

Public Member Functions

auto map (signed char val) -> int
 
auto map (unsigned char val) -> unsigned
 
auto map (short val) -> int
 
auto map (unsigned short val) -> unsigned
 
auto map (int val) -> int
 
auto map (unsigned val) -> unsigned
 
auto map (long val) -> long_type
 
auto map (unsigned long val) -> ulong_type
 
auto map (long long val) -> long long
 
auto map (unsigned long long val) -> unsigned long long
 
auto map (int128_t val) -> int128_t
 
auto map (uint128_t val) -> uint128_t
 
auto map (bool val) -> bool
 
template<typename T , enable_if_t<(std::is_same< T, char >::value||std::is_same< T, char_type >::value), int > = 0>
auto map (T val) -> char_type
 
template<typename T , enable_if_t<(std::is_same< T, wchar_t >::value||std::is_same< T, char16_t >::value||std::is_same< T, char32_t >::value) &&!std::is_same< T, char_type >::value, int > = 0>
auto map (T) -> unformattable_char
 
auto map (float val) -> float
 
auto map (double val) -> double
 
auto map (long double val) -> long double
 
auto map (char_type *val) -> const char_type *
 
auto map (const char_type *val) -> const char_type *
 
template<typename T , enable_if_t<(is_string< T >::value &&!std::is_pointer< T >::value &&std::is_same< char_type, char_t< T >>::value), int > = 0>
auto map (const T &val) -> basic_string_view< char_type >
 
template<typename T , enable_if_t<(is_string< T >::value &&!std::is_pointer< T >::value &&!std::is_same< char_type, char_t< T >>::value), int > = 0>
auto map (const T &) -> unformattable_char
 
template<typename T , enable_if_t<(std::is_constructible< basic_string_view< char_type >, T >::value &&!is_string< T >::value &&!has_formatter< T, Context >::value &&!has_fallback_formatter< T, char_type >::value), int > = 0>
auto map (const T &val) -> basic_string_view< char_type >
 
template<typename T , enable_if_t<(std::is_constructible< std_string_view< char_type >, T >::value &&!std::is_constructible< basic_string_view< char_type >, T >::value &&!is_string< T >::value &&!has_formatter< T, Context >::value &&!has_fallback_formatter< T, char_type >::value), int > = 0>
auto map (const T &val) -> basic_string_view< char_type >
 
auto map (const signed char *val) -> cstring_result
 
auto map (const unsigned char *val) -> cstring_result
 
auto map (signed char *val) -> cstring_result
 
auto map (unsigned char *val) -> cstring_result
 
auto map (void *val) -> const void *
 
auto map (const void *val) -> const void *
 
auto map (std::nullptr_t val) -> const void *
 
template<typename T , enable_if_t<(std::is_member_pointer< T >::value||std::is_function< typename std::remove_pointer< T >::type >::value||(std::is_convertible< const T &, const void * >::value &&!std::is_convertible< const T &, const char_type * >::value)), int > = 0>
auto map (const T &) -> unformattable_pointer
 
template<typename T , std::size_t N, enable_if_t<(!std::is_same< T, wchar_t >::value), int > = 0>
auto map (const T(&values)[N]) -> const T(&)[N]
 
template<typename T , enable_if_t<(std::is_enum< T >::value &&std::is_convertible< T, int >::value &&!has_formatter< T, Context >::value &&!has_fallback_formatter< T, char_type >::value), int > = 0>
auto map (const T &val) -> decltype(std::declval< arg_mapper >().map(static_cast< typename std::underlying_type< T >::type >(val)))
 
auto map (detail::byte val) -> unsigned
 
template<typename T , enable_if_t<(formattable< T >::value), int > = 0>
auto do_map (T &&val) -> T &
 
template<typename T , enable_if_t<(!formattable< T >::value), int > = 0>
auto do_map (T &&) -> unformattable_const
 
template<typename T , typename U = remove_cvref_t<T>, enable_if_t<(!is_string< U >::value &&!is_char< U >::value &&!std::is_array< U >::value &&(has_formatter< U, Context >::value||has_fallback_formatter< U, char_type >::value)), int > = 0>
auto map (T &&val) -> decltype(this->do_map(std::forward< T >(val)))
 
template<typename T , enable_if_t<(is_named_arg< T >::value), int > = 0>
auto map (const T &named_arg) -> decltype(std::declval< arg_mapper >().map(named_arg.value))
 
auto map (...) -> unformattable
 

Member Typedef Documentation

◆ char_type

template<typename Context >
using fmt::v8::detail::arg_mapper< Context >::char_type = typename Context::char_type

◆ cstring_result

template<typename Context >
using fmt::v8::detail::arg_mapper< Context >::cstring_result = conditional_t<std::is_same<char_type, char>::value, const char*, unformattable_pointer>

Member Function Documentation

◆ do_map() [1/2]

template<typename Context >
template<typename T , enable_if_t<(!formattable< T >::value), int > = 0>
auto fmt::v8::detail::arg_mapper< Context >::do_map ( T &&  ) -> unformattable_const
inline

◆ do_map() [2/2]

template<typename Context >
template<typename T , enable_if_t<(formattable< T >::value), int > = 0>
auto fmt::v8::detail::arg_mapper< Context >::do_map ( T &&  val) -> T&
inline

◆ map() [1/38]

template<typename Context >
auto fmt::v8::detail::arg_mapper< Context >::map (   ...) -> unformattable
inline

◆ map() [2/38]

template<typename Context >
auto fmt::v8::detail::arg_mapper< Context >::map ( bool  val) -> bool
inline

◆ map() [3/38]

template<typename Context >
auto fmt::v8::detail::arg_mapper< Context >::map ( char_type *  val) -> const char_type*
inline

◆ map() [4/38]

template<typename Context >
auto fmt::v8::detail::arg_mapper< Context >::map ( const char_type *  val) -> const char_type*
inline

◆ map() [5/38]

template<typename Context >
auto fmt::v8::detail::arg_mapper< Context >::map ( const signed char *  val) -> cstring_result
inline
Here is the call graph for this function:

◆ map() [6/38]

template<typename Context >
template<typename T , enable_if_t<(is_string< T >::value &&!std::is_pointer< T >::value &&!std::is_same< char_type, char_t< T >>::value), int > = 0>
auto fmt::v8::detail::arg_mapper< Context >::map ( const T &  ) -> unformattable_char
inline

◆ map() [7/38]

template<typename Context >
template<typename T , enable_if_t<(std::is_member_pointer< T >::value||std::is_function< typename std::remove_pointer< T >::type >::value||(std::is_convertible< const T &, const void * >::value &&!std::is_convertible< const T &, const char_type * >::value)), int > = 0>
auto fmt::v8::detail::arg_mapper< Context >::map ( const T &  ) -> unformattable_pointer
inline

◆ map() [8/38]

template<typename Context >
template<typename T , enable_if_t<(is_named_arg< T >::value), int > = 0>
auto fmt::v8::detail::arg_mapper< Context >::map ( const T &  named_arg) -> decltype(std::declval<arg_mapper>().map(named_arg.value))
inline
Here is the call graph for this function:

◆ map() [9/38]

template<typename Context >
template<typename T , enable_if_t<(is_string< T >::value &&!std::is_pointer< T >::value &&std::is_same< char_type, char_t< T >>::value), int > = 0>
auto fmt::v8::detail::arg_mapper< Context >::map ( const T &  val) -> basic_string_view<char_type>
inline
Here is the call graph for this function:

◆ map() [10/38]

template<typename Context >
template<typename T , enable_if_t<(std::is_constructible< basic_string_view< char_type >, T >::value &&!is_string< T >::value &&!has_formatter< T, Context >::value &&!has_fallback_formatter< T, char_type >::value), int > = 0>
auto fmt::v8::detail::arg_mapper< Context >::map ( const T &  val) -> basic_string_view<char_type>
inline

◆ map() [11/38]

template<typename Context >
template<typename T , enable_if_t<(std::is_constructible< std_string_view< char_type >, T >::value &&!std::is_constructible< basic_string_view< char_type >, T >::value &&!is_string< T >::value &&!has_formatter< T, Context >::value &&!has_fallback_formatter< T, char_type >::value), int > = 0>
auto fmt::v8::detail::arg_mapper< Context >::map ( const T &  val) -> basic_string_view<char_type>
inline

◆ map() [12/38]

template<typename Context >
template<typename T , enable_if_t<(std::is_enum< T >::value &&std::is_convertible< T, int >::value &&!has_formatter< T, Context >::value &&!has_fallback_formatter< T, char_type >::value), int > = 0>
auto fmt::v8::detail::arg_mapper< Context >::map ( const T &  val) -> decltype(std::declval<arg_mapper>().map( static_cast<typename std::underlying_type<T>::type>(val)))
inline
Here is the call graph for this function:

◆ map() [13/38]

template<typename Context >
template<typename T , std::size_t N, enable_if_t<(!std::is_same< T, wchar_t >::value), int > = 0>
auto fmt::v8::detail::arg_mapper< Context >::map ( const T(&)  values[N]) -> const T (&)[N]
inline

◆ map() [14/38]

template<typename Context >
auto fmt::v8::detail::arg_mapper< Context >::map ( const unsigned char *  val) -> cstring_result
inline
Here is the call graph for this function:

◆ map() [15/38]

template<typename Context >
auto fmt::v8::detail::arg_mapper< Context >::map ( const void *  val) -> const void*
inline

◆ map() [16/38]

template<typename Context >
auto fmt::v8::detail::arg_mapper< Context >::map ( detail::byte  val) -> unsigned
inline
Here is the call graph for this function:

◆ map() [17/38]

template<typename Context >
auto fmt::v8::detail::arg_mapper< Context >::map ( double  val) -> double
inline

◆ map() [18/38]

template<typename Context >
auto fmt::v8::detail::arg_mapper< Context >::map ( float  val) -> float
inline

◆ map() [19/38]

template<typename Context >
auto fmt::v8::detail::arg_mapper< Context >::map ( int  val) -> int
inline

◆ map() [20/38]

template<typename Context >
auto fmt::v8::detail::arg_mapper< Context >::map ( int128_t  val) -> int128_t
inline

◆ map() [21/38]

template<typename Context >
auto fmt::v8::detail::arg_mapper< Context >::map ( long double  val) -> long double
inline

◆ map() [22/38]

template<typename Context >
auto fmt::v8::detail::arg_mapper< Context >::map ( long long  val) -> long long
inline

◆ map() [23/38]

template<typename Context >
auto fmt::v8::detail::arg_mapper< Context >::map ( long  val) -> long_type
inline

◆ map() [24/38]

template<typename Context >
auto fmt::v8::detail::arg_mapper< Context >::map ( short  val) -> int
inline

◆ map() [25/38]

template<typename Context >
auto fmt::v8::detail::arg_mapper< Context >::map ( signed char *  val) -> cstring_result
inline
Here is the call graph for this function:

◆ map() [26/38]

template<typename Context >
auto fmt::v8::detail::arg_mapper< Context >::map ( signed char  val) -> int
inline
Here is the caller graph for this function:

◆ map() [27/38]

template<typename Context >
auto fmt::v8::detail::arg_mapper< Context >::map ( std::nullptr_t  val) -> const void*
inline

◆ map() [28/38]

template<typename Context >
template<typename T , typename U = remove_cvref_t<T>, enable_if_t<(!is_string< U >::value &&!is_char< U >::value &&!std::is_array< U >::value &&(has_formatter< U, Context >::value||has_fallback_formatter< U, char_type >::value)), int > = 0>
auto fmt::v8::detail::arg_mapper< Context >::map ( T &&  val) -> decltype(this->do_map(std::forward<T>(val)))
inline

◆ map() [29/38]

template<typename Context >
template<typename T , enable_if_t<(std::is_same< T, char >::value||std::is_same< T, char_type >::value), int > = 0>
auto fmt::v8::detail::arg_mapper< Context >::map ( T  val) -> char_type
inline

◆ map() [30/38]

template<typename Context >
template<typename T , enable_if_t<(std::is_same< T, wchar_t >::value||std::is_same< T, char16_t >::value||std::is_same< T, char32_t >::value) &&!std::is_same< T, char_type >::value, int > = 0>
auto fmt::v8::detail::arg_mapper< Context >::map ( T  ) -> unformattable_char
inline

◆ map() [31/38]

template<typename Context >
auto fmt::v8::detail::arg_mapper< Context >::map ( uint128_t  val) -> uint128_t
inline

◆ map() [32/38]

template<typename Context >
auto fmt::v8::detail::arg_mapper< Context >::map ( unsigned char *  val) -> cstring_result
inline
Here is the call graph for this function:

◆ map() [33/38]

template<typename Context >
auto fmt::v8::detail::arg_mapper< Context >::map ( unsigned char  val) -> unsigned
inline

◆ map() [34/38]

template<typename Context >
auto fmt::v8::detail::arg_mapper< Context >::map ( unsigned long long  val) -> unsigned long long
inline

◆ map() [35/38]

template<typename Context >
auto fmt::v8::detail::arg_mapper< Context >::map ( unsigned long  val) -> ulong_type
inline

◆ map() [36/38]

template<typename Context >
auto fmt::v8::detail::arg_mapper< Context >::map ( unsigned short  val) -> unsigned
inline

◆ map() [37/38]

template<typename Context >
auto fmt::v8::detail::arg_mapper< Context >::map ( unsigned  val) -> unsigned
inline

◆ map() [38/38]

template<typename Context >
auto fmt::v8::detail::arg_mapper< Context >::map ( void *  val) -> const void*
inline
The documentation for this struct was generated from the following file: