Hi Tobias! On 9/3/07, Tobias Schwinger <tschwinger@isonews2.com> wrote:
Hi Dean,
Dean Michael Berris wrote:
Though it is interesting -- I've been playing around with the idea of an overloaded type-safe dispatcher for some time, but I never got to thinking of a way to accomplish it in a clean manner. Basically something that will allow the following:
<code>
Seems like a job for 'fusion::map'...
Yes, it definitely looks like that to me. Time to brush up on fusion again, seems I have been out of that template metaprogramming world for quite a while now...
Perhaps it might be doable, even with the current code I already have there but Real Life (TM) and not enough interest (or utility) from the community really bars me from doing much about it. Maybe when Real Life (TM) lets up, I might come around to allowing this.
A very interesting thing related to your work would be to have "Interfaces with Reflection"
http://tinyurl.com/58koc (see "Future Directions")
. That library is not making any noticeable progress since quite some time now. What is there might still be too complicated at places, but the ideas in it are very hot. I bet you'll get good feedback from the community for bringing something like that up for review...
This is definitely interesting... I'll try to take a dive in, but basically one thing missing from my current dispatcher implementation is the ability to register functions of different signatures to which a separate type can be "self-registered" to. I'm likening this to something like: struct foo_type { template <class dispatcher_type> explicit foo_type (dispatcher_type & dispatcher_) { dispatcher_["one"] = boost::bind(&foo_type::one, this, _1); dispatcher_["one"] = boost::bind(&foo_type::one, this, _1, _2); }; void one(int) { }; void one(int, int) { }; }; // ... somewhere in main dispatcher< signatures<void(int), void(int, int)>, string > d; foo_type instance(d); find<void(int, int)>(instance)["one"](1, 1); find<void(int)>(instance)["one"](1); There might be a less cryptic way, but that's what I'm looking to implement soon -- which should be pretty close to Interfaces with Reflection. Interesting indeed.
Another thing that you might find interesting: You know the Fusion functional module, don't you?
I can't say I know it very well (yet), but I'm definitely going to go try and look at this really soon.
It sorta emulates variadic templates and RValue references in C++98 (where Fusion Sequences are analog to the 'va_list' with C varargs) and allows calling functions / function objects with Tuples for their argument lists. It makes generic callback (and "callforth") facilities very easy to implement, as shown by the cookbook recipe implementing 'bind' in less than 150 LOC and with neither repetitive code nor preprocessor metaprogramming:
Nice! This is definitely interesting. I'm going to have a hand at "fusion-izing" the dispatcher implementation pretty soon. Thanks for the pointers, I'll definitely look into these. -- Dean Michael C. Berris http://cplusplus-soup.blogspot.com/ mikhailberis AT gmail DOT com +63 928 7291459