pybind11.hpp

#ifndef __pinocchio_python_pybind11_hpp__
#define __pinocchio_python_pybind11_hpp__
 
 
#include <iostream>
#include <pinocchio/fwd.hpp>
 
// This lines forces clang-format to keep the include split here
#include <pybind11/pybind11.h>
 
#include <eigenpy/eigenpy.hpp>
 
namespace pinocchio
{
  namespace python
  {
    namespace bp = boost::python;
    namespace py = pybind11;
 
    template<typename T>
    inline py::object to(T & t)
    {
      // Create PyObject using boost Python
      bp::object obj = bp::api::object(t);
      PyObject * pyobj = obj.ptr();
      return pybind11::reinterpret_borrow<py::object>(pyobj);
    }
    template<typename T>
    inline py::object to(T * t)
    {
      // Create PyObject using boost Python
      typename bp::manage_new_object::apply<T *>::type converter;
      PyObject * pyobj = converter(t);
      // Create the Pybind11 object
      return py::reinterpret_borrow<py::object>(pyobj);
    }
 
    template<typename ReturnType>
    inline ReturnType & from(py::handle model)
    {
      return bp::extract<ReturnType &>(model.ptr());
    }
 
    template<typename T>
    struct convert_type
    {
      typedef T type;
      static inline T _to(T t)
      {
        return t;
      }
      static inline type _from(type t)
      {
        return t;
      }
    };
    template<>
    struct convert_type<void>
    {
      // typedef void type;
      // static inline void _to() {}
    };
 
    template<typename T>
    struct convert_boost_python_object
    {
      typedef py::object type;
      static inline type _to(T t)
      {
        return to<typename std::remove_pointer<
          typename std::remove_reference<typename std::remove_cv<T>::type>::type>::type>(t);
      }
      static inline T _from(type t)
      {
        return from<typename std::remove_cv<typename std::remove_reference<T>::type>::type>(t);
      }
    };
 
#define PINOCCHIO_PYBIND11_ADD_CONVERT_TYPE(CLASS)                                                 \
  namespace pinocchio                                                                              \
  {                                                                                                \
    namespace python                                                                               \
    {                                                                                              \
      template<>                                                                                   \
      struct convert_type<CLASS> : convert_boost_python_object<CLASS>                              \
      {                                                                                            \
      };                                                                                           \
    }                                                                                              \
  }
 
#define _SINGLE_ARG(...) __VA_ARGS__
#define PINOCCHIO_PYBIND11_ADD_ALL_CONVERT_TYPE(CLASS)                                             \
  PINOCCHIO_PYBIND11_ADD_CONVERT_TYPE(_SINGLE_ARG(CLASS))                                          \
  PINOCCHIO_PYBIND11_ADD_CONVERT_TYPE(_SINGLE_ARG(CLASS const))                                    \
  PINOCCHIO_PYBIND11_ADD_CONVERT_TYPE(_SINGLE_ARG(CLASS &))                                        \
  PINOCCHIO_PYBIND11_ADD_CONVERT_TYPE(_SINGLE_ARG(CLASS const &))                                  \
  PINOCCHIO_PYBIND11_ADD_CONVERT_TYPE(_SINGLE_ARG(CLASS *))                                        \
  PINOCCHIO_PYBIND11_ADD_CONVERT_TYPE(_SINGLE_ARG(CLASS const *))
 
    namespace internal
    {
 
      template<typename R, typename... Args>
      auto call(R (*f)(Args...), typename convert_type<Args>::type... args)
      {
        return convert_type<R>::_to(f(convert_type<Args>::_from(args)...));
      }
      template<typename... Args>
      void call(void (*f)(Args...), typename convert_type<Args>::type... args)
      {
        f(convert_type<Args>::_from(args)...);
      }
 
      template<typename T>
      struct function_wrapper;
 
      template<typename R, typename... Args>
      struct function_wrapper<R (*)(Args...)>
      {
        static const size_t nargs = sizeof...(Args);
 
        typedef R result_type;
 
        template<size_t i>
        struct arg
        {
          typedef typename std::tuple_element<i, std::tuple<Args...>>::type type;
        };
 
        typedef R (*func_type)(Args...);
 
        func_type f;
 
        // typename convert_type<result_type>::type
        auto operator()(typename convert_type<Args>::type... args)
        {
          return call(f, args...);
        }
      };
    } // namespace internal
 
    template<typename R, typename... Args>
    internal::function_wrapper<R (*)(Args...)> make_pybind11_function(R (*func)(Args...))
    {
      internal::function_wrapper<R (*)(Args...)> wrapper;
      wrapper.f = func;
      return wrapper;
    }
 
    template<typename T>
    py::object default_arg(T t)
    {
      py::object obj = to<T>(t);
      // obj.inc_ref();
      return obj;
    }
 
#define PINOCCHIO_PYBIND11_TYPE_CASTER(native_type, boost_python_name)                             \
  namespace pybind11                                                                               \
  {                                                                                                \
    namespace detail                                                                               \
    {                                                                                              \
      template<>                                                                                   \
      struct type_caster<native_type>                                                              \
      {                                                                                            \
        PYBIND11_TYPE_CASTER(_SINGLE_ARG(native_type), boost_python_name);                         \
                                                                                                   \
        /* Python -> C++ */                                                                        \
        bool load(pybind11::handle src, bool)                                                      \
        {                                                                                          \
          PyObject * source = src.ptr();                                                           \
          value = boost::python::extract<native_type>(source);                                     \
          return !PyErr_Occurred();                                                                \
        }                                                                                          \
        /* C++ -> Python */                                                                        \
        static pybind11::handle cast(                                                              \
          native_type src, pybind11::return_value_policy /*policy*/, pybind11::handle /*parent*/)  \
        {                                                                                          \
          return boost::python::api::object(src).ptr();                                            \
        }                                                                                          \
      };                                                                                           \
    } /* namespace detail */                                                                       \
  } /* namespace pybind11 */
 
  } // namespace python
} // namespace pinocchio
 
#undef _SINGLE_ARG
 
#endif // #ifndef __pinocchio_python_pybind11_hpp__