Повторение выполнения блока кода

enum class States { success, state1, state2 };

void updateDevice(States& state) {
    // Вызываем нужные действия. Если успешно, то меняем state на States::success или другое нужное состояние, иначе оставляем без изменений.
    cout << "Succesfully updated from state " << (int)state << " to state " << (int)States::success << endl;
    state = States::success;
}

int main() {
    States state = States::state1;
    while(state != States::success) {
        switch(state) {
            case States::state1:
                updateDevice(state);
                break;
            case States::state2:
                cout << "Unimplemented!" << endl;
                state = States::success;
                break;
            case States::success:
            default:
                break;
        }
    }
}

# дано
# state - некоторое глобальное состояние
# action - параметры вызываемого действия

if action.type == "withdraw":
  if state.balance > action.data.amount:
    apply_withdrawal(state, action)
  else:
    raise InsufficientBalance(state, action)

if action.type == "deposit":
  if state.user.is_active:
    show_cashier()
  else:
    raise InactiveAccount(state.user)

def apply_action_alpha(state, action):
  # ...

def apply_action_beta(state, action):
  # ...

def apply_action_third(state, action):
  # ...

routes = { # таблица "маршрутизации" управлением выполнения в зависимости от типа действия (расширяемый иф-кейс, как-раз твой случай)
  "deposit": apply_action_first,
  "withdrawal": apply_action_second,
  "activation": apply_action_third,
  "nop": lambda state, action: raise Exception("NOP")
}

def apply_action(state, action):
  handle = action.type in routes and routes[action.type] or routes["nop"]
  return handle(state, action)

def action1(state, action):
  if action.type == "type1":
    state["value1"] = get_type1_result(action)

def action2(state, action):
  if action.type == "type2":
    state["value2"] = get_type2_value(action)

actions = [action1, action2]

def dispatch(state, action):
  for action in actions:
    action(state, action) # здесь действие само решает по состоянию и объекту события, ответственно ли оно за обработку запроса или нет

class state
{
public:
  virtual ~state();

  virtual void on_enter();
  virtual void on_exit();
  virtual void on_recv_frame();
  virtual void on_t0_timeout();
  virtual void on_t1_timeout();
};

class state1: public state
{
/* custom code */
};

class state2: public state
{
/* custom code */
};

class machine
{
  //Many, many states 
  state1 s1;
  state2 s2;
  state3 s3;
  state4 s4;
  state5 s5;
  state6 s6;

  state* s_curr;

  void init()
  {
     s_curr=&s1;
  }

  inline void switch_state(state* s)
  {
    s_curr->on_exit();
    s_curr=s;
    s_curr->on_enter();
  }

  //Events
  void on_recv_frame()
  {
    s_curr->on_recv_frame();
  }
  void on_t0_timeout()
  {
    s_curr->on_t0_timeout();
  }
  void on_t1_timeout()
  {
    s_curr->on_t1_timeout();
  }
};

class machine;

class state
{
private:
  machine* owner;
public:
  state(machine* _owner)
    :owner(_owner)
  {
  }
/* ... */
};

class state1 : public state
{
public:
   state1(machine* _owner)
     :state(_owner)
   {
   }
};


class machine
{
public:
  state1 s1;
  state1 s2;
  state1 s3;
  state1 s4;

  machine()
    :s1(this),
     s2(this),
     s3(this),
     s4(this)
  {
  }
};