pars::app::state_machine< state_t > Struct Template Reference

#include <state_machine.h>

Public Types
using	state_type = state_t

Public Member Functions
	state_machine (state_type s)
void	ensure (std::initializer_list< state_type > expected)
void	ensure (state_type s)
void	next (state_type s)
void	rollback ()
void	commit ()
state_tx< state_type >	tx (state_type to_state)
state_tx< state_type >	tx (state_type from_state, state_type to_state)
state_tx< state_type >	tx (std::initializer_list< state_type > from_states, state_type to_state)
state_type	current () const
void	reset ()

Detailed Description

template<typename state_t>
struct pars::app::state_machine< state_t >

Definition at line 82 of file state_machine.h.

Member Typedef Documentation

state_type

template<typename state_t>

using pars::app::state_machine< state_t >::state_type = state_t

Definition at line 84 of file state_machine.h.

Constructor & Destructor Documentation

state_machine()

template<typename state_t>

pars::app::state_machine< state_t >::state_machine ( state_type s )

inline

Definition at line 86 of file state_machine.h.

    : state_m{s}
  {
  }

Member Function Documentation

commit()

template<typename state_t>

void pars::app::state_machine< state_t >::commit ( )

inline

Definition at line 139 of file state_machine.h.

  {
    if (!next_m)
      throw std::runtime_error("Commit while no transition!");
 
    pars::debug(SL, lf::app, "Commit transition from \"{}\" to \"{}\"", state_m,
                *next_m);
 
    state_m = *next_m;
 
    next_m.reset();
  }

References pars::app, pars::debug(), and SL.

Here is the call graph for this function:

current()

template<typename state_t>

state_type pars::app::state_machine< state_t >::current ( ) const

inline

Definition at line 172 of file state_machine.h.

{ return state_m; }

ensure() [1/2]

template<typename state_t>

void pars::app::state_machine< state_t >::ensure ( state_type s )

inline

Definition at line 110 of file state_machine.h.

  {
    if (state_m != s)
      throw std::runtime_error(
        std::format("Wrong State \"{}\" [must be \"{}\"]", state_m, s));
  }

ensure() [2/2]

template<typename state_t>

void pars::app::state_machine< state_t >::ensure ( std::initializer_list< state_type > expected )

inline

Definition at line 91 of file state_machine.h.

  {
    for (const auto& e : expected)
      if (e == state_m)
        return;
 
    std::string states_str;
 
    for (const auto& e : expected)
      if (e != *expected.end())
        states_str += std::format("{},", e);
      else
        states_str += std::format("{}", e);
 
    throw std::runtime_error(
      std::format("Wrong State {} [must be in \"{}\"]", state_m,
                  std::string_view{states_str.begin(), states_str.end() - 1}));
  }

Referenced by tx(), and tx().

Here is the caller graph for this function:

next()

template<typename state_t>

void pars::app::state_machine< state_t >::next ( state_type s )

inline

Definition at line 117 of file state_machine.h.

  {
    if (next_m)
      throw std::runtime_error("Another transition in progress!");
 
    pars::debug(SL, lf::app, "Start transition from \"{}\" to \"{}\"", state_m,
                s);
 
    next_m = s;
  }

References pars::app, pars::debug(), and SL.

Referenced by pars::app::state_tx< state_t >::state_tx().

Here is the call graph for this function:

Here is the caller graph for this function:

reset()

template<typename state_t>

void pars::app::state_machine< state_t >::reset ( )

inline

Definition at line 174 of file state_machine.h.

  {
    pars::debug(SL, lf::app, "Reset State to \"{}\" [was \"{}\"]",
                state_type::INITIALIZING, state_m);
 
    state_m = state_type::INITIALIZING;
  }

References pars::app, pars::debug(), and SL.

Here is the call graph for this function:

rollback()

template<typename state_t>

void pars::app::state_machine< state_t >::rollback ( )

inline

Definition at line 128 of file state_machine.h.

  {
    if (!next_m)
      throw std::runtime_error("Rollback while no transition!");
 
    pars::debug(SL, lf::app, "Rollback transition from \"{}\" to \"{}\"",
                state_m, *next_m);
 
    next_m.reset();
  }

References pars::app, pars::debug(), and SL.

Here is the call graph for this function:

tx() [1/3]

template<typename state_t>

state_tx< state_type > pars::app::state_machine< state_t >::tx ( state_type from_state, state_type to_state )

inline

Definition at line 157 of file state_machine.h.

  {
    ensure(from_state);
 
    return state_tx(*this, to_state);
  }

References ensure().

Here is the call graph for this function:

tx() [2/3]

template<typename state_t>

state_tx< state_type > pars::app::state_machine< state_t >::tx ( state_type to_state )

inline

Definition at line 152 of file state_machine.h.

  {
    return state_tx(*this, to_state);
  }

tx() [3/3]

template<typename state_t>

state_tx< state_type > pars::app::state_machine< state_t >::tx ( std::initializer_list< state_type > from_states, state_type to_state )

inline

Definition at line 164 of file state_machine.h.

  {
    ensure(from_states);
 
    return state_tx(*this, to_state);
  }

References ensure().

Here is the call graph for this function:

---

The documentation for this struct was generated from the following file:

• /home/runner/work/pars-cxx/pars-cxx/lib/include/pars/app/state_machine.h