Executor.h

Go to the documentation of this file.

/*
 * Copyright 2015-2019 CNRS-UM LIRMM, CNRS-AIST JRL
 */
 
#pragma once
 
#include <mc_control/api.h>
#include <mc_control/fsm/State.h>
#include <mc_control/fsm/StateFactory.h>
#include <mc_control/fsm/TransitionMap.h>
 
#include <chrono>
#include <memory>
 
namespace mc_control
{
 
namespace fsm
{
 
struct Controller;
 
struct MC_CONTROL_FSM_DLLAPI Executor
{
  Executor() = default;
  Executor(const Executor &) = delete;
  Executor(Executor &&) = delete;
  Executor & operator=(const Executor &) = delete;
  Executor & operator=(Executor &&) = delete;
 
  void init(Controller & ctl,
            const mc_rtc::Configuration & config,
            const std::string & name = "",
            const std::vector<std::string> & category = {});
 
  bool run(Controller & ctl, bool keep_state);
 
  void stop(Controller & ctl);
 
  void teardown(Controller & ctl);
 
  inline void interrupt() { interrupt_triggered_ = true; }
 
  inline bool running() const { return state_ != nullptr; }
 
  inline bool ready() const { return ready_; }
 
  inline bool complete() const { return complete_; }
 
  bool resume(const std::string & state);
 
  bool next();
 
  const std::string & state() const { return curr_state_; }
 
  const std::string & output() const { return state_output_; }
 
  const std::string & next_state() const { return next_state_; }
 
  bool read_msg(std::string & msg);
 
  bool read_write_msg(std::string & msg, std::string & out);
 
private:
  using duration_ms = std::chrono::duration<double, std::milli>;
  mc_rtc::Configuration config_;
  std::string name_;
  std::vector<std::string> category_;
  bool managed_ = false;
  bool step_by_step_ = true;
  bool reset_postures_ = true;
 
  TransitionMap transition_map_;
 
  StatePtr state_ = nullptr;
  std::string curr_state_ = "";
  std::string state_output_ = "";
 
  bool interrupt_triggered_ = false;
  bool ready_ = true;
  bool transition_triggered_ = false;
  bool complete_ = false;
  std::string next_state_ = "";
 
  duration_ms state_create_dt_{0};
  duration_ms state_run_dt_{0};
  duration_ms state_teardown_dt_{0};
 
private:
  bool complete(Controller & ctl, bool keep_state);
 
  void next(Controller & ctl);
};
 
} // namespace fsm
 
} // namespace mc_control