C++Talk.NET

Howard Gardner · Guest

/*

This program exercises the facility supports_syntax, which
would be handy to use in conjuntion with boost::enable_if.

supports_syntax< SUBJECT, SYNTAX >::value is true if and
only if SUBJECT supports the syntax that SYNTAX checks for.

There are no requirements on SUBJECT. SYNTAX must be
written carefully. This program demonstrates checking
for a member type, a member variable, a member function,
and a nonmember function. The example syntax here is
deliberately minimal. I've tried some more complex
syntax: sometimes I've gotten it to work, and sometimes
I haven't.

I arrived at this implementation through a little research
(sizeof trick, SFINAE) and heroic quantities of experiment.

This code would be very useful(!) in template metaprogramming,
but I'm afraid of it. Since I arrived at it through experiment,
it's quite possible that it just exploits bugs in the compiler
that I'm using. I keep trying to make simplifications that
break it, so there are certainly things about it that I don't
understand.

I'll give the two big mysteries names:

1) syntax dummy parameter

All of the syntax checks are template classes taking one
template parameter, which is a dummy. If I take this dummy
parameter away from syntax_member_type, the code still works.
If I take it away from syntax_member_variable,
syntax_member_function, or syntax_nonmember_function, though,
the code breaks.

2) nonmember_function double overload

Why do I have to supply TWO overloads of nonmember function?
If I supply only one, the code breaks.

*/

#include <fstream>
using std::cout;
using std::endl;

// An empty class to be used as a dummy type
struct
dummy
{
};

// Another empty class to be used as a dummy type
struct
another_dummy
{
};

// An empty class that has none of the syntax I'm checking for
struct
has_nothing
{
};

// A class that defines a type
struct
has_member_type
{
typedef
int
member_type;
};

// Checks that a type is defined
template< typename xDummy = dummy >
// syntax dummy parameter - take this away, still works
struct
syntax_member_type
{
template
<
typename xSubject,
typename = typename xSubject::member_type