state_machine.hpp

Go to the documentation of this file.

// Copyright (C) 2023 Miguel Ángel González Santamarta
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
#ifndef YASMIN__STATE_MACHINE_HPP_
#define YASMIN__STATE_MACHINE_HPP_
 
#include <atomic>
#include <condition_variable>
#include <functional>
#include <mutex>
#include <string>
#include <vector>
 
#include "yasmin/blackboard.hpp"
#include "yasmin/state.hpp"
#include "yasmin/state_machine_cancel_exception.hpp"
 
namespace yasmin {

class StateMachine : public State {
 
public:
  using StartCallbackType =
      std::function<void(Blackboard::SharedPtr, const std::string &)>;
  using TransitionCallbackType =
      std::function<void(Blackboard::SharedPtr, const std::string &,
                         const std::string &, const std::string &)>;
  using EndCallbackType =
      std::function<void(Blackboard::SharedPtr, const std::string &)>;

  YASMIN_PTR_ALIASES(StateMachine)
 
  
  StateMachine(const Outcomes &outcomes, bool handle_sigint = false);

  StateMachine(const std::string &name, const Outcomes &outcomes,
               bool handle_sigint = false);

  ~StateMachine();

  void add_state(const std::string &name, State::SharedPtr state,
                 const Transitions &transitions = {},
                 const Remappings &remappings = {},
                 const ParameterMappings &parameter_mappings = {});

  void set_name(const std::string &name) { this->name = name; }

  const std::string &get_name() const noexcept { return this->name; }

  void set_start_state(const std::string &state_name);

  std::string const &get_start_state() const noexcept;

  StateMap const &get_states() const noexcept;

  TransitionsMap const &get_transitions() const noexcept;

  std::string const &get_current_state() const;

  void add_start_cb(StartCallbackType cb);

  void add_transition_cb(TransitionCallbackType cb);

  void add_end_cb(EndCallbackType cb);

  void set_parameter_mappings(const std::string &state_name,
                              const ParameterMappings &parameter_mappings);

  const ParameterMappingsMap &get_parameter_mappings() const noexcept;

  void validate(bool strict_mode = false);

  void configure() override;
 
  std::string execute(Blackboard::SharedPtr blackboard) override;

  std::string execute();

  std::string operator()();
 
  // Use the base class operator()
  using State::operator();

  void cancel_state() override;

  void cancel_state_machine();

  void set_sigint_handler(bool handle = true);

  std::string to_string() const override;
 
private:
  // Name of the state machine (used if this is the root state machine)
  std::string name;

  StateMap states;
  TransitionsMap transitions;
  RemappingsMap remappings;
  ParameterMappingsMap parameter_mappings;

  std::string start_state;
  std::string current_state;
  std::unique_ptr<std::mutex> current_state_mutex;
  std::condition_variable current_state_cond;

  std::atomic_bool validated{false};
  std::atomic_bool configured{false};
  std::atomic_bool execution_active{false};
  std::atomic_bool cancel_state_machine_requested{false};

  std::vector<StartCallbackType> start_cbs;
  std::vector<TransitionCallbackType> transition_cbs;
  std::vector<EndCallbackType> end_cbs;

  void set_current_state(const std::string &state_name);

  void apply_parameter_mappings(const std::string &state_name,
                                const State::SharedPtr &state);

  void call_start_cbs(Blackboard::SharedPtr blackboard,
                      const std::string &start_state);

  void call_transition_cbs(Blackboard::SharedPtr blackboard,
                           const std::string &from_state,
                           const std::string &to_state,
                           const std::string &outcome);

  void call_end_cbs(Blackboard::SharedPtr blackboard,
                    const std::string &outcome);

  static Remappings compose_remappings(const Remappings &parent_remappings,
                                       const Remappings &state_remappings);

  std::string wait_for_current_state();

  void throw_if_cancel_state_machine_requested();
};
 
} // namespace yasmin
 
#endif // YASMIN__STATE_MACHINE_HPP_