Hi Alexander
Although my idea is supposed to solve multimethod support for dynamic_any it might be useful in FSM library. What I'm trying to build in last two weeks is some sort of typelists for overloaded function set. Each function is identified by overload_id<N> class with unique N. For example:
struct read_number_transitions { // Signatures has the form NewState (OldState, Char) Positive operator()(overload_id<0>, StartState, Plus) const; Negative operator()(overload_id<1>, StartState, Minus) const; Positive operator()(overload_id<2>, StartState, Digit) const; Positive operator()(overload_id<3>, Positive, Digit) const; Negative operator()(overload_id<4>, Negative, Digit) const;
static std::size_t const max_overload_id = 4; };
This approach has advantage over typelists in some cases because things are right in their places. In the example, every transition, on one hand, is represented by a call operator (this is natural, because transition is a function that takes old state and a char and returns a new state); on the other hand, argument types and return type (a signature) can be retrieved from the call operator.
So far I *think* I understand. You have developed a way how to represent/implement multimethods in C++.
The retrieval is a bit problematic but I'm working on this. The problem is a lack of typeof in C++. If it were available you could write:
template<int N, class C, class R, class T> mpl::identity<R(T)> tester(R (C::*)(overload_id<N>, T) const); typedef typeof(tester<0>(&read_number_transitions::operator()))::type sig0;
Here you lost me, tester does not seem to accept enough parameters. I assume that you'd need another parameter for the event. sig0 seems to have the same problem. I don't exactly grok what follows but I guess it describes how to retrive the right functions given the current state type and an event type. You can then call the function to transition to the new state (the new state is returned). Your mechanism only works with functions declared in a single class, right? While I can see that an FSM framework can be built on top of this mechanism, I think I won't be able to use it in boost::fsm. A state machine implemented in terms of my library can be spread over multiple translation units (this is a key feature). I think your MM implementation (nice idea, BTW) could probably be used in a second FSM library, which is more oriented towards top-notch speed. boost::fsm focuses more on scalability (i.e. minimization of compile times of and dependencies in large FSMs). Regards, Andreas