Allow arrays of tuples and tuples as function arguments

Fixes JuliaInterop/CxxWrap.jl#478

Author: barche

examples/containers.cpp

@@ -18,6 +18,45 @@ const double* const_matrix()
   return &d[0][0];
 }
 
+// Tuple array test
+std::tuple<jlcxx::Array<double>, jlcxx::Array<double>>
+make_array_tuple()
+{
+  jlcxx::Array<double> x;
+  jlcxx::Array<double> y;
+
+  x.push_back(1.0);
+  x.push_back(2.0);
+  y.push_back(3.0);
+
+  return std::make_tuple(x, y);
+}
+
+std::tuple<double,int,bool> copy_tuple(std::tuple<double,int,bool> t)
+{
+  return t;
+}
+
+std::vector<double> read_array_tuple(std::tuple<jlcxx::ArrayRef<double>, jlcxx::ArrayRef<double>> t)
+{
+  jlcxx::ArrayRef<double> x = std::get<0>(t);
+  jlcxx::ArrayRef<double> y = std::get<1>(t);
+
+  std::vector<double> result;
+
+  for(auto el : x)
+  {
+    result.push_back(el);
+  }
+
+  for(auto el : y)
+  {
+    result.push_back(el);
+  }
+
+  return result;
+}
+
 JLCXX_MODULE define_julia_module(jlcxx::Module& containers)
 {
   using namespace jlcxx;
@@ -81,4 +120,7 @@ JLCXX_MODULE define_julia_module(jlcxx::Module& containers)
     return result;
   });
   containers.method("uint8_ptr", [] (uint8_t* x) { return int(*x); });
+  containers.method("copy_tuple", &copy_tuple);
+  containers.method("make_array_tuple", &make_array_tuple);
+  containers.method("read_array_tuple", &read_array_tuple);
 }

include/jlcxx/array.hpp

@@ -415,6 +415,24 @@ struct ConvertToCpp<ArrayRef<T,Dim>, CxxWrappedTrait<SubTraitT>>
   }
 };
 
+template<typename CppT>
+struct BoxValue<CppT,jl_array_t*>
+{
+  inline jl_value_t* operator()(CppT arr)
+  {
+    return (jl_value_t*)arr.wrapped();
+  }
+};
+
+template<typename ElementT, int Dim>
+struct UnboxValue<ArrayRef<ElementT,Dim>, jl_array_t*>
+{
+  inline ArrayRef<ElementT,Dim> operator()(jl_value_t* arr)
+  {
+    return ArrayRef<ElementT,Dim>(reinterpret_cast<jl_array_t*>(arr));
+  }
+};
+
 // Iterator operator implementation
 template<typename PointedT, typename CppT>
 bool operator!=(const array_iterator_base<PointedT, CppT>& l, const array_iterator_base<PointedT, CppT>& r)

include/jlcxx/tuple.hpp

@@ -67,6 +67,32 @@ struct TraitSelector<std::tuple<TypesT...>>
   using type = TupleTrait;
 };
 
+// Tuples are always copied because the memory layout in C++ and Julia is different, so references and pointers are not allowed
+template<typename... TypesT>
+struct TraitSelector<std::tuple<TypesT...>&>
+{
+  using type = TupleTrait;
+  static_assert(sizeof(std::tuple<TypesT...>) == 0, "References to Julia tuples can't be used. Pass the tuple by value instead.");
+};
+template<typename... TypesT>
+struct TraitSelector<const std::tuple<TypesT...>&>
+{
+  using type = TupleTrait;
+  static_assert(sizeof(std::tuple<TypesT...>) == 0, "References to Julia tuples can't be used. Pass the tuple by value instead.");
+};
+template<typename... TypesT>
+struct TraitSelector<std::tuple<TypesT...>*>
+{
+  using type = TupleTrait;
+  static_assert(sizeof(std::tuple<TypesT...>) == 0, "Pointers to Julia tuples can't be used. Pass the tuple by value instead.");
+};
+template<typename... TypesT>
+struct TraitSelector<const std::tuple<TypesT...>*>
+{
+  using type = TupleTrait;
+  static_assert(sizeof(std::tuple<TypesT...>) == 0, "Pointers to Julia tuples can't be used. Pass the tuple by value instead.");
+};
+
 template<typename... TypesT>
 struct MappingTrait<std::tuple<TypesT...>, TupleTrait>
 {
@@ -106,6 +132,21 @@ struct ConvertToJulia<std::tuple<TypesT...>, TupleTrait>
   }
 };
 
+template<typename... TypesT>
+struct ConvertToCpp<std::tuple<TypesT...>, TupleTrait>
+{
+  using cpp_t = std::tuple<TypesT...>;
+  inline cpp_t operator()(jl_value_t* julia_val) const
+  {
+    constexpr std::size_t tup_sz = std::tuple_size<cpp_t>::value;
+    auto unpack_tuple = [&]<std::size_t... Is>(std::index_sequence<Is...>)
+    {
+      return std::make_tuple((unbox<std::tuple_element_t<Is, cpp_t>>(jl_get_nth_field_checked(julia_val, Is)))...);
+    };
+    return unpack_tuple(std::make_index_sequence<tup_sz>{});
+  }
+};
+
 // Wrap NTuple type
 template<typename N, typename T>
 struct NTuple