Merge pull request #40 from pachadotdev/map-to-list-clean

Map to list clean

Author: pachadotdev

cpp11test/R/cpp11.R

@@ -92,6 +92,14 @@ cpp11_insert_ <- function(num_sxp) {
   .Call(`_cpp11test_cpp11_insert_`, num_sxp)
 }
 
+ordered_map_to_list_ <- function(x) {
+  .Call(`_cpp11test_ordered_map_to_list_`, x)
+}
+
+unordered_map_to_list_ <- function(x) {
+  .Call(`_cpp11test_unordered_map_to_list_`, x)
+}
+
 gibbs_cpp <- function(N, thin) {
   .Call(`_cpp11test_gibbs_cpp`, N, thin)
 }
@@ -160,34 +168,6 @@ rcpp_release_ <- function(n) {
   invisible(.Call(`_cpp11test_rcpp_release_`, n))
 }
 
-notroxcpp1_ <- function(x) {
-  .Call(`_cpp11test_notroxcpp1_`, x)
-}
-
-roxcpp2_ <- function(x) {
-  .Call(`_cpp11test_roxcpp2_`, x)
-}
-
-roxcpp3_ <- function(x) {
-  .Call(`_cpp11test_roxcpp3_`, x)
-}
-
-roxcpp4_ <- function(x) {
-  .Call(`_cpp11test_roxcpp4_`, x)
-}
-
-roxcpp5_ <- function(x) {
-  .Call(`_cpp11test_roxcpp5_`, x)
-}
-
-notroxcpp6_ <- function(x) {
-  .Call(`_cpp11test_notroxcpp6_`, x)
-}
-
-roxcpp7_ <- function(x) {
-  .Call(`_cpp11test_roxcpp7_`, x)
-}
-
 cpp11_safe_ <- function(x_sxp) {
   .Call(`_cpp11test_cpp11_safe_`, x_sxp)
 }

cpp11test/src/cpp11.cpp

@@ -180,6 +180,20 @@ extern "C" SEXP _cpp11test_cpp11_insert_(SEXP num_sxp) {
     return cpp11::as_sexp(cpp11_insert_(cpp11::as_cpp<cpp11::decay_t<SEXP>>(num_sxp)));
   END_CPP11
 }
+// map.cpp
+SEXP ordered_map_to_list_(cpp11::doubles x);
+extern "C" SEXP _cpp11test_ordered_map_to_list_(SEXP x) {
+  BEGIN_CPP11
+    return cpp11::as_sexp(ordered_map_to_list_(cpp11::as_cpp<cpp11::decay_t<cpp11::doubles>>(x)));
+  END_CPP11
+}
+// map.cpp
+SEXP unordered_map_to_list_(cpp11::doubles x);
+extern "C" SEXP _cpp11test_unordered_map_to_list_(SEXP x) {
+  BEGIN_CPP11
+    return cpp11::as_sexp(unordered_map_to_list_(cpp11::as_cpp<cpp11::decay_t<cpp11::doubles>>(x)));
+  END_CPP11
+}
 // matrix.cpp
 SEXP gibbs_cpp(int N, int thin);
 extern "C" SEXP _cpp11test_gibbs_cpp(SEXP N, SEXP thin) {
@@ -620,6 +634,7 @@ static const R_CallMethodDef CallEntries[] = {
     {"_cpp11test_my_warning_n1",            (DL_FUNC) &_cpp11test_my_warning_n1,            1},
     {"_cpp11test_my_warning_n1fmt",         (DL_FUNC) &_cpp11test_my_warning_n1fmt,         1},
     {"_cpp11test_my_warning_n2fmt",         (DL_FUNC) &_cpp11test_my_warning_n2fmt,         2},
+    {"_cpp11test_ordered_map_to_list_",     (DL_FUNC) &_cpp11test_ordered_map_to_list_,     1},
     {"_cpp11test_notroxcpp1_",              (DL_FUNC) &_cpp11test_notroxcpp1_,              1},
     {"_cpp11test_notroxcpp6_",              (DL_FUNC) &_cpp11test_notroxcpp6_,              1},
     {"_cpp11test_protect_many_",            (DL_FUNC) &_cpp11test_protect_many_,            1},
@@ -669,6 +684,7 @@ static const R_CallMethodDef CallEntries[] = {
     {"_cpp11test_sum_int_foreach_",         (DL_FUNC) &_cpp11test_sum_int_foreach_,         1},
     {"_cpp11test_test_destruction_inner",   (DL_FUNC) &_cpp11test_test_destruction_inner,   0},
     {"_cpp11test_test_destruction_outer",   (DL_FUNC) &_cpp11test_test_destruction_outer,   0},
+    {"_cpp11test_unordered_map_to_list_",   (DL_FUNC) &_cpp11test_unordered_map_to_list_,   1},
     {"_cpp11test_upper_bound",              (DL_FUNC) &_cpp11test_upper_bound,              2},
     {"run_testthat_tests",                  (DL_FUNC) &run_testthat_tests,                  1},
     {NULL, NULL, 0}

cpp11test/src/map.cpp

@@ -0,0 +1,20 @@
+#include "cpp11/as.hpp"
+#include "cpp11/doubles.hpp"
+
+[[cpp11::register]] SEXP ordered_map_to_list_(cpp11::doubles x) {
+  std::map<double, int> counts;
+  int n = x.size();
+  for (int i = 0; i < n; i++) {
+    counts[x[i]]++;
+  }
+  return cpp11::as_sexp(counts);
+}
+
+[[cpp11::register]] SEXP unordered_map_to_list_(cpp11::doubles x) {
+  std::unordered_map<double, int> counts;
+  int n = x.size();
+  for (int i = 0; i < n; i++) {
+    counts[x[i]]++;
+  }
+  return cpp11::as_sexp(counts);
+}

cpp11test/src/roxygen1.cpp

@@ -0,0 +1,18 @@
+test_that("ordered and unordered C++ maps are converted to R lists", {
+  set.seed(42L)
+  x <- rnorm(10L)
+  xprime <- c(x, x[1])
+
+  om <- ordered_map_to_list_(x)
+  expect_type(om, "list")
+
+  om_doubles <- as.double(names(om))
+  expect_equal(om_doubles, sort(om_doubles))
+
+  omprime <- ordered_map_to_list_(xprime)
+  expect_equal(unlist(unique(omprime)), 1:2)
+
+  um <- unordered_map_to_list_(xprime)
+  expect_type(um, "list")
+  expect_equal(unlist(unique(um)), 1:2)
+})

cpp11test/src/roxygen2.cpp

@@ -2,11 +2,14 @@
 
 #include <cmath>             // for modf
 #include <initializer_list>  // for initializer_list
+#include <map>               // for std::map
 #include <memory>            // for std::shared_ptr, std::weak_ptr, std::unique_ptr
 #include <complex>
 #include <stdexcept>
-#include <string>       // for string, basic_string
-#include <type_traits>  // for decay, enable_if, is_same, is_convertible
+#include <string>         // for string, basic_string
+#include <type_traits>    // for decay, enable_if, is_same, is_convertible
+#include <unordered_map>  // for std::unordered_map
+#include <vector>         // for std::vector
 
 #include "cpp11/R.hpp"        // for SEXP, SEXPREC, Rf_xlength, R_xlen_t
 #include "cpp11/protect.hpp"  // for stop, protect, safe, protect::function
@@ -277,7 +280,7 @@ enable_if_integral<T, SEXP> as_sexp(const Container& from) {
 }
 
 inline SEXP as_sexp(std::initializer_list<int> from) {
-  return as_sexp<std::initializer_list<int>>(from);
+  return as_sexp(std::vector<int>(from));
 }
 
 template <typename Container, typename T = typename Container::value_type,
@@ -296,7 +299,7 @@ enable_if_floating_point<T, SEXP> as_sexp(const Container& from) {
 }
 
 inline SEXP as_sexp(std::initializer_list<double> from) {
-  return as_sexp<std::initializer_list<double>>(from);
+  return as_sexp(std::vector<double>(from));
 }
 
 template <typename Container, typename T = typename Container::value_type,
@@ -315,7 +318,7 @@ enable_if_bool<T, SEXP> as_sexp(const Container& from) {
 }
 
 inline SEXP as_sexp(std::initializer_list<bool> from) {
-  return as_sexp<std::initializer_list<bool>>(from);
+  return as_sexp(std::vector<bool>(from));
 }
 
 namespace detail {
@@ -361,12 +364,81 @@ enable_if_c_string<T, SEXP> as_sexp(const Container& from) {
 }
 
 inline SEXP as_sexp(std::initializer_list<const char*> from) {
-  return as_sexp<std::initializer_list<const char*>>(from);
+  return as_sexp(std::vector<const char*>(from));
 }
 
 template <typename T, typename = disable_if_r_string<T>>
 enable_if_convertible_to_sexp<T, SEXP> as_sexp(const T& from) {
   return from;
 }
 
+// Pacha: Specialization for std::map
+// NOTE: I did not use templates to avoid clashes with doubles/function/etc.
+inline SEXP as_sexp(const std::map<std::string, SEXP>& map) {
+  R_xlen_t size = map.size();
+  SEXP result = PROTECT(Rf_allocVector(VECSXP, size));
+  SEXP names = PROTECT(Rf_allocVector(STRSXP, size));
+
+  auto it = map.begin();
+  for (R_xlen_t i = 0; i < size; ++i, ++it) {
+    SET_VECTOR_ELT(result, i, it->second);
+    SET_STRING_ELT(names, i, Rf_mkCharCE(it->first.c_str(), CE_UTF8));
+  }
+
+  Rf_setAttrib(result, R_NamesSymbol, names);
+  UNPROTECT(2);
+  return result;
+}
+
+// Specialization for std::map<double, int>
+inline SEXP as_sexp(const std::map<double, int>& map) {
+  R_xlen_t size = map.size();
+  SEXP result = PROTECT(Rf_allocVector(VECSXP, size));
+  SEXP names = PROTECT(Rf_allocVector(REALSXP, size));
+
+  auto it = map.begin();
+  for (R_xlen_t i = 0; i < size; ++i, ++it) {
+    SET_VECTOR_ELT(result, i, Rf_ScalarInteger(it->second));
+    REAL(names)[i] = it->first;
+  }
+
+  Rf_setAttrib(result, R_NamesSymbol, names);
+  UNPROTECT(2);
+  return result;
+}
+
+// Pacha: Specialization for std::unordered_map
+inline SEXP as_sexp(const std::unordered_map<std::string, SEXP>& map) {
+  R_xlen_t size = map.size();
+  SEXP result = PROTECT(Rf_allocVector(VECSXP, size));
+  SEXP names = PROTECT(Rf_allocVector(STRSXP, size));
+
+  auto it = map.begin();
+  for (R_xlen_t i = 0; i < size; ++i, ++it) {
+    SET_VECTOR_ELT(result, i, it->second);
+    SET_STRING_ELT(names, i, Rf_mkCharCE(it->first.c_str(), CE_UTF8));
+  }
+
+  Rf_setAttrib(result, R_NamesSymbol, names);
+  UNPROTECT(2);
+  return result;
+}
+
+// Specialization for std::unordered_map<double, int>
+inline SEXP as_sexp(const std::unordered_map<double, int>& map) {
+  R_xlen_t size = map.size();
+  SEXP result = PROTECT(Rf_allocVector(VECSXP, size));
+  SEXP names = PROTECT(Rf_allocVector(REALSXP, size));
+
+  auto it = map.begin();
+  for (R_xlen_t i = 0; i < size; ++i, ++it) {
+    SET_VECTOR_ELT(result, i, Rf_ScalarInteger(it->second));
+    REAL(names)[i] = it->first;
+  }
+
+  Rf_setAttrib(result, R_NamesSymbol, names);
+  UNPROTECT(2);
+  return result;
+}
+
 }  // namespace cpp11

cpp11test/src/roxygen3.cpp

@@ -878,8 +878,6 @@ logicals duplicated_cpp(integers x) {
 }
 ```
 
-````{=html}
-<!--- TODO: Add `as_sexp()` support for maps
 ### Map
 
 A map is similar to a set, but instead of storing presence or absence, it can store additional data.
@@ -903,8 +901,6 @@ SEXP table_cpp(doubles x) {
   return as_sexp(counts);
 }
 ```
-!-->
-````
 
 ### Exercises