Quick Links: |
#include <bslmf_invokeresult.h>
Public Types | |
enum | { k_IS_VOID } |
typedef InvokeResult_FunctorDeduction < k_IS_VOID, t_FN, t_ARGTYPES...>::type | type |
Static Public Member Functions | |
template<class t_SOME_TYPE > | |
static t_SOME_TYPE | myDeclval () |
static bslmf::Tag< false > | checkLvalue (AnyRvalue,...) |
static bslmf::Tag< true > | checkLvalue (AnyLvalue, int) |
template<class t_TP > | |
static bslmf::Tag< false > | checkConst (t_TP &) |
template<class t_TP > | |
static bslmf::Tag< true > | checkConst (const t_TP &) |
template<class t_TP > | |
static bslmf::Tag< false > | checkVolatile (t_TP &) |
template<class t_TP > | |
static bslmf::Tag< false > | checkVolatile (const t_TP &) |
template<class t_TP > | |
static bslmf::Tag< true > | checkVolatile (volatile t_TP &) |
template<class t_TP > | |
static bslmf::Tag< true > | checkVolatile (const volatile t_TP &) |
template<class t_TP > | |
static t_TP & | uncv (const t_TP &) |
template<class t_TP > | |
static t_TP & | uncv (const volatile t_TP &) |
template<class t_TP > | |
static t_TP & | unpoint (t_TP &) |
template<class t_TP > | |
static const t_TP & | unpoint (const t_TP &) |
template<class t_TP > | |
static bsl::enable_if <!bsl::is_void< t_TP >::value, t_TP >::type & | unpoint (t_TP *&) |
template<class t_TP > | |
static bsl::enable_if <!bsl::is_void< t_TP >::value, t_TP >::type & | unpoint (t_TP *const &) |
template<class t_TP > | |
static bsl::enable_if <!bsl::is_void< t_TP >::value, t_TP >::type & | unpoint (t_TP *volatile &) |
template<class t_TP > | |
static bsl::enable_if <!bsl::is_void< t_TP >::value, t_TP >::type & | unpoint (t_TP *const volatile &) |
Implementation of invoke_result<t_FN, t_ARGTYPES...>
. This specialization is instantiated in C++03 when t_FN
is neither a pointer-to-function, pointer-to-member-function, nor pointer-to-member-object type.
See Component bslmf_invokeresult
typedef InvokeResult_FunctorDeduction<k_IS_VOID, t_FN, t_ARGTYPES...>::type bslmf::InvokeResult_FunctorImp< t_VOID_TYPE, t_FN, t_ARGTYPES >::type |
anonymous enum |
Determine if myDeclval<t_FN>()(myDeclval<t_ARGTYPES>()...)
is a void expression by invoking the overloaded comma operator using a InvokeResult_VoidChecker
as the second argument. If the expression is of void type, then the built-in comma operator will yield InvokeResult_VoidChecker
, otherwise the overloaded comma operator will yield bslmf::Tag<false>
static t_SOME_TYPE bslmf::InvokeResult_ImpUtils::myDeclval | ( | ) | [static, inherited] |
Return an object of the specified t_SOME_TYPE
template parameter type. This function is declared but not defined and is intended to be called in an unevaluated context. Because there is no definition, the available constructors for t_SOME_TYPE
are irrelevant.
static bslmf::Tag<false> bslmf::InvokeResult_ImpUtils::checkLvalue | ( | AnyRvalue | , | |
... | ||||
) | [static, inherited] |
static bslmf::Tag<true > bslmf::InvokeResult_ImpUtils::checkLvalue | ( | AnyLvalue | , | |
int | ||||
) | [static, inherited] |
(Declared but not defined) Return bslmf::Tag<false>()
if the first argument is an rvalue and bslmf::Tag<true>()
if it is lvalue. In actual use, the second argument is always a literal int
, which causes the second overload to be preferred in case of ambiguity.
static bslmf::Tag<false> bslmf::InvokeResult_ImpUtils::checkConst | ( | t_TP & | ) | [static, inherited] |
static bslmf::Tag<true> bslmf::InvokeResult_ImpUtils::checkConst | ( | const t_TP & | ) | [static, inherited] |
(Declared but not defined) Return bslmf::Tag<true>()
if the argument is const
-qualified and bslmf::Tag<false>()
otherwise.
static bslmf::Tag<false> bslmf::InvokeResult_ImpUtils::checkVolatile | ( | t_TP & | ) | [static, inherited] |
static bslmf::Tag<false> bslmf::InvokeResult_ImpUtils::checkVolatile | ( | const t_TP & | ) | [static, inherited] |
static bslmf::Tag<true> bslmf::InvokeResult_ImpUtils::checkVolatile | ( | volatile t_TP & | ) | [static, inherited] |
static bslmf::Tag<true> bslmf::InvokeResult_ImpUtils::checkVolatile | ( | const volatile t_TP & | ) | [static, inherited] |
(Declared but not defined) Return bslmf::Tag<true>()
if the argument is volatile
-qualified and bslmf::Tag<false>()
otherwise. Note that if t_TP
is both const- and volatile-qualified, it will not match volatile t_TP&
, hence the need for the const overloads.
static t_TP& bslmf::InvokeResult_ImpUtils::uncv | ( | const t_TP & | ) | [static, inherited] |
static t_TP& bslmf::InvokeResult_ImpUtils::uncv | ( | const volatile t_TP & | ) | [static, inherited] |
(Declared but not defined) Return the argument, with cv-qualifiers removed.
static t_TP& bslmf::InvokeResult_ImpUtils::unpoint | ( | t_TP & | ) | [static, inherited] |
static const t_TP& bslmf::InvokeResult_ImpUtils::unpoint | ( | const t_TP & | ) | [static, inherited] |
static bsl::enable_if<!bsl::is_void<t_TP>::value, t_TP>::type& bslmf::InvokeResult_ImpUtils::unpoint | ( | t_TP *& | ) | [static, inherited] |
static bsl::enable_if<!bsl::is_void<t_TP>::value, t_TP>::type& bslmf::InvokeResult_ImpUtils::unpoint | ( | t_TP *const & | ) | [static, inherited] |
static bsl::enable_if<!bsl::is_void<t_TP>::value, t_TP>::type& bslmf::InvokeResult_ImpUtils::unpoint | ( | t_TP *volatile & | ) | [static, inherited] |
static bsl::enable_if<!bsl::is_void<t_TP>::value, t_TP>::type& bslmf::InvokeResult_ImpUtils::unpoint | ( | t_TP *const volatile & | ) | [static, inherited] |
If the argument type t_TP
is pointer to type X
, where X
is not cv-'void', return a reference to X
; otherwise return a reference to t_TP
. Note that these functions are declared but not defined and are intended to be called only in an unevaluated context.