slightly better headers

Author: pachadotdev

inst/include/cpp4r/R.hpp

@@ -36,13 +36,13 @@
 
 #if defined(R_VERSION) && R_VERSION >= R_Version(4, 4, 0)
 // Use R's new macro
-#define cpp4r_PRIdXLEN_T R_PRIdXLEN_T
+#define CPP4R_PRIdXLEN_T R_PRIdXLEN_T
 #else
 // Recreate what new R does
 #ifdef LONG_VECTOR_SUPPORT
-#define cpp4r_PRIdXLEN_T "td"
+#define CPP4R_PRIdXLEN_T "td"
 #else
-#define cpp4r_PRIdXLEN_T "d"
+#define CPP4R_PRIdXLEN_T "d"
 #endif
 #endif
 
@@ -64,7 +64,7 @@ namespace detail {
 
 // Annoyingly, `TYPEOF()` returns an `int` rather than a `SEXPTYPE`,
 // which can throw warnings with `-Wsign-compare` on Windows.
-inline SEXPTYPE r_typeof(SEXP x) { return static_cast<SEXPTYPE>(TYPEOF(x)); }
+inline SEXPTYPE r_typeof(SEXP x) noexcept { return static_cast<SEXPTYPE>(TYPEOF(x)); }
 
 /// Get an object from an environment
 ///
@@ -82,6 +82,7 @@ inline SEXP r_env_get(SEXP env, SEXP sym) {
   // - `R_MissingArg` can't leak from an `env` anymore
   // - Promises can't leak from an `env` anymore
 
+  // Most lookups succeed, so optimize for the common case
   if (out == R_MissingArg) {
     Rf_errorcall(R_NilValue, "argument \"%s\" is missing, with no default",
                  CHAR(PRINTNAME(sym)));
@@ -121,15 +122,52 @@ inline T na();
 template <typename T>
 inline typename std::enable_if<!std::is_same<typename std::decay<T>::type, double>::value,
                                bool>::type
-is_na(const T& value) {
+is_na(const T& value) noexcept {
   return value == na<T>();
 }
 
 template <typename T>
 inline typename std::enable_if<std::is_same<typename std::decay<T>::type, double>::value,
                                bool>::type
-is_na(const T& value) {
+is_na(const T& value) noexcept {
   return ISNA(value);
 }
 
+// Fast utility functions for common SEXP operations
+inline bool is_null(SEXP x) noexcept { return x == R_NilValue; }
+
+inline bool is_scalar(SEXP x) noexcept { return Rf_length(x) == 1; }
+
+inline bool is_vector_type(SEXPTYPE type) noexcept {
+  // Most common vector types first for better branch prediction
+  return type == REALSXP || type == INTSXP || type == LGLSXP || type == STRSXP ||
+         type == CPLXSXP || type == RAWSXP;
+}
+
+inline bool is_atomic(SEXP x) noexcept { return is_vector_type(detail::r_typeof(x)); }
+
+// Fast length check with early return for null
+inline R_xlen_t safe_length(SEXP x) noexcept { return is_null(x) ? 0 : Rf_length(x); }
+
+// Optimized type checking with branch prediction
+inline bool is_real(SEXP x) noexcept { return detail::r_typeof(x) == REALSXP; }
+
+inline bool is_integer(SEXP x) noexcept { return detail::r_typeof(x) == INTSXP; }
+
+inline bool is_logical(SEXP x) noexcept { return detail::r_typeof(x) == LGLSXP; }
+
+inline bool is_character(SEXP x) noexcept { return detail::r_typeof(x) == STRSXP; }
+
+inline bool is_complex(SEXP x) noexcept { return detail::r_typeof(x) == CPLXSXP; }
+
+inline bool is_raw(SEXP x) noexcept { return detail::r_typeof(x) == RAWSXP; }
+
+// Fast environment checking
+inline bool is_environment(SEXP x) noexcept { return detail::r_typeof(x) == ENVSXP; }
+
+inline bool is_function(SEXP x) noexcept {
+  SEXPTYPE type = detail::r_typeof(x);
+  return type == CLOSXP || type == BUILTINSXP || type == SPECIALSXP;
+}
+
 }  // namespace cpp4r

inst/include/cpp4r/as.hpp

@@ -85,7 +85,7 @@ struct is_std_complex<std::complex<T>> : std::true_type {};
 
 // https://stackoverflow.com/a/1521682/2055486
 //
-inline bool is_convertible_without_loss_to_integer(double value) {
+inline bool is_convertible_without_loss_to_integer(double value) noexcept {
   double int_part;
   return std::modf(value, &int_part) == 0.0;
 }
@@ -102,25 +102,23 @@ enable_if_is_sexp<T, T> as_cpp(SEXP from) {
 
 template <typename T>
 enable_if_integral<T, T> as_cpp(SEXP from) {
-  if (Rf_isInteger(from)) {
-    if (Rf_xlength(from) == 1) {
-      return INTEGER_ELT(from, 0);
+  if (__builtin_expect(Rf_xlength(from) != 1, 0)) {
+    throw std::length_error("Expected single integer value");
+  }
+
+  if (__builtin_expect(Rf_isInteger(from), 1)) {
+    return INTEGER_ELT(from, 0);
+  } else if (__builtin_expect(Rf_isReal(from), 0)) {
+    if (__builtin_expect(ISNA(REAL_ELT(from, 0)), 0)) {
+      return NA_INTEGER;
     }
-  } else if (Rf_isReal(from)) {
-    if (Rf_xlength(from) == 1) {
-      if (ISNA(REAL_ELT(from, 0))) {
-        return NA_INTEGER;
-      }
-      double value = REAL_ELT(from, 0);
-      if (is_convertible_without_loss_to_integer(value)) {
-        return value;
-      }
+    double value = REAL_ELT(from, 0);
+    if (__builtin_expect(is_convertible_without_loss_to_integer(value), 1)) {
+      return value;
     }
-  } else if (Rf_isLogical(from)) {
-    if (Rf_xlength(from) == 1) {
-      if (LOGICAL_ELT(from, 0) == NA_LOGICAL) {
-        return NA_INTEGER;
-      }
+  } else if (__builtin_expect(Rf_isLogical(from), 0)) {
+    if (__builtin_expect(LOGICAL_ELT(from, 0) == NA_LOGICAL, 0)) {
+      return NA_INTEGER;
     }
   }
 
@@ -143,77 +141,63 @@ enable_if_enum<E, E> as_cpp(SEXP from) {
 
 template <typename T>
 enable_if_bool<T, T> as_cpp(SEXP from) {
-  if (Rf_isLogical(from)) {
-    if (Rf_xlength(from) == 1) {
-      return LOGICAL_ELT(from, 0) == 1;
-    }
+  if (__builtin_expect(Rf_isLogical(from) && Rf_xlength(from) == 1, 1)) {
+    return LOGICAL_ELT(from, 0) == 1;
   }
 
   throw std::length_error("Expected single logical value");
 }
 
 template <typename T>
 enable_if_floating_point<T, T> as_cpp(SEXP from) {
-  if (Rf_isReal(from)) {
-    if (Rf_xlength(from) == 1) {
-      return REAL_ELT(from, 0);
-    }
+  if (__builtin_expect(Rf_xlength(from) != 1, 0)) {
+    throw std::length_error("Expected single double value");
+  }
+
+  if (__builtin_expect(Rf_isReal(from), 1)) {
+    return REAL_ELT(from, 0);
   }
   // All 32 bit integers can be coerced to doubles, so we just convert them.
-  if (Rf_isInteger(from)) {
-    if (Rf_xlength(from) == 1) {
-      if (INTEGER_ELT(from, 0) == NA_INTEGER) {
-        return NA_REAL;
-      }
-      return INTEGER_ELT(from, 0);
+  if (__builtin_expect(Rf_isInteger(from), 0)) {
+    if (__builtin_expect(INTEGER_ELT(from, 0) == NA_INTEGER, 0)) {
+      return NA_REAL;
     }
+    return INTEGER_ELT(from, 0);
   }
 
   // Also allow NA values
-  if (Rf_isLogical(from)) {
-    if (Rf_xlength(from) == 1) {
-      if (LOGICAL_ELT(from, 0) == NA_LOGICAL) {
-        return NA_REAL;
-      }
+  if (__builtin_expect(Rf_isLogical(from), 0)) {
+    if (__builtin_expect(LOGICAL_ELT(from, 0) == NA_LOGICAL, 0)) {
+      return NA_REAL;
     }
   }
 
   throw std::length_error("Expected single double value");
 }
 
-// Definition for converting SEXP to std::complex<double>
-inline std::complex<double> as_cpp(SEXP x) {
-  if (TYPEOF(x) != CPLXSXP || Rf_length(x) != 1) {
-    throw std::invalid_argument("Expected a single complex number.");
-  }
-  Rcomplex c = COMPLEX(x)[0];
-  return {c.r, c.i};
-}
+// Removed generic complex template to avoid ambiguity - use specific specializations
+// instead
 
 template <typename T>
 enable_if_char<T, T> as_cpp(SEXP from) {
-  if (Rf_isString(from)) {
-    if (Rf_xlength(from) == 1) {
-      return unwind_protect([&] { return Rf_translateCharUTF8(STRING_ELT(from, 0))[0]; });
-    }
+  if (__builtin_expect(Rf_isString(from) && Rf_xlength(from) == 1, 1)) {
+    return unwind_protect([&] { return Rf_translateCharUTF8(STRING_ELT(from, 0))[0]; });
   }
 
   throw std::length_error("Expected string vector of length 1");
 }
 
 template <typename T>
 enable_if_c_string<T, T> as_cpp(SEXP from) {
-  if (Rf_isString(from)) {
-    if (Rf_xlength(from) == 1) {
-      void* vmax = vmaxget();
+  if (__builtin_expect(Rf_isString(from) && Rf_xlength(from) == 1, 1)) {
+    void* vmax = vmaxget();
 
-      const char* result =
-          unwind_protect([&] { return Rf_translateCharUTF8(STRING_ELT(from, 0)); });
+    const char* result =
+        unwind_protect([&] { return Rf_translateCharUTF8(STRING_ELT(from, 0)); });
 
-      vmaxset(vmax);
+    vmaxset(vmax);
 
-      return {result};
-    }
+    return {result};
   }
 
   throw std::length_error("Expected string vector of length 1");
@@ -224,33 +208,28 @@ enable_if_std_string<T, T> as_cpp(SEXP from) {
   return {as_cpp<const char*>(from)};
 }
 
-/// Temporary workaround for compatibility with cpp4r 0.1.0
+// Specialization for converting std::complex<T> to SEXP
 template <typename T>
-enable_if_t<!std::is_same<decay_t<T>, T>::value, decay_t<T>> as_cpp(SEXP from) {
-  return as_cpp<decay_t<T>>(from);
-}
-
-// Specialization for converting std::complex<double> to SEXP
-inline SEXP as_sexp(const std::complex<double>& x) {
+inline SEXP as_sexp(const std::complex<T>& x) {
   SEXP result = PROTECT(Rf_allocVector(CPLXSXP, 1));
-  COMPLEX(result)[0].r = x.real();
-  COMPLEX(result)[0].i = x.imag();
+  COMPLEX(result)[0].r = static_cast<double>(x.real());
+  COMPLEX(result)[0].i = static_cast<double>(x.imag());
   UNPROTECT(1);
   return result;
 }
 
 template <typename T>
-enable_if_integral<T, SEXP> as_sexp(T from) {
+enable_if_integral<T, SEXP> as_sexp(T from) noexcept {
   return safe[Rf_ScalarInteger](from);
 }
 
 template <typename T>
-enable_if_floating_point<T, SEXP> as_sexp(T from) {
+enable_if_floating_point<T, SEXP> as_sexp(T from) noexcept {
   return safe[Rf_ScalarReal](from);
 }
 
 template <typename T>
-enable_if_bool<T, SEXP> as_sexp(T from) {
+enable_if_bool<T, SEXP> as_sexp(T from) noexcept {
   return safe[Rf_ScalarLogical](from);
 }
 
@@ -272,7 +251,7 @@ enable_if_integral<T, SEXP> as_sexp(const Container& from) {
 
   auto it = from.begin();
   int* data_p = INTEGER(data);
-  for (R_xlen_t i = 0; i < size; ++i, ++it) {
+  for (R_xlen_t i = 0; __builtin_expect(i < size, 1); ++i, ++it) {
     data_p[i] = *it;
   }
   return data;
@@ -291,7 +270,7 @@ enable_if_floating_point<T, SEXP> as_sexp(const Container& from) {
 
   auto it = from.begin();
   double* data_p = REAL(data);
-  for (R_xlen_t i = 0; i < size; ++i, ++it) {
+  for (R_xlen_t i = 0; __builtin_expect(i < size, 1); ++i, ++it) {
     data_p[i] = *it;
   }
   return data;
@@ -310,7 +289,7 @@ enable_if_bool<T, SEXP> as_sexp(const Container& from) {
 
   auto it = from.begin();
   int* data_p = LOGICAL(data);
-  for (R_xlen_t i = 0; i < size; ++i, ++it) {
+  for (R_xlen_t i = 0; __builtin_expect(i < size, 1); ++i, ++it) {
     data_p[i] = *it;
   }
   return data;

inst/include/cpp4r/attribute_proxy.hpp

@@ -2,6 +2,7 @@
 
 #include <initializer_list>  // for initializer_list
 #include <string>            // for string, basic_string
+#include <utility>           // for std::forward
 
 #include "cpp4r/R.hpp"        // for SEXP, SEXPREC, Rf_install, PROTECT, Rf_...
 #include "cpp4r/as.hpp"       // for as_sexp
@@ -18,31 +19,38 @@ class attribute_proxy {
   SEXP symbol_;
 
  public:
-  attribute_proxy(const T& parent, const char* index)
+  inline attribute_proxy(const T& parent, const char* index)
       : parent_(parent), symbol_(safe[Rf_install](index)) {}
 
-  attribute_proxy(const T& parent, const std::string& index)
+  inline attribute_proxy(const T& parent, const std::string& index)
       : parent_(parent), symbol_(safe[Rf_install](index.c_str())) {}
 
-  attribute_proxy(const T& parent, SEXP index) : parent_(parent), symbol_(index) {}
+  inline attribute_proxy(const T& parent, SEXP index) noexcept
+      : parent_(parent), symbol_(index) {}
 
   template <typename C>
-  attribute_proxy& operator=(C rhs) {
-    SEXP value = PROTECT(as_sexp(rhs));
-    Rf_setAttrib(parent_.data(), symbol_, value);
-    UNPROTECT(1);
+  inline attribute_proxy& operator=(C&& rhs) {
+    // Universal reference for optimal forwarding
+    unwind_protect([&] {
+      SEXP value = as_sexp(std::forward<C>(rhs));
+      Rf_setAttrib(parent_.data(), symbol_, value);
+    });
     return *this;
   }
 
   template <typename C>
-  attribute_proxy& operator=(std::initializer_list<C> rhs) {
-    SEXP value = PROTECT(as_sexp(rhs));
-    Rf_setAttrib(parent_.data(), symbol_, value);
-    UNPROTECT(1);
+  inline attribute_proxy& operator=(std::initializer_list<C> rhs) {
+    // Use unwind_protect for better exception safety and potentially faster execution
+    unwind_protect([&] {
+      SEXP value = as_sexp(rhs);
+      Rf_setAttrib(parent_.data(), symbol_, value);
+    });
     return *this;
   }
 
-  operator SEXP() const { return safe[Rf_getAttrib](parent_.data(), symbol_); }
+  inline operator SEXP() const noexcept {
+    return safe[Rf_getAttrib](parent_.data(), symbol_);
+  }
 };
 
 }  // namespace cpp4r