Quick Links:

bal | bbl | bdl | bsl

Public Types | Static Public Member Functions

bslmf::InvokeResult_Imp< t_IS_FUNCPTR, t_IS_MEMFUNCPTR, t_IS_MEMOBJPTR, t_FN, t_ARGTYPES > Struct Template Reference

#include <bslmf_invokeresult.h>

Inheritance diagram for bslmf::InvokeResult_Imp< t_IS_FUNCPTR, t_IS_MEMFUNCPTR, t_IS_MEMOBJPTR, t_FN, t_ARGTYPES >:
bslmf::InvokeResult_FunctorImp< void, t_FN, t_ARGTYPES...> bslmf::InvokeResult_ImpUtils

List of all members.

Public Types

enum  
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< truecheckLvalue (AnyLvalue, int)
template<class t_TP >
static bslmf::Tag< false > checkConst (t_TP &)
template<class t_TP >
static bslmf::Tag< truecheckConst (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< truecheckVolatile (volatile t_TP &)
template<class t_TP >
static bslmf::Tag< truecheckVolatile (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 &)

Detailed Description

template<bool t_IS_FUNCPTR, bool t_IS_MEMFUNCPTR, bool t_IS_MEMOBJPTR, class t_FN, class... t_ARGTYPES>
struct bslmf::InvokeResult_Imp< t_IS_FUNCPTR, t_IS_MEMFUNCPTR, t_IS_MEMOBJPTR, t_FN, t_ARGTYPES >

This component-private, partial struct template specialization provides the implementation of InvokeResult_Imp for types that are neither function pointers, pointers to member functions, nor pointers to member objects.

See Component bslmf_invokeresult


Member Typedef Documentation

typedef InvokeResult_FunctorDeduction<k_IS_VOID, t_FN, t_ARGTYPES...>::type bslmf::InvokeResult_FunctorImp< void , t_FN, t_ARGTYPES >::type [inherited]

Member Enumeration Documentation

anonymous enum [inherited]

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>


Member Function Documentation

template<class t_SOME_TYPE >
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.

template<class t_TP >
static bslmf::Tag<false> bslmf::InvokeResult_ImpUtils::checkConst ( t_TP &   )  [static, inherited]
template<class t_TP >
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.

template<class t_TP >
static bslmf::Tag<false> bslmf::InvokeResult_ImpUtils::checkVolatile ( t_TP &   )  [static, inherited]
template<class t_TP >
static bslmf::Tag<false> bslmf::InvokeResult_ImpUtils::checkVolatile ( const t_TP &   )  [static, inherited]
template<class t_TP >
static bslmf::Tag<true> bslmf::InvokeResult_ImpUtils::checkVolatile ( volatile t_TP &   )  [static, inherited]
template<class t_TP >
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.

template<class t_TP >
static t_TP& bslmf::InvokeResult_ImpUtils::uncv ( const t_TP &   )  [static, inherited]
template<class t_TP >
static t_TP& bslmf::InvokeResult_ImpUtils::uncv ( const volatile t_TP &   )  [static, inherited]

(Declared but not defined) Return the argument, with cv-qualifiers removed.

template<class t_TP >
static t_TP& bslmf::InvokeResult_ImpUtils::unpoint ( t_TP &   )  [static, inherited]
template<class t_TP >
static const t_TP& bslmf::InvokeResult_ImpUtils::unpoint ( const t_TP &   )  [static, inherited]
template<class t_TP >
static bsl::enable_if<!bsl::is_void<t_TP>::value, t_TP>::type& bslmf::InvokeResult_ImpUtils::unpoint ( t_TP *&   )  [static, inherited]
template<class t_TP >
static bsl::enable_if<!bsl::is_void<t_TP>::value, t_TP>::type& bslmf::InvokeResult_ImpUtils::unpoint ( t_TP *const &   )  [static, inherited]
template<class t_TP >
static bsl::enable_if<!bsl::is_void<t_TP>::value, t_TP>::type& bslmf::InvokeResult_ImpUtils::unpoint ( t_TP *volatile &   )  [static, inherited]
template<class t_TP >
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.


The documentation for this struct was generated from the following file: