Boost logo

Boost :

Subject: Re: [boost] [Review] TTI
From: Jeffrey Lee Hellrung, Jr. (jeffrey.hellrung_at_[hidden])
Date: 2011-07-27 16:14:07

On Wed, Jul 27, 2011 at 12:23 PM, Mathias Gaunard <
mathias.gaunard_at_[hidden]> wrote:

> On 07/27/2011 07:52 PM, Jeffrey Lee Hellrung, Jr. wrote:
> I think you missed the convertibility requirement(s).
>>> TTI needs an exact signature.
>> ...and hence why I had presumed it to be outside of the scope of TTI. It
>> stills falls within the domain of introspection, though.
> You need SFINAE for expressions to do this.

You can get a pretty good approximation via something like the following
(warning: untested).

struct yes_type { char _dummy[1]; };
struct no_type { char _dummy[2]; };

struct dummy_result_t { };
yes_type is_dummy_result(dummy_result_t);
no_type is_dummy_result(...);

struct base_t
{ void xxx() { } };
template< void (base_t::*)( ) >
struct has_mem_fn_detector
{ typedef no_type type; };

template< class T >
struct derived_t : T, base_t
    using T::xxx;
    dummy_result_t xxx(...) const;

template< class T >
typename has_mem_fn_detector< &T::xxx >::type
template< class T >

First, you determine if T *has* a member function called xxx, regardless of
signature, via

struct derived2_t : T, base_t { };
sizeof( has_mem_fn_test< derived2_t >(0) ) == sizeof( yes_type )

and, if this passes, then you use the expression declval< derived_t<T>
>().xxx(arg0, arg1) (for example) to query, first, whether the type of the
expression is dummy_result_t; then, assuming not, whether the type of the
expression has the convertibility properties you desire (for example).

It's not perfect, e.g., it breaks when xxx is private or if you want to
check nullary member functions (must resort to exact signatures in that
case, I think), and I haven't tested what happens when xxx is a static
member function. But I don't think any of this is using SFINAE for

- Jeff

Boost list run by bdawes at, gregod at, cpdaniel at, john at