Реализация базового класса шаблона реализация по умолчанию

Question

Я пытаюсь создать простую шаблонную библиотеку FSM, которая позволила бы: machine.react(Event1{}); вызывать реализацию SomeState.react(std::shared_ptr<StateMachine> machine, Event1 event) без необходимости заранее знать все возможные события, без необходимости реализовывать все и каждое возможное событие для all Производный класс.

Поскольку я вызываю функции из current_state_, сохраненного как тип State, при вызове response (который не является виртуальным) он будет вызывать реализацию Base, а не реализацию класса Derived (State1).

#include <iostream>
#include <memory>
#include <tuple>
#include <typeinfo>
#include <vector>

template <typename ContextT, typename... StatesT>
class MachineT : public std::enable_shared_from_this<MachineT<ContextT, StatesT...>> {
  using M_ = MachineT<ContextT, StatesT...>;

 public:
  using Context = ContextT;
  class State {
   public:
    template <typename EVENT>
    void react(std::shared_ptr<M_> machine, EVENT event) {
      std::cout << "State::react" << std::endl;
    };
    virtual void update(std::shared_ptr<M_> machine) = 0;
  };

  MachineT(std::shared_ptr<ContextT> context)
      : context_(context),
        states_{std::make_shared<StatesT>()...} {
    using FirstEntityType = std::tuple_element_t<0, std::tuple<StatesT...>>;
    set<FirstEntityType>();
  }

  ~MachineT() {}

  template <typename T>
  std::shared_ptr<T> get() {
    return std::get<std::shared_ptr<T>>(states_);
  }

  template <typename T>
  void set() {
    current_state_ = std::get<std::shared_ptr<T>>(states_);
  }

  std::shared_ptr<M_> shared() {
    return this->shared_from_this();
  }

  void update(){
    current_state_->update(shared());
  };

  template <typename EVENT>
  void react(EVENT event){
    current_state_->react(shared(), event);
  };

 private:
  std::shared_ptr<ContextT>               context_;
  std::tuple<std::shared_ptr<StatesT>...> states_;
  std::shared_ptr<State>                  current_state_;
};

struct State1;
struct State2;
struct Context {};
struct Event1 {};

using StateMachine = MachineT<Context, State1, State2>;


struct State1 : public StateMachine::State {
  int  value = 10;
  void print() { std::cout << value << std::endl; }

  void react(std::shared_ptr<StateMachine> machine, Event1 event) {
    std::cout << "State1::react()" << std::endl;
  }
  void update(std::shared_ptr<StateMachine> machine) {
    std::cout << "State1::update()" << std::endl;
  }
};

struct State2 : public StateMachine::State {
  int  value = 20;
  void print() { std::cout << value << std::endl; }
  void react(std::shared_ptr<StateMachine> machine, Event1 event) {
    std::cout << "State2::react()" << std::endl;
  }
  void update(std::shared_ptr<StateMachine> machine) {
    std::cout << "State2::update()" << std::endl;
  }
};

int main() {
  std::shared_ptr<Context> context;
  context.reset(new Context());
  std::shared_ptr<StateMachine> machine;
  machine.reset(new StateMachine(context));
  machine->set<State1>();
  machine->update();
  machine->react(Event1{});
  machine->set<State2>();
  machine->update();
  machine->react(Event1{});
}

Полный Пример: http://cpp.sh/7d37rq

Токовый выход:

State1::update()
State::react()
State2::update()
State::react()

Ожидаемый выход:

State1::update()
State1::react()
State2::update()
State2::react()

Answer 1

Для этого вам понадобится std::variant и сохранить текущее состояние как:

std::variant<std::shared_ptr<StatesT>...> current_state_;

С трейтом для определения, реагирует ли данное состояние на какой-либо тип события:

template <typename State, typename Event, typename = void>
struct can_react : std::false_type {};

