ControllerFactory.hpp

#pragma once
 
#include "controllers/IController.hpp"
#include "controllers/ControllerType.hpp"
#include "robot_model/Model.hpp"
 
#include "state_representation/space/cartesian/CartesianState.hpp"
#include "state_representation/space/joint/JointState.hpp"
 
namespace controllers {
 
template<class S>
class ControllerFactory {
public:
 
  static std::shared_ptr<IController<S>> create_controller(CONTROLLER_TYPE type, unsigned int dimensions = 6);
 
  static std::shared_ptr<IController<S>> create_controller(
      CONTROLLER_TYPE type, const std::list<std::shared_ptr<state_representation::ParameterInterface>>& parameters,
      unsigned int dimensions = 6
  );
 
  static std::shared_ptr<IController<S>> create_controller(
      CONTROLLER_TYPE type, const robot_model::Model& robot_model
  );
 
  static std::shared_ptr<IController<S>> create_controller(
      CONTROLLER_TYPE type, const std::list<std::shared_ptr<state_representation::ParameterInterface>>& parameters,
      const robot_model::Model& robot_model
  );
};
 
template<class S>
std::shared_ptr<IController<S>> ControllerFactory<S>::create_controller(CONTROLLER_TYPE type, unsigned int dimensions) {
  std::list<std::shared_ptr<state_representation::ParameterInterface>> parameters;
  return ControllerFactory<S>::create_controller(type, parameters, dimensions);
}
 
template<class S>
std::shared_ptr<IController<S>>
ControllerFactory<S>::create_controller(CONTROLLER_TYPE type, const robot_model::Model& robot_model) {
  std::list<std::shared_ptr<state_representation::ParameterInterface>> parameters;
  return ControllerFactory<S>::create_controller(type, parameters, robot_model);
}
 
typedef ControllerFactory<state_representation::CartesianState> CartesianControllerFactory;
typedef ControllerFactory<state_representation::JointState> JointControllerFactory;
 
}// namespace controllers