TaskDynamics.h

Go to the documentation of this file.

/*
 * Copyright 2017-2020 CNRS-AIST JRL and CNRS-UM LIRMM
 */
 
#pragma once
 
#include <tvm/defs.h>
 
#include <tvm/graph/abstract/Node.h>
#include <tvm/task_dynamics/abstract/TaskDynamicsImpl.h>
#include <tvm/task_dynamics/enums.h>
 
#include <Eigen/Core>
 
// FIXME add mechanisms for when the function's output is resized
// FIXME Consider the possibility of having variables in task dynamics?
 
namespace tvm
{
 
namespace task_dynamics
{
 
namespace abstract
{
class TVM_DLLAPI TaskDynamics
{
public:
  virtual ~TaskDynamics() = default;
 
  std::unique_ptr<TaskDynamicsImpl> impl(FunctionPtr f, constraint::Type t, const Eigen::VectorXd & rhs) const;
 
  Order order() const;
 
protected:
  virtual std::unique_ptr<TaskDynamicsImpl> impl_(FunctionPtr f,
                                                  constraint::Type t,
                                                  const Eigen::VectorXd & rhs) const = 0;
  virtual Order order_() const = 0;
};
 
} // namespace abstract
 
} // namespace task_dynamics
 
} // namespace tvm
 
#define TASK_DYNAMICS_DERIVED_FACTORY(...)                                                             \
  template<typename Derived, typename... Args>                                                         \
  std::unique_ptr<tvm::task_dynamics::abstract::TaskDynamicsImpl> impl_(                               \
      tvm::FunctionPtr f, tvm::constraint::Type t, const Eigen::VectorXd & rhs, Args &&... args) const \
  { return std::make_unique<Derived>(f, t, rhs, std::forward<Args>(args)..., __VA_ARGS__); }
 
#define TASK_DYNAMICS_DERIVED_FACTORY_Z()                                                              \
  template<typename Derived, typename... Args>                                                         \
  std::unique_ptr<tvm::task_dynamics::abstract::TaskDynamicsImpl> impl_(                               \
      tvm::FunctionPtr f, tvm::constraint::Type t, const Eigen::VectorXd & rhs, Args &&... args) const \
  { return std::make_unique<Derived>(f, t, rhs, std::forward<Args>(args)...); }
 
#define COMPOSABLE_TASK_DYNAMICS_DERIVED_FACTORY(T, ...)                                               \
  template<typename Derived, typename... Args>                                                         \
  std::unique_ptr<tvm::task_dynamics::abstract::TaskDynamicsImpl> impl_(                               \
      tvm::FunctionPtr f, tvm::constraint::Type t, const Eigen::VectorXd & rhs, Args &&... args) const \
  { return T::template impl_<Derived>(f, t, rhs, std::forward<Args>(args)..., __VA_ARGS__); }