Merge pull request #417 from jcarpent/topic/std-pair

Add support of std::pair

Author: jcarpent

CHANGELOG.md

@@ -8,6 +8,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ### Added
 - Support for C++11 `std::array` types ([#412](https://github.com/stack-of-tasks/pull/412))
+- Support for `std::pair` types ([#417](https://github.com/stack-of-tasks/pull/417))
 
 ## [3.1.4] - 2023-11-27
 

CMakeLists.txt

@@ -164,6 +164,7 @@ set(${PROJECT_NAME}_HEADERS
     include/eigenpy/register.hpp
     include/eigenpy/std-array.hpp
     include/eigenpy/std-map.hpp
+    include/eigenpy/std-pair.hpp
     include/eigenpy/std-vector.hpp
     include/eigenpy/optional.hpp
     include/eigenpy/pickle-vector.hpp

include/eigenpy/std-pair.hpp

@@ -0,0 +1,69 @@
+//
+// Copyright (c) 2023 INRIA
+//
+
+#ifndef __eigenpy_utils_std_pair_hpp__
+#define __eigenpy_utils_std_pair_hpp__
+
+#include <boost/python.hpp>
+#include <utility>
+
+namespace eigenpy {
+
+template <typename pair_type>
+struct StdPairConverter {
+  typedef typename pair_type::first_type T1;
+  typedef typename pair_type::second_type T2;
+
+  static PyObject* convert(const pair_type& pair) {
+    return boost::python::incref(
+        boost::python::make_tuple(pair.first, pair.second).ptr());
+  }
+
+  static void* convertible(PyObject* obj) {
+    if (!PyTuple_CheckExact(obj)) return 0;
+    if (PyTuple_Size(obj) != 2) return 0;
+    {
+      boost::python::tuple tuple(boost::python::borrowed(obj));
+      boost::python::extract<T1> elt1(tuple[0]);
+      if (!elt1.check()) return 0;
+      boost::python::extract<T2> elt2(tuple[1]);
+      if (!elt2.check()) return 0;
+    }
+    return obj;
+  }
+
+  static void construct(
+      PyObject* obj,
+      boost::python::converter::rvalue_from_python_stage1_data* memory) {
+    boost::python::tuple tuple(boost::python::borrowed(obj));
+    void* storage =
+        reinterpret_cast<
+            boost::python::converter::rvalue_from_python_storage<pair_type>*>(
+            reinterpret_cast<void*>(memory))
+            ->storage.bytes;
+    new (storage) pair_type(boost::python::extract<T1>(tuple[0]),
+                            boost::python::extract<T2>(tuple[1]));
+    memory->convertible = storage;
+  }
+
+  static PyTypeObject const* get_pytype() {
+    PyTypeObject const* py_type = &PyTuple_Type;
+    return py_type;
+  }
+
+  static void registration() {
+    boost::python::converter::registry::push_back(
+        &convertible, &construct, boost::python::type_id<pair_type>()
+#ifndef BOOST_PYTHON_NO_PY_SIGNATURES
+                                      ,
+        get_pytype
+#endif
+    );
+    boost::python::to_python_converter<pair_type, StdPairConverter, true>();
+  }
+};
+
+}  // namespace eigenpy
+
+#endif  // ifndef __eigenpy_utils_std_pair_hpp__

unittest/CMakeLists.txt

@@ -39,6 +39,7 @@ if(NOT NUMPY_WITH_BROKEN_UFUNC_SUPPORT)
 endif()
 add_lib_unit_test(std_vector)
 add_lib_unit_test(std_array)
+add_lib_unit_test(std_pair)
 add_lib_unit_test(user_struct)
 
 function(config_bind_optional tagname opttype)
@@ -115,6 +116,10 @@ add_python_unit_test("py-std-array" "unittest/python/test_std_array.py"
                      "python;unittest")
 set_tests_properties("py-std-array" PROPERTIES DEPENDS ${PYWRAP})
 
+add_python_unit_test("py-std-pair" "unittest/python/test_std_pair.py"
+                     "unittest")
+set_tests_properties("py-std-pair" PROPERTIES DEPENDS ${PYWRAP})
+
 add_python_unit_test("py-user-struct" "unittest/python/test_user_struct.py"
                      "python;unittest")
 set_tests_properties("py-user-struct" PROPERTIES DEPENDS ${PYWRAP})

unittest/python/test_std_pair.py

@@ -0,0 +1,5 @@
+from std_pair import std_pair_to_tuple, copy
+
+t = (1, 2.0)
+assert std_pair_to_tuple(t) == t
+assert copy(t) == t

unittest/std_pair.cpp

@@ -0,0 +1,30 @@
+/// @file
+/// @copyright Copyright 2023 CNRS INRIA
+
+#include <eigenpy/eigenpy.hpp>
+#include <eigenpy/std-pair.hpp>
+#include <iostream>
+
+namespace bp = boost::python;
+
+template <typename T1, typename T2>
+bp::tuple std_pair_to_tuple(const std::pair<T1, T2>& pair) {
+  return bp::make_tuple(pair.first, pair.second);
+}
+
+template <typename T1, typename T2>
+std::pair<T1, T2> copy(const std::pair<T1, T2>& pair) {
+  return pair;
+}
+
+BOOST_PYTHON_MODULE(std_pair) {
+  using namespace eigenpy;
+
+  enableEigenPy();
+
+  typedef std::pair<int, double> PairType;
+  StdPairConverter<PairType>::registration();
+
+  bp::def("std_pair_to_tuple", std_pair_to_tuple<int, double>);
+  bp::def("copy", copy<int, double>);
+}