Re: "Overloading" a metafunction
on Sat Jul 14 2007, Ronald Landheer-Cieslak <blytkerchan-AT-gmail.com>
wrote:
On Jul 13, 2:25 pm, David Abrahams <d...@boost-consulting.com> wrote:
on Fri Jul 13 2007, Ronald Landheer-Cieslak <blytkerchan-AT-gmail.com>
wrote:
Hello all,
In my generic Visitors implementation, I have defined a policy type
(which determines how I traverse the structure to be visited) as a
meta-function of the type of the visitor and the type of the visited
structure's node:
#ifndef _visitors_get_traversal_policy_type_h
#define _visitors_get_traversal_policy_type_h
Identifiers beginning with underscores and followed by lower case
letters are reserved to the implementation at global scope, IIRC.
I suggest you leave a blank line here, after quoted text and before
your replies. It's easier on the reader.
Wasn't that underscores followed by uppercase letters? (hope so, or I
have a lot of inclusion guards to correct).
17.4.3.1.2 Global names
[global.names]
Certain sets of names and function signatures are always reserved to
the implementation:
1
? Each name that contains a double underscore or begins with an
underscore followed by an uppercase letter (2.11) is reserved
to the implementation for any use.
? Each name that begins with an underscore is reserved to the
implementation for use as a name in the global namespace.174)
174) Such names are also reserved in namespace ::std (17.4.3.1).
Anyway, it's slightly beside the point..
Yes
OK, let me put it a bit differently, then: I have a meta-function that
takes a visitor's type and a visitee's (node) type as parameter and
hands back the traversal policy to use for the visitor. I.e.:
<snip long explanation I don't have time to understand (sorry)>
Is there any known way to "overload" a meta-function in such a way
that, once I do know the visitor and visitee types I can "invoke" it
to get the policy type I need, knowing that I won't know either type
until I also know the vertex and edge types (and two booleans)?
I'm mostly lost, but, as a metafunction is just a class template, and
there is a reasonably-close analogue for overloading, I'll suggest you
use (partial) specialization to match just the arguments you're
interested in. If the matching the structure of a type is
insufficient, you can use enable_if as described
in
http://www.boost.org/libs/utility/enable_if.html#sec:enable_if_classes
That's a really, *really* cool trick: I hadn't thought of SFINAE for
this yet.
[...] pondering [...]
This will work! Thanks! All I need to do is define a
traversal_policy_type typedef within my visitor type, define a
has_traversal_policy_type meta-function and use enable_if to select
the specialization I need for my meta-function.
[...] testing [...]
OK, here's the complete solution:
I've created a new meta-function as follows:
namespace Visitors
{
namespace Details
{
typedef struct { char ar[1]; } one_t;
typedef struct { char ar[2]; } two_t;
template < typename T >
one_t has_traversal_policy_type_function(...);
template < typename T >
two_t has_traversal_policy_type_function(typename
T::traversal_policy_type const volatile *);
}
template < typename VisitorType >
struct has_traversal_policy_type : boost::mpl::if_c<
sizeof(Details::has_traversal_policy_type_function< VisitorType >(0))
== sizeof(Details::two_t), boost::true_type, boost::false_type >
{};
template <>
struct has_traversal_policy_type< void > : boost::false_type
{};
}
which is almost exactly the has_value_type meta-function from
"Adapting Interface-Incomplete Types at Compile Time" by Matthew
Wilson, CUJ Nov 1, 2005.
Or you could just use BOOST_MPL_HAS_XXX_TRAIT_DEF
(http://www.boost.org/libs/mpl/doc/refmanual/has-xxx-trait-def.html)
With that, I've adapted my
get_traversal_policy_type meta-function as follows:
namespace Visitors
{
template < typename VisitorType, typename VisiteeType, typename
Enable = void >
struct get_traversal_policy_type
;
template <
typename VisitorType,
typename VisiteeType >
struct get_traversal_policy_type<
typename VisitorType,
typename VisiteeType,
typename boost::enable_if<
typename has_traversal_policy_type< VisitorType >::type >::type
: boost::mpl::identity< typename
VisitorType::traversal_policy_type >
{};
}
which means my visitor's type will only need a "traversal_policy_type"
typedef in order to work. My regression tests for my Visitors
implementation still work, which confirms that the visitor type
doesn't actually need the typedef.
Problem solved, thanks!
Glad to be of service.
--
Dave Abrahams
Boost Consulting
http://www.boost-consulting.com
The Astoria Seminar ==> http://www.astoriaseminar.com
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]