The attached testcase doesn't compile with g++ 4.0.2 or g++ 3.2.3. The compiler generates a series of error messages like this: boost/statechart/simple_state.hpp:189: error: no type named 'inner_context_type' in 'struct Test::NormalMode<int>' I hastily sketched this out based on a larger code. If there are typos or other mistakes, let me know but the main problem I'm trying to solve is the "no type named" problem. I typedef it right in the template definition for NormalMode! This is using the current CVS for statechart, 1.33.1 for mpl. Is it possibly a compiler bug? Thanks! -Dave ---------------- Testcase #include #include #include #include #include #include #include #include <iostream> // Switch finite state machine for multiplexor schedule policy namespace Test { namespace sc = boost::statechart; namespace mpl = boost::mpl; // Inner states template <typename Type> struct On; template <typename Type> struct Off; template <typename Type> struct Error; // Outer states template <typename Type> struct NormalMode; template <typename Type> struct ErrorMode; // Events struct End : public sc::event<End> {}; struct UnconsumedEvent : public sc::event<UnconsumedEvent> { std::string st; UnconsumedEvent(const std::string &s) : st(s) {}; const std::string &state(void) const { return(st); }; }; template struct SwitchEvent : public sc::event<Derived> { typedef Type value_type; value_type ev; SwitchEvent(value_type e) : ev(e) {}; value_type value(void) const { return(ev); } }; template<typename Type> struct TurnOn : public SwitchEvent { TurnOn(Type value) : SwitchEvent(value) {}; }; template<typename Type> struct TurnOff : public SwitchEvent { TurnOff(Type value) : SwitchEvent(value) {}; }; template<typename Type> struct Switch; namespace detail { template<typename Type> struct typedefs { typedef Type value_type; typedef Switch switch_context; typedef TurnOn turn_on; typedef TurnOff turn_off; typedef On on; typedef Off off; }; }; // The state machine template<typename Type> struct Switch : public sc::state_machine, public detail::typedefs<Type> { typedef sc::state_machine Base; typedef Switch<Type> This; std::string state(void) const { if (this->template state_cast()) { return("ON"); } else if (this->template state_cast()) { return("OFF"); } else { std::cerr << "Unknown state" << std::endl; std::abort(); return("ERROR"); } }; // Abort on unexpected events void unconsumed_event(const sc::event_base &event) { std::cerr << "Unexpected event in state " << state() << std::endl; std::abort(); this->post_event(new UnconsumedEvent(state())); }; }; // Define states // Outer template<typename Type> struct NormalMode : public sc::simple_state, public detail::typedefs<Type> { typedef sc::simple_state state_base; typedef typename state_base::inner_context_type inner_context_type; }; template<typename Type> struct ErrorMode : public sc::simple_state, public detail::typedefs<Type> { typedef sc::simple_state state_base; typedef typename state_base::inner_context_type inner_context_type; }; // Inner template<typename Type> struct Off : public sc::simple_state, public detail::typedefs<Type> { typedef Off<Type> This; typedef mpl::list< sc::custom_reaction<typename This::on>, sc::custom_reaction<End> > reactions; sc::result react(const typename This::on &) { this->template context<typename This::switch_context>().transit("OFF", "ON"); return(this->template transit<typename This::on>()); }; sc::result react(const End &) { this->terminate(); }; }; template<typename Type> struct On : public sc::simple_state, public detail::typedefs<Type> { typedef On<Type> This; typedef mpl::list< sc::custom_reaction<typename This::off>, sc::custom_reaction<End> > reactions; sc::result react(const typename This::off &) { this->template context<typename This::switch_context>().transit("ON", "OFF"); return(this->template transit<typename This::off>()); }; sc::result react(const End &) { this->terminate(); }; }; template<typename Type> struct Error : sc::simple_state, public detail::typedefs<Type> { }; }; int main(void) { Test::Switch<int> machine; machine.initiate(); machine.process_event( Test::TurnOn<int>(0) ); std::cout << "Now in state " << machine.state() << std::endl; machine.process_event( Test::TurnOff<int>(0) ); std::cout << "Now in state " << machine.state() << std::endl; machine.process_event( Test::TurnOff<int>(0) ); // Should produce error std::cout << "Now in state " << machine.state() << std::endl; machine.process_event( Test::End() ); }