fix copy constructors for C++ 11/14

Author: pachadotdev

Makefile

@@ -21,13 +21,12 @@ check:
 	@$(MAKE) install
 	@$(MAKE) register
 	@Rscript -e 'devtools::check("./", error_on = "error")'
-	@Rscript -e	'cpp4r::register("extended-tests/cpp4rtest")'
-	@Rscript -e 'devtools::check("./", error_on = "error")'
 	@echo "==============================="
 	@echo "Checking C++ code"
 	@$(MAKE) install
 	@rm -f extended-tests-results/*.log
 	@rm -f extended-tests-results/check-results.md
+	@Rscript -e	'cpp4r::register("extended-tests/cpp4rtest")'
 	@export -p USE_CLANG; /bin/bash -euo pipefail -c './scripts/check_loop.sh'
 	@echo "==============================="
 

example-packages/cpp4rgaussjordan/src/vendor/cpp4r/complexes.hpp

@@ -221,8 +221,7 @@ class r_vector<r_complex>::proxy {
 // New complexes_vector class for handling complex numbers in SEXP
 class complexes_vector {
  public:
-  explicit complexes_vector(SEXP x) noexcept
-      : data_(reinterpret_cast<Rcomplex*>(DATAPTR(x))), size_(Rf_length(x)) {}
+  explicit complexes_vector(SEXP x) noexcept : data_(COMPLEX(x)), size_(Rf_length(x)) {}
 
   std::complex<double> operator[](R_xlen_t i) const noexcept {
     return {data_[i].r, data_[i].i};

example-packages/cpp4rgaussjordan/src/vendor/cpp4r/list.hpp

@@ -35,8 +35,18 @@ template <>
 inline typename r_vector<SEXP>::underlying_type const* r_vector<SEXP>::get_const_p(
     bool is_altrep, SEXP data) noexcept {
   // No `VECTOR_PTR_OR_NULL()`
-  return __builtin_expect(is_altrep, 0) ? nullptr
-                                        : static_cast<SEXP const*>(DATAPTR_RO(data));
+  if (is_altrep) {
+    return nullptr;
+  } else {
+#if defined(R_VERSION) && R_VERSION >= R_Version(4, 5, 0)
+    // R 4.5.0+ provides VECTOR_PTR_RO as part of the public API
+    return VECTOR_PTR_RO(data);
+#else
+    // For older R versions, return nullptr and rely on VECTOR_ELT for element access
+    // DATAPTR_RO is not part of the public API and causes CRAN check failures
+    return nullptr;
+#endif
+  }
 }
 
 /// Specialization for lists, where `x["oob"]` returns `R_NilValue`, like at the R level

extended-tests/cpp4rtest/configure

@@ -8,5 +8,11 @@ SHLIB_OPENMP_CXXFLAGS=$(${R_HOME}/bin/R CMD config SHLIB_OPENMP_CXXFLAGS 2>/dev/
 BLAS_LIBS=$(${R_HOME}/bin/R CMD config BLAS_LIBS)
 LAPACK_LIBS=$(${R_HOME}/bin/R CMD config LAPACK_LIBS)
 
+# If CXX_STD is empty, default to CXX11 (minimum required by cpp4r)
+if [ -z "${CXX_STD:-}" ]; then
+    echo "configure: CXX_STD not set, defaulting to CXX11"
+    CXX_STD="CXX11"
+fi
+
 sed -e "s|@CXX_STD@|${CXX_STD}|g" \
     src/Makevars.in > src/Makevars

extended-tests/cpp4rtest/src/main.cpp

@@ -30,23 +30,36 @@ using namespace cpp4r;
 
 // Test headers (these contain testthat tests, not exported functions)
 #include "test-as.h"
+#include "test-as_advanced.h"
+#include "test-as_complexes.h"
+#include "test-attribute_proxy.h"
 #include "test-complex.h"
 #include "test-data_frame.h"
 #include "test-doubles.h"
 #include "test-environment.h"
+#include "test-environment_advanced.h"
 #include "test-external_pointer.h"
 #include "test-function.h"
+#include "test-function_advanced.h"
 #include "test-integers.h"
 #include "test-list.h"
 #include "test-list_of.h"
 #include "test-logicals.h"
 #include "test-matrix.h"
+#include "test-matrix_advanced.h"
+#include "test-named_arg.h"
 #include "test-nas.h"
 #include "test-protect-nested.h"
 #include "test-protect.h"
+#include "test-protect_advanced.h"
+#include "test-r_bool_advanced.h"
 #include "test-r_complex.h"
+#include "test-r_string_advanced.h"
 #include "test-r_vector.h"
+#include "test-r_vector_advanced.h"
 #include "test-raws.h"
 #include "test-sexp.h"
+#include "test-sexp_advanced.h"
 #include "test-string.h"
 #include "test-strings.h"
+#include "test-translate_names.h"

extended-tests/cpp4rtest/src/test-as_advanced.h

@@ -0,0 +1,84 @@
+#include <testthat.h>
+
+#include <deque>
+#include <list>
+#include <map>
+#include <unordered_map>
+
+context("as_advanced-C++") {
+  test_that("as_cpp with int type") {
+    SEXP x = PROTECT(Rf_ScalarInteger(42));
+    auto val = cpp4r::as_cpp<int>(x);
+    expect_true(val == 42);
+    UNPROTECT(1);
+  }
+
+  test_that("as_sexp with std::map<std::string, SEXP>") {
+    std::map<std::string, SEXP> m;
+    m["a"] = PROTECT(Rf_ScalarInteger(1));
+    m["b"] = PROTECT(Rf_ScalarInteger(2));
+
+    SEXP result = PROTECT(cpp4r::as_sexp(m));
+    expect_true(Rf_isVector(result));
+    expect_true(Rf_xlength(result) == 2);
+
+    SEXP names = Rf_getAttrib(result, R_NamesSymbol);
+    expect_true(names != R_NilValue);
+    UNPROTECT(3);
+  }
+
+  test_that("as_sexp with std::map<double, int>") {
+    std::map<double, int> m;
+    m[1.5] = 10;
+    m[2.5] = 20;
+
+    SEXP result = PROTECT(cpp4r::as_sexp(m));
+    expect_true(Rf_isVector(result));
+    UNPROTECT(1);
+  }
+
+  test_that("as_sexp with std::unordered_map<std::string, SEXP>") {
+    std::unordered_map<std::string, SEXP> m;
+    m["x"] = PROTECT(Rf_ScalarReal(1.5));
+    m["y"] = PROTECT(Rf_ScalarReal(2.5));
+
+    SEXP result = PROTECT(cpp4r::as_sexp(m));
+    expect_true(Rf_isVector(result));
+    UNPROTECT(3);
+  }
+
+  test_that("as_sexp with std::list<double>") {
+    std::list<double> l = {1.0, 2.0, 3.0};
+    SEXP result = PROTECT(cpp4r::as_sexp(l));
+    expect_true(Rf_isReal(result));
+    expect_true(Rf_xlength(result) == 3);
+    UNPROTECT(1);
+  }
+
+  test_that("as_cpp with SEXP passthrough") {
+    SEXP x = PROTECT(Rf_ScalarInteger(42));
+    SEXP y = cpp4r::as_cpp<SEXP>(x);
+    expect_true(x == y);
+    UNPROTECT(1);
+  }
+
+  test_that("as_cpp for std::complex<double>") {
+    SEXP x = PROTECT(Rf_allocVector(CPLXSXP, 1));
+    COMPLEX(x)[0].r = 1.0;
+    COMPLEX(x)[0].i = 2.0;
+
+    std::complex<double> c = cpp4r::as_cpp(x);
+    expect_true(c.real() == 1.0);
+    expect_true(c.imag() == 2.0);
+    UNPROTECT(1);
+  }
+
+  test_that("as_sexp for std::complex<double>") {
+    std::complex<double> c(3.0, 4.0);
+    SEXP result = PROTECT(cpp4r::as_sexp(c));
+    expect_true(Rf_isComplex(result));
+    expect_true(COMPLEX(result)[0].r == 3.0);
+    expect_true(COMPLEX(result)[0].i == 4.0);
+    UNPROTECT(1);
+  }
+}

extended-tests/cpp4rtest/src/test-as_complexes.h

@@ -0,0 +1,46 @@
+#include <testthat.h>
+
+context("as_complexes-C++") {
+  test_that("as_complexes from integers") {
+    cpp4r::writable::integers x({1, 2, 3});
+    cpp4r::complexes result = cpp4r::as_complexes(x);
+
+    expect_true(result.size() == 3);
+    expect_true(result[0] == cpp4r::r_complex(1, 0));
+    expect_true(result[1] == cpp4r::r_complex(2, 0));
+    expect_true(result[2] == cpp4r::r_complex(3, 0));
+  }
+
+  test_that("as_complexes handles NA_INTEGER") {
+    cpp4r::writable::integers x({NA_INTEGER, 42});
+    cpp4r::complexes result = cpp4r::as_complexes(x);
+
+    expect_true(cpp4r::is_na(result[0]));
+    expect_true(result[1] == cpp4r::r_complex(42, 0));
+  }
+
+  test_that("as_complexes from complex passthrough") {
+    cpp4r::writable::complexes x({cpp4r::r_complex(1, 2)});
+    cpp4r::complexes result = cpp4r::as_complexes(x);
+    expect_true(result[0] == cpp4r::r_complex(1, 2));
+  }
+
+  test_that("as_complexes throws on invalid type") {
+    cpp4r::writable::strings x({"a", "b"});
+    expect_error(cpp4r::as_complexes(x));
+  }
+
+  test_that("complex_vector wrapper works") {
+    SEXP x = PROTECT(Rf_allocVector(CPLXSXP, 2));
+    COMPLEX(x)[0].r = 1.0;
+    COMPLEX(x)[0].i = 2.0;
+    COMPLEX(x)[1].r = 3.0;
+    COMPLEX(x)[1].i = 4.0;
+
+    cpp4r::complex_vector cv(x);
+    expect_true(cv.size() == 2);
+    expect_true(cv[0] == std::complex<double>(1.0, 2.0));
+    expect_true(cv[1] == std::complex<double>(3.0, 4.0));
+    UNPROTECT(1);
+  }
+}

extended-tests/cpp4rtest/src/test-attribute_proxy.h

@@ -0,0 +1,30 @@
+#include <testthat.h>
+
+context("attribute_proxy-C++") {
+  test_that("attribute_proxy with initializer_list") {
+    cpp4r::writable::doubles x({1., 2., 3.});
+    x.attr("custom") = {10, 20, 30};
+
+    cpp4r::integers attr_val(Rf_getAttrib(x.data(), Rf_install("custom")));
+    expect_true(attr_val[0] == 10);
+    expect_true(attr_val[1] == 20);
+    expect_true(attr_val[2] == 30);
+  }
+
+  test_that("attribute_proxy with SEXP name") {
+    cpp4r::writable::integers x({1, 2, 3});
+    SEXP sym = Rf_install("foo");
+    x.attr(sym) = "bar";
+
+    cpp4r::strings val(Rf_getAttrib(x.data(), sym));
+    expect_true(val[0] == "bar");
+  }
+
+  test_that("attribute_proxy read via SEXP conversion") {
+    cpp4r::writable::doubles x({1., 2.});
+    x.attr("test") = 42;
+
+    SEXP attr_val = x.attr("test");
+    expect_true(INTEGER(attr_val)[0] == 42);
+  }
+}

extended-tests/cpp4rtest/src/test-environment_advanced.h

@@ -0,0 +1,44 @@
+#include <testthat.h>
+
+context("environment-advanced-C++") {
+  test_that("environment::exists() works") {
+    auto new_env = cpp4r::package("base")["new.env"];
+    cpp4r::environment x(new_env());
+
+    expect_false(x.exists("foo"));
+    x["foo"] = 1;
+    expect_true(x.exists("foo"));
+  }
+
+  test_that("environment::exists() with SEXP symbol") {
+    auto new_env = cpp4r::package("base")["new.env"];
+    cpp4r::environment x(new_env());
+
+    SEXP sym = Rf_install("bar");
+    expect_false(x.exists(sym));
+    x["bar"] = 2;
+    expect_true(x.exists(sym));
+  }
+
+  test_that("environment::exists() with std::string") {
+    auto new_env = cpp4r::package("base")["new.env"];
+    cpp4r::environment x(new_env());
+
+    std::string name = "baz";
+    expect_false(x.exists(name));
+    x["baz"] = 3;
+    expect_true(x.exists(name));
+  }
+
+  test_that("environment::remove() with SEXP symbol") {
+    auto new_env = cpp4r::package("base")["new.env"];
+    cpp4r::environment x(new_env());
+
+    x["foo"] = 1;
+    expect_true(x.exists("foo"));
+
+    SEXP sym = Rf_install("foo");
+    x.remove(sym);
+    expect_false(x.exists("foo"));
+  }
+}

extended-tests/cpp4rtest/src/test-function_advanced.h

@@ -0,0 +1,35 @@
+#include <testthat.h>
+
+context("function-advanced-C++") {
+  test_that("function with multiple named arguments") {
+    using namespace cpp4r::literals;
+
+    auto paste = cpp4r::package("base")["paste"];
+    std::string res = cpp4r::as_cpp<std::string>(paste("a", "b", "c", "sep"_nm = "-"));
+    expect_true(res == "a-b-c");
+  }
+
+  test_that("package::operator[] with std::string") {
+    std::string func_name = "sum";
+    auto sum = cpp4r::package("base")[func_name];
+    double result = sum(cpp4r::as_sexp({1., 2., 3.}));
+    expect_true(result == 6.);
+  }
+
+  test_that("cpp4r::message works") {
+    // Just test that it doesn't throw - message output is captured by R
+    cpp4r::message("test message");
+    expect_true(true);
+  }
+
+  test_that("cpp4r::message with format args") {
+    cpp4r::message("test %s %d", "message", 42);
+    expect_true(true);
+  }
+
+  test_that("cpp4r::message with std::string") {
+    std::string msg = "test message";
+    cpp4r::message(msg);
+    expect_true(true);
+  }
+}