State.h

Go to the documentation of this file.

/*
 * Copyright 2015-2020 CNRS-UM LIRMM, CNRS-AIST JRL
 */
 
#pragma once
 
#include <mc_control/fsm/api.h>
#include <mc_control/fsm/states/api.h>
 
#include <mc_solver/ConstraintSet.h>
 
#include <mc_tasks/MetaTask.h>
#include <mc_tasks/PostureTask.h>
 
#include <mc_rtc/Configuration.h>
 
namespace mc_control
{
 
namespace fsm
{
 
struct MC_CONTROL_FSM_DLLAPI Controller;
 
struct MC_CONTROL_FSM_DLLAPI State
{
  virtual ~State() {}
 
  void configure_(const mc_rtc::Configuration & config);
 
  void start_(Controller & ctl);
 
  void teardown_(Controller & ctl);
 
  virtual bool run(Controller & ctl) = 0;
 
  virtual void stop(Controller &) {}
 
  virtual bool read_msg(std::string &) { return false; }
 
  virtual bool read_write_msg(std::string &, std::string &) { return false; }
 
  const std::string & output() const noexcept { return output_; }
 
  const std::string & name() { return name_; }
 
  void name(const std::string & n) { name_ = n; }
 
protected:
  void output(const std::string & o) { output_ = o; }
 
  virtual void configure(const mc_rtc::Configuration & config);
 
  virtual void start(Controller & ctl) = 0;
 
  virtual void teardown(Controller & ctl) = 0;
 
protected:
  mc_rtc::Configuration add_contacts_config_;
  mc_rtc::Configuration remove_contacts_config_;
  mc_rtc::Configuration add_contacts_after_config_;
  mc_rtc::Configuration remove_contacts_after_config_;
  mc_rtc::Configuration add_collisions_config_;
  mc_rtc::Configuration remove_collisions_config_;
  mc_rtc::Configuration add_collisions_after_config_;
  mc_rtc::Configuration remove_collisions_after_config_;
  mc_rtc::Configuration constraints_config_;
  mc_rtc::Configuration tasks_config_;
  mc_rtc::Configuration remove_posture_task_;
  mc_rtc::Configuration config_;
 
  std::vector<mc_solver::ConstraintSetPtr> constraints_;
  std::vector<std::pair<mc_tasks::MetaTaskPtr, mc_rtc::Configuration>> tasks_;
  std::vector<mc_tasks::PostureTaskPtr> postures_;
 
private:
  std::string name_ = "";
  std::string output_ = "";
};
 
using StatePtr = std::shared_ptr<State>;
 
} // namespace fsm
 
} // namespace mc_control
 
/* The following macros are used to simplify the required symbol exports */
 
#ifndef MC_RTC_BUILD_STATIC
 
#  ifdef WIN32
#    define FSM_STATE_API __declspec(dllexport)
#  else
#    if __GNUC__ >= 4
#      define FSM_STATE_API __attribute__((visibility("default")))
#    else
#      define FSM_STATE_API
#    endif
#  endif
 
#  define EXPORT_SINGLE_STATE(NAME, TYPE)                                   \
    extern "C"                                                              \
    {                                                                       \
      FSM_STATE_API void MC_RTC_FSM_STATE(std::vector<std::string> & names) \
      {                                                                     \
        names = {NAME};                                                     \
      }                                                                     \
      FSM_STATE_API void destroy(mc_control::fsm::State * ptr)              \
      {                                                                     \
        delete ptr;                                                         \
      }                                                                     \
      FSM_STATE_API mc_control::fsm::State * create(const std::string &)    \
      {                                                                     \
        return new TYPE();                                                  \
      }                                                                     \
    }
 
#else
 
#  define EXPORT_SINGLE_STATE(NAME, TYPE)                                                              \
    namespace                                                                                          \
    {                                                                                                  \
    static auto registered = []()                                                                      \
    {                                                                                                  \
      using fn_t = std::function<TYPE *()>;                                                            \
      mc_control::fsm::Controller::factory().register_object(NAME, fn_t([]() { return new TYPE(); })); \
      return true;                                                                                     \
    }();                                                                                               \
    }
 
#endif