template <typename State, typename Event>
struct can_react<State, Event,
    decltype(void(std::declval<State>()->react(nullptr, std::declval<Event>())))>
    : std::true_type {};

Затем вы можете отправить событие в состояние, если оно может его обработать, и отменить в противном случае:

template <typename Event>
void react(Event event) {
    std::visit([&](auto state) {
        if constexpr (can_react<decltype(state), Event>{}) {
            state->react(shared(), event);
        }
    }, current_state_);
} 

Аналогично, update становится:

void update() {
    std::visit([this](auto state) {
        state->update(shared());
    }, current_state_);
}

ДЕМО

---

Полный код:

template <typename ContextT, typename... StatesT>
class MachineT : public std::enable_shared_from_this<MachineT<ContextT, StatesT...>> {
  using M_ = MachineT<ContextT, StatesT...>;

 public:
  using Context = ContextT;

  MachineT(std::shared_ptr<ContextT> context)
      : context_(context),
        states_{std::make_shared<StatesT>()...} {
    using FirstEntityType = std::tuple_element_t<0, std::tuple<StatesT...>>;
    set<FirstEntityType>();
  }

  ~MachineT() {}

  template <typename T>
  std::shared_ptr<T> get() {
    return std::get<std::shared_ptr<T>>(states_);
  }

  template <typename T>
  void set() {
    current_state_ = std::get<std::shared_ptr<T>>(states_);
  }

  std::shared_ptr<M_> shared() {
    return this->shared_from_this();
  }

  void update() {
    std::visit([this](auto state) { state->update(shared()); }, current_state_);
  }

  template <typename State, typename Event, typename = void>
  struct can_react : std::false_type {};

  template <typename State, typename Event>
  struct can_react<State, Event,
      decltype(void(std::declval<State>()->react(nullptr, std::declval<Event>())))>
      : std::true_type {};

  template <typename Event>
  void react(Event event) {
    std::visit([&](auto state) {
      if constexpr (can_react<decltype(state), Event>{}) {
        state->react(shared(), event);
      }
    }, current_state_);
  } 

 private:
  std::shared_ptr<ContextT>                 context_;
  std::tuple<std::shared_ptr<StatesT>...>   states_;
  std::variant<std::shared_ptr<StatesT>...> current_state_;
};

Состояния и события:

struct State1;
struct State2;
struct Context {};
struct Event1 {};
struct Event2 {};

using StateMachine = MachineT<Context, State1, State2>;

struct State1 {    
  void react(std::shared_ptr<StateMachine> machine, Event1 event) {
    std::cout << "State1::react(Event1)" << std::endl;
  }

  void update(std::shared_ptr<StateMachine> machine) {
    std::cout << "State1::update()" << std::endl;
  }
};

struct State2 {            
  void react(std::shared_ptr<StateMachine> machine, Event2 event) {
    std::cout << "State2::react(Event2)" << std::endl;
  }

  void update(std::shared_ptr<StateMachine> machine) {
    std::cout << "State2::update()" << std::endl;
  }
};

Тесты:

int main() {
  std::shared_ptr<Context> context;
  context.reset(new Context());
  std::shared_ptr<StateMachine> machine;
  machine.reset(new StateMachine(context));
  machine->set<State1>();
  machine->update();
  machine->react(Event1{});
  machine->set<State2>();
  machine->update();
  machine->react(Event2{});
}

Вывод:

State1::update()
State1::react(Event1)
State2::update()
State2::react(Event2)

---

Используя c ++ 14 это возможно используя boost::variant:

template <typename Event>
struct Visitor {
    MachineT* machine;
    Event* event;
    template <typename State>
    std::enable_if_t<can_react<State, Event>{}> operator()(State state) const {
        state->react(machine->shared(), *event);
    }
    template <typename State>
    std::enable_if_t<!can_react<State, Event>{}> operator()(State) const {}
};

template <typename Event>
void react(Event event) {
    boost::apply_visitor(Visitor<Event>{ this, &event }, current_state_);
}