pybind11.hpp

Go to the documentation of this file.

#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 <boost/python.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__