Hello everybody. I have a problem similar to the one described in the Statechart tutorial, but a little different. My state machine has two states (let's call them A and B) in the different state hierarchies and a third state C that can be transited to from either A or B. The transition from C must be done to either A or B, depending on where we came to C from. So I've decided to use the history. The difference between this problem and what's described in the tutorial is that A and B don't belong to the same composite state (they only belong to the same state machine). I can't simply declare "has_xxx_history" in the outer state like it's done in the tutorial. Here's what I've tried to do: #include <iostream> #include <boost/statechart/shallow_history.hpp> #include <boost/statechart/simple_state.hpp> #include <boost/statechart/state_machine.hpp> #include <boost/statechart/transition.hpp> namespace sc = boost::statechart; // events struct transfer_to_B : sc::event<transfer_to_B> {}; struct visit_C : sc::event<visit_C> {}; struct exit_to_history : sc::event<exit_to_history> {}; // forward declarations struct state_A; struct substate_A; struct substate_B; struct state_C; // state machine struct test_fsm : sc::state_machine<test_fsm, state_A> {}; // composite state A struct state_A : sc::simple_state<state_A, test_fsm, substate_A, sc::has_shallow_history> {}; struct substate_A : sc::simple_state<substate_A, state_A> { typedef boost::mpl::list < sc::transition<transfer_to_B, substate_B> , sc::transition<visit_C, state_C> > reactions; substate_A() { std::cout << "Entered A" << std::endl; } ~substate_A() { std::cout << "Exited A" << std::endl; } }; // composite state B struct state_B : sc::simple_state<state_B, test_fsm, substate_B, sc::has_shallow_history> {}; struct substate_B : sc::simple_state<substate_B, state_B> { typedef sc::transition<visit_C, state_C> reactions; substate_B() { std::cout << "Entered B" << std::endl; } ~substate_B() { std::cout << "Exited B" << std::endl; } }; // simple state C struct state_C : sc::simple_state<state_C, test_fsm> { typedef sc::transition < exit_to_history, sc::shallow_history<substate_A> > reactions; state_C() { std::cout << "Entered C" << std::endl; } ~state_C() { std::cout << "Exited C" << std::endl; } }; int main() { test_fsm fsm; fsm.initiate(); fsm.process_event(visit_C()); fsm.process_event(exit_to_history()); fsm.process_event(transfer_to_B()); fsm.process_event(visit_C()); fsm.process_event(exit_to_history()); } Unfortunately, this doesn't work as intended. The transition to history always leads to substate_A and never to substate_B: Entered A Exited A Entered C Exited C Entered A Exited A Entered B Exited B Entered C Exited C Entered A Exited A Can anyone please clarify if I've got something wrong or made a mistake somewhere? Is history supposed to work in the different state hierarchies?