For c2py of stl types take argument by value and move elements

Author: Wentzell

c++/cpp2py/converters/map.hpp

@@ -5,13 +5,13 @@ namespace cpp2py {
 
   template <typename K, typename V> struct py_converter<std::map<K, V>> {
 
-    static PyObject *c2py(std::map<K, V> const &m) {
+    static PyObject *c2py(std::map<K, V> m) {
       PyObject *d = PyDict_New();
       for (auto &x : m) {
-        pyref k = py_converter<K>::c2py(x.first);
+        pyref k = py_converter<std::decay_t<K>>::c2py(std::move(x.first));
         // if the K is a list, we transform into a tuple
         if (PyList_Check(k)) k = PyList_AsTuple(k);
-        pyref v = py_converter<V>::c2py(x.second);
+        pyref v = py_converter<std::decay_t<V>>::c2py(std::move(x.second));
         if (k.is_null() or v.is_null() or (PyDict_SetItem(d, k, v) == -1)) {
           Py_DECREF(d);
           return NULL;

c++/cpp2py/converters/optional.hpp

@@ -3,12 +3,12 @@ namespace cpp2py {
 
  template <typename T> struct py_converter<std::optional<T>> {
 
-  using conv = py_converter<T>;
+   using conv = py_converter<std::decay_t<T>>;
 
-  static PyObject *c2py(std::optional<T> &op) {
-   if (!bool(op)) Py_RETURN_NONE;
-   return conv::c2py(*op);
-  }
+   static PyObject *c2py(std::optional<T> op) {
+     if (!bool(op)) Py_RETURN_NONE;
+     return conv::c2py(std::move(*op));
+   }
 
   static bool is_convertible(PyObject *ob, bool raise_exception) {
    return ((ob == Py_None) or conv::is_convertible(ob, raise_exception));

c++/cpp2py/converters/pair.hpp

@@ -5,9 +5,9 @@ namespace cpp2py {
 
   template <typename T1, typename T2> struct py_converter<std::pair<T1, T2>> {
 
-    static PyObject *c2py(std::pair<T1, T2> const &p) {
-      pyref x1 = py_converter<T1>::c2py(std::get<0>(p));
-      pyref x2 = py_converter<T2>::c2py(std::get<1>(p));
+    static PyObject *c2py(std::pair<T1, T2> p) {
+      pyref x1 = py_converter<std::decay_t<T1>>::c2py(std::move(std::get<0>(p)));
+      pyref x2 = py_converter<std::decay_t<T2>>::c2py(std::move(std::get<1>(p)));
       if (x1.is_null() or x2.is_null()) return NULL;
       return PyTuple_Pack(2, (PyObject *)x1, (PyObject *)x2);
     }

c++/cpp2py/converters/set.hpp

@@ -5,10 +5,10 @@ namespace cpp2py {
 
   template <typename K> struct py_converter<std::set<K>> {
 
-    static PyObject *c2py(std::set<K> const &s) {
+    static PyObject *c2py(std::set<K> s) {
       PyObject *set = PySet_New(NULL);
       for (auto &x : s) {
-        pyref y = py_converter<K>::c2py(x);
+        pyref y = py_converter<std::decay_t<K>>::c2py(std::move(x));
         if (y.is_null() or (PySet_Add(set, y) == -1)) {
           Py_DECREF(set);
           return NULL;

c++/cpp2py/converters/std_array.hpp

@@ -6,10 +6,10 @@ namespace cpp2py {
   template <typename T, size_t R> struct py_converter<std::array<T, R>> {
     // --------------------------------------
 
-    static PyObject *c2py(std::array<T, R> const &v) {
+    static PyObject *c2py(std::array<T, R> v) {
       PyObject *list = PyList_New(0);
-      for (auto const &x : v) {
-        pyref y = py_converter<T>::c2py(x);
+      for (auto &x : v) {
+        pyref y = py_converter<std::decay_t<T>>::c2py(std::move(x));
         if (y.is_null() or (PyList_Append(list, y) == -1)) {
           Py_DECREF(list);
           return NULL;

c++/cpp2py/converters/tuple.hpp

@@ -11,28 +11,28 @@ namespace cpp2py {
     using tuple_t = std::tuple<Types...>;
 
     // c2py implementation
-    template <std::size_t... Is> static PyObject *c2py_impl(tuple_t const &t, std::index_sequence<Is...>) {
-      auto objs        = std::array<pyref, sizeof...(Is)>{pyref(py_converter<Types>::c2py(std::get<Is>(t)))...};
+    template <std::size_t... Is> static PyObject *c2py_impl(tuple_t t, std::index_sequence<Is...>) {
+      auto objs        = std::array<pyref, sizeof...(Is)>{pyref(py_converter<std::decay_t<Types>>::c2py(std::move(std::get<Is>(t))))...};
       bool one_is_null = std::accumulate(std::begin(objs), std::end(objs), false, [](bool x, PyObject *a) { return x or (a == NULL); });
       if (one_is_null) return NULL;
       return PyTuple_Pack(sizeof...(Types), (PyObject *)(objs[Is])...);
     }
 
     // is_convertible implementation
     template <int N, typename T, typename... Tail> static bool is_convertible_impl(PyObject *seq, bool raise_exception) {
-      return py_converter<T>::is_convertible(PySequence_Fast_GET_ITEM(seq, N), raise_exception)
+      return py_converter<std::decay_t<T>>::is_convertible(PySequence_Fast_GET_ITEM(seq, N), raise_exception)
          && is_convertible_impl<N + 1, Tail...>(seq, raise_exception);
     }
     template <int> static bool is_convertible_impl(PyObject *seq, bool raise_exception) { return true; }
 
     template <size_t... Is> static auto py2c_impl(std::index_sequence<Is...>, PyObject *seq) {
-      return std::make_tuple(py_converter<Types>::py2c(PySequence_Fast_GET_ITEM(seq, Is))...);
+      return std::make_tuple(py_converter<std::decay_t<Types>>::py2c(PySequence_Fast_GET_ITEM(seq, Is))...);
     }
 
     public:
     // -----------------------------------------
 
-    static PyObject *c2py(tuple_t const &t) { return c2py_impl(t, std::make_index_sequence<sizeof...(Types)>()); }
+    static PyObject *c2py(tuple_t t) { return c2py_impl(std::move(t), std::make_index_sequence<sizeof...(Types)>()); }
 
     // -----------------------------------------
 

c++/cpp2py/converters/variant.hpp

@@ -45,18 +45,20 @@ namespace cpp2py {
     }
 
     struct _visitor {
-      template <typename U> PyObject *operator()(U const &x) { return py_converter<U>::c2py(x); }
+      template <typename U> PyObject *operator()(U x) { return py_converter<std::decay_t<U>>::c2py(std::move(x)); }
     };
 
     public:
+    static PyObject *c2py(std::variant<T...> v) { return visit(_visitor{}, std::move(v)); }
+
     static PyObject *c2py(std::variant<T...> const &v) {
       //auto l = [](auto const &x) -> PyObject * { return py_converter<decltype(x)>::c2py(x); };
       return visit(_visitor{}, v);
       //return visit(_visitor{}, v);
     }
 
     static bool is_convertible(PyObject *ob, bool raise_exception) {
-      if ((...  or py_converter<T>::is_convertible(ob, false))) return true;
+      if ((... or py_converter<std::decay_t<T>>::is_convertible(ob, false))) return true;
       if (raise_exception) { PyErr_SetString(PyExc_TypeError, "Cannot convert to std::variant"); }
       return false;
     }

c++/cpp2py/converters/vector.hpp

@@ -9,20 +9,19 @@
 namespace cpp2py {
 
   template <typename T> static void delete_pycapsule(PyObject *capsule) {
-    auto *ptr = static_cast<std::unique_ptr<T[]> *>(PyCapsule_GetPointer(capsule, "guard"));
+    auto *ptr = static_cast<std::vector<T> *>(PyCapsule_GetPointer(capsule, "guard"));
     delete ptr;
   }
 
   // Convert vector to numpy_proxy, WARNING: Deep Copy
-  template <typename T> numpy_proxy make_numpy_proxy_from_vector(std::vector<T> const &v) {
+  template <typename T> numpy_proxy make_numpy_proxy_from_vector(std::vector<T> v) {
 
-    auto *data_ptr = new std::unique_ptr<T[]>{new T[v.size()]};
-    std::copy(begin(v), end(v), data_ptr->get());
-    auto capsule = PyCapsule_New(data_ptr, "guard", &delete_pycapsule<T>);
+    auto *vec_heap = new std::vector<T>{std::move(v)};
+    auto capsule   = PyCapsule_New(vec_heap, "guard", &delete_pycapsule<T>);
 
     return {1, // rank
             npy_type<std::remove_const_t<T>>,
-            (void *)data_ptr->get(),
+            (void *)vec_heap->data(),
             std::is_const_v<T>,
             v_t{static_cast<long>(v.size())}, // extents
             v_t{sizeof(T)},                   // strides
@@ -46,14 +45,14 @@ namespace cpp2py {
 
   template <typename T> struct py_converter<std::vector<T>> {
 
-    static PyObject *c2py(std::vector<T> const &v) {
+    static PyObject *c2py(std::vector<T> v) {
 
       if constexpr (has_npy_type<T>) {
-        return make_numpy_proxy_from_vector(v).to_python();
+        return make_numpy_proxy_from_vector(std::move(v)).to_python();
       } else { // Convert to Python List
         PyObject *list = PyList_New(0);
         for (auto const &x : v) {
-          pyref y = py_converter<T>::c2py(x);
+          pyref y = py_converter<T>::c2py(std::move(x));
           if (y.is_null() or (PyList_Append(list, y) == -1)) {
             Py_DECREF(list);
             return NULL;