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 <map>
#include <memory>
#include <mutex>
#include <set>
#include <string>
#include <vector>
 
#include "yasmin/blackboard/blackboard.hpp"
#include "yasmin/state.hpp"
 
namespace yasmin {

class StateMachine : public State {

  using StartCallbackType = std::function<void(
      std::shared_ptr<yasmin::blackboard::Blackboard>, const std::string &,
      const std::vector<std::string> &)>;
  using TransitionCallbackType = std::function<void(
      std::shared_ptr<yasmin::blackboard::Blackboard>, const std::string &,
      const std::string &, const std::string &,
      const std::vector<std::string> &)>;
  using EndCallbackType = std::function<void(
      std::shared_ptr<yasmin::blackboard::Blackboard>, const std::string &,
      const std::vector<std::string> &)>;
 
public:
  StateMachine(const std::set<std::string> &outcomes);

  StateMachine(const std::string &name, const std::set<std::string> &outcomes);

  ~StateMachine();

  void add_state(const std::string &name, std::shared_ptr<State> state,
                 const std::map<std::string, std::string> &transitions = {},
                 const std::map<std::string, std::string> &remappings = {});

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

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

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

  std::string get_start_state();

  std::map<std::string, std::shared_ptr<State>> const &get_states();

  std::map<std::string, std::map<std::string, std::string>> const &
  get_transitions();

  std::string get_current_state();

  void add_start_cb(StartCallbackType cb,
                    const std::vector<std::string> &args = {});

  void add_transition_cb(TransitionCallbackType cb,
                         const std::vector<std::string> &args = {});

  void add_end_cb(EndCallbackType cb,
                  const std::vector<std::string> &args = {});

  void
  call_start_cbs(std::shared_ptr<yasmin::blackboard::Blackboard> blackboard,
                 const std::string &start_state);

  void call_transition_cbs(
      std::shared_ptr<yasmin::blackboard::Blackboard> blackboard,
      const std::string &from_state, const std::string &to_state,
      const std::string &outcome);

  void call_end_cbs(std::shared_ptr<yasmin::blackboard::Blackboard> blackboard,
                    const std::string &outcome);

  void validate(bool strict_mode = false);

  std::string
  execute(std::shared_ptr<blackboard::Blackboard> blackboard) override;

  std::string execute();

  std::string operator()();
 
  using State::operator();

  void cancel_state() override;

  std::string to_string();
 
private:
  // Name of the state machine (used if this is the root state machine)
  std::string name;
  std::map<std::string, std::shared_ptr<State>> states;
  std::map<std::string, std::map<std::string, std::string>> transitions;
  std::map<std::string, std::map<std::string, std::string>> remappings;
  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::vector<std::pair<StartCallbackType, std::vector<std::string>>> start_cbs;
  std::vector<std::pair<TransitionCallbackType, std::vector<std::string>>>
      transition_cbs;
  std::vector<std::pair<EndCallbackType, std::vector<std::string>>> end_cbs;

  void set_current_state(const std::string &state_name);
};
 
} // namespace yasmin
 
#endif // YASMIN__STATE_MACHINE_HPP