#include <boost/mpl/arg.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/for_each.hpp>

#include <boost/ref.hpp>
#include <boost/variant/get.hpp>
#include <boost/variant/variant.hpp>

#include <boost/type_traits/add_pointer.hpp>

#include <iostream>

struct Active {};
struct Stopped : Active {};
struct Running : Active {};

struct EvStartStop {};
struct EvReset {};

template<class Fsm, class Event>
struct process_event_fn
{
    Fsm&        m_fsm;
    Event&      m_event;
    mutable int m_counter;

    process_event_fn(Fsm& fsm, Event& event)
        : m_fsm(fsm)
        , m_event(event)
        , m_counter(0)
    {}

    template<class State>
    void operator()(State*) const
    {
        if(m_counter == m_fsm.m_states.which())
        {
            m_fsm.m_states = m_fsm(boost::get<State>(m_fsm.m_states), m_event);
            throw 0;
        }
        ++m_counter;
    }
};

struct Fsm
{
    typedef boost::mpl::vector<Stopped,Running> states;
    typedef boost::make_variant_over<states>::type state_variant;

    state_variant m_states;

    template<class InitialState>
    Fsm(InitialState state) : m_states(state) {}

    Stopped operator()( Running, EvStartStop )
    {
        std::cout << "Running --> (EvStartStop) --> Stopped\n";
        return Stopped();
    }

    Running operator()( Stopped, EvStartStop )
    {
        std::cout << "Stopped --> (EvStartStop) --> Running\n";
        return Running();
    }

    Stopped operator()( Active, EvReset )
    {
        std::cout << "Active --> (EvReset) --> Stopped\n";
        return Stopped();
    }

    template<class Event>
    void process_event(Event event)
    {
        using namespace boost::mpl;

        try
        {
            process_event_fn<Fsm,Event> fn(*this, event);
            boost::mpl::for_each<states, boost::add_pointer<_1> >(boost::ref(fn));
        }
        catch(int) {}
    }
};

int main()
{
    Stopped initial;
    EvReset evReset;
    EvStartStop evStartStop;

    Fsm fsm(initial);

    fsm.process_event(evStartStop);
    fsm.process_event(evReset);

    fsm.process_event(evStartStop);
    fsm.process_event(evStartStop);
    fsm.process_event(evReset);
}