Dear Boost experts, I'm trying to find a solution to the following problem. I'm iterating over an MPL sequence and once I found the appropriate type in the sequence I call a static function that returns a pointer to a newly created object that I need to return to the caller of the ModelDispatcher::parse member function with its exact type. In other words I need to propagate the exact type of the object created somewhere in a recursive chain of function calls back to the original caller. Unfortunately I can't figure out how to specify the return type of this recursive function. Every type in the sequence has the following form: struct sequence_item { typedef the_real_type type ; static the_real_type *parse( const QDomElement & ) ; } ; The code for iterating over the sequence is the following: template < typename It, typename End > ?? *dispatchM( const QDomElement &, mpl::true_ /* endofvec */ ) { return 0 ; } template < typename It, typename End > ?? *dispatchM( const QDomElement &element, mpl::false_ ) { typedef typename mpl::deref< It >::type MapEntry ; if ( element.tagName() == MapEntry::first::name() ) { // return type is MapEntry::second::type return MapEntry::second::parse( element ) ; } else { typedef typename mpl::next< It >::type Next ; return dispatchM< Next, End >( element, typename boost::is_same< Next, End >::type() ) ; } } template < typename ModelMap > struct ModelDispatcher { static ?? *parse( const QDomElement &element ) { mpl::false_ f ; return dispatchM< typename mpl::begin< ModelMap >::type, typename mpl::end< ModelMap >::type >( element, f ) ; } } ; Thanks a lot for your help. Istvan
Every type in the sequence has the following form:
struct sequence_item { typedef the_real_type type ; static the_real_type *parse( const QDomElement & ) ; } ;
The code for iterating over the sequence is the following:
template < typename It, typename End > ?? *dispatchM( const QDomElement &, mpl::true_ /* endofvec */ ) { return 0 ; }
template < typename It, typename End > ?? *dispatchM( const QDomElement &element, mpl::false_ ) { typedef typename mpl::deref< It >::type MapEntry ; if ( element.tagName() == MapEntry::first::name() )
The above line means that you figure out the correct type in *run-time*, don't you? But the result type must be known in compile-time.
on Mon Oct 10 2011, Igor R <boost.lists-AT-gmail.com> wrote:
Every type in the sequence has the following form:
struct sequence_item { typedef the_real_type type ; static the_real_type *parse( const QDomElement & ) ; } ;
The code for iterating over the sequence is the following:
template < typename It, typename End > ?? *dispatchM( const QDomElement &, mpl::true_ /* endofvec */ ) { return 0 ; }
template < typename It, typename End > ?? *dispatchM( const QDomElement &element, mpl::false_ ) { typedef typename mpl::deref< It >::type MapEntry ; if ( element.tagName() == MapEntry::first::name() )
The above line means that you figure out the correct type in *run-time*, don't you? But the result type must be known in compile-time.
Yeah, as long as you're doing that with a runtime test, your only option is to use some kind of type erasure (boost::any, polymorphic base class, etc). If you are stuck with a runtime test, you might consider passing in a function object to handle whatever was going to be done at the outer level with full knowledge of the types. -- Dave Abrahams BoostPro Computing http://www.boostpro.com
on Mon Oct 10 2011, Igor R <boost.lists-AT-gmail.com> wrote:
Yeah, as long as you're doing that with a runtime test, your only option is to use some kind of type erasure (boost::any, polymorphic base class, etc).
Or Boost.Variant.
(which is what I meant by etc.) I think if you are going to use type erasure, Igor's suggestion is probably the approach most suited to a metaprogrammed system. -- Dave Abrahams BoostPro Computing http://www.boostpro.com
On Mon, Oct 10, 2011 at 11:49 PM, Dave Abrahams <dave@boostpro.com> wrote:
on Mon Oct 10 2011, Igor R <boost.lists-AT-gmail.com> wrote:
Yeah, as long as you're doing that with a runtime test, your only option is to use some kind of type erasure (boost::any, polymorphic base class, etc).
Or Boost.Variant.
(which is what I meant by etc.)
I think if you are going to use type erasure, Igor's suggestion is probably the approach most suited to a metaprogrammed system.
Thank you for your suggestions. It seems that one way or the other I'll have to bite the bullet and use (at least partially) a more traditional approach in my application. It all started when I saw that to avoid duplicating information among my classes I created a complex inheritance hierarchy. I didn't like it and I decided to try using some generative programming techniques to build my classes at compile-time. So far so good but then I was facing all kind of other problems like how to store these heterogeneous objects in containers or, like in the example above, mix run-time and compile-time tests...
on Tue Oct 11 2011, Istvan Buki <buki.istvan-AT-gmail.com> wrote:
Thank you for your suggestions.
It seems that one way or the other I'll have to bite the bullet and use (at least partially) a more traditional approach in my application. It all started when I saw that to avoid duplicating information among my classes I created a complex inheritance hierarchy. I didn't like it and I decided to try using some generative programming techniques to build my classes at compile-time. So far so good but then I was facing all kind of other problems like how to store these heterogeneous objects in containers or, like in the example above, mix run-time and compile-time tests...
Well, boost::variant is very well-suited to these problems. -- Dave Abrahams BoostPro Computing http://www.boostpro.com
participants (3)
-
Dave Abrahams -
Igor R -
Istvan Buki