#include <functional>
#include <boost/mpl/vector.hpp>
#include <boost/fsm/state_machine.hpp>
#include <boost/fsm/event.hpp>
#include <boost/fsm/transition.hpp>

namespace mpl = boost::mpl;
namespace fsm = boost::fsm;

struct Attached;
struct Powered;
struct Default;
struct Address;
struct Configured;

typedef mpl::vector<Attached, Powered, Default, Address, Configured>::type StateList;

struct PowerOn;
struct PowerOff;
struct Reset;
struct SetAddress;
struct SetConfiguration;


template<typename SourceT, template<typename> class PredT, typename TargetT>
struct SetAddressTrans: fsm::transition<SourceT, fsm::event<SetAddress, int>, TargetT> {
  static void transit(SourceT& state, fsm::event<SetAddress, int> const& evt) {
    PredT<int> pred;
    if (pred(evt.get<0>(), 0))
      state.template switch_to<TargetT>();
  }
};

template<typename SourceT, template<typename> class PredT, typename TargetT>
struct SetConfigurationTrans: fsm::transition<SourceT, fsm::event<SetConfiguration, int>, TargetT> {
  static void transit(SourceT& state, fsm::event<SetConfiguration, int> const& evt) {
    PredT<int> pred;
    if (pred(evt.get<0>(), 0))
      state.template switch_to<TargetT>();
  }
};

typedef mpl::vector<
  fsm::transition<Attached, fsm::event<PowerOn>, Powered>,
  SetAddressTrans<Default, std::not_equal_to, Address>,
  SetAddressTrans<Address, std::equal_to, Default>,
  SetConfigurationTrans<Address, std::not_equal_to, Configured>,
  SetConfigurationTrans<Configured, std::equal_to, Address>,
  fsm::transition<fsm::any_state, fsm::event<Reset>, Default>,
  fsm::transition<fsm::any_state, fsm::event<PowerOff>, Attached>
>::type Transitions;


struct Common {
  int addr;
  int configuration;

  Common() : addr(0), configuration(0) {}
};

template<typename StateT>
struct UsbState: fsm::state<StateT, StateList>, virtual Common {
  void on_process(fsm::event<SetAddress, int> const& evt) {
    state.addr = evt.get<0>();
  }
  void on_process(fsm::event<SetConfiguration, int> const& evt) {
    state.configuration = evt.get<0>();
  }
  template<typename T>
  void on_process(T const&) {
  }
};

struct Attached: UsbState<Attached> {
};

struct Powered: UsbState<Powered> {
};

struct Default: UsbState<Default> {
};

struct Address: UsbState<Address> {
};

struct Configured: UsbState<Configured> {
};

int main(int, char*[])
{
  fsm::state_machine<StateList> machine;
  machine.process(fsm::make_event<PowerOn>());
  machine.process(fsm::make_event<Reset>());
  machine.process(fsm::make_event<SetAddress>(5));
  machine.process(fsm::make_event<SetConfiguration>(10));
  return 0;
}