c++の状態遷移ライブラリ調査

/**
 * @file statemachine.hpp
 * @brief
 */
#ifndef STATEMACHINE
#define STATEMACHINE

#include <assert.h>
// Configure optional HFSM2 functionality using #defines
// (in this case we're using Plans to make transition cycle more straightforward):
#define HFSM2_ENABLE_PLANS

// Include HFSM2 header:
#include "hfsm2/machine.hpp"

////////////////////////////////////////////////////////////////////////////////
// Define interface class between the state machine and its host
// (also ok to use the host object itself):
struct Context
{
  bool powerOn;
};

// (Optional) Define type config:
using Config = hfsm2::Config::ContextT<Context>;

// (Optional, recommended) Definehfsm2::Machine for convenience:
using M = hfsm2::MachineT<Config>;

//------------------------------------------------------------------------------

// Declare state machine structure.
// States need to be forward declared, e.g. with a magic macro:
#define S(s) struct s

using FSM = M::PeerRoot<S(Start),              // initial top-level state
                        M::Composite<S(Do),    // sub-machine region with a head state (On) and and 3 sub-states
                                     S(Sub1),  // initial sub-state of the region
                                     S(Sub2), S(Sub3)>,
                        S(End)>;

#undef S

// namespace test
// {
// class statemachine
// {
//------------------------------------------------------------------------------

// While HFSM2 transitions aren't event-based,
// events can be used to have FSM react to external stimuli:
struct Event
{
};

//------------------------------------------------------------------------------

// Define states and override required state methods:
struct Start : FSM::State
{
  void entryGuard(FullControl& control) noexcept
  {                                 // called before state activation, use to re-route transitions
    if (control.context().powerOn)  // access shared data
      control.changeTo<Do>();       // initiate a transition into 'On' region
  }
};

struct Do : FSM::State
{
  void enter(PlanControl& control) noexcept
  {                              // called on state activation
    auto plan = control.plan();  // access the plan for the region

    plan.change<Sub1, Sub2>();  // sequence plan steps, executed when the previous state succeeds
    plan.change<Sub2, Sub3>();
  }

  void exit(PlanControl& /*control*/) noexcept
  {
  }  // called on state deactivation

  void planSucceeded(FullControl& control) noexcept
  {  // called on the successful completion of all plan steps
    control.changeTo<End>();
  }

  void planFailed(FullControl& /*control*/) noexcept
  {
  }  // called if any of the plan steps fails
};
struct Sub1 : FSM::State
{
  void update(FullControl& control) noexcept
  {                     // called on periodic state machine updates
    control.succeed();  // notify successful completion of the plan step
  }                     // plan will advance to the 'Yellow' state
};

struct Sub2 : FSM::State
{
  void update(FullControl& control) noexcept
  {
    control.succeed();  // plan will advance to the 'Green' state on the first entry
                        // and 'Red' state on the second one
  }
};

struct Sub3 : FSM::State
{
  void react(const Event&, FullControl& control) noexcept
  {                     // called on external events
    control.succeed();  // advance to the next plan step
  }
};
struct End : FSM::State
{
};

// public:
void set()
{
  Context context;
  context.powerOn = true;
  FSM::Instance fsm{ context };
}
// };
// }  // namespace test
#endif