Add std::string variants for all const char* accessors

Fixes #34

Author: jimhester

cpp11test/src/test-strings.cpp

@@ -166,6 +166,14 @@ context("strings-C++") {
     x.at(0) = "bar";
   }
 
+  test_that("strings::operator=() works with std:strings") {
+    cpp11::writable::strings x(Rf_mkChar("foo"));
+    std::string y("bar");
+
+    x[0] = y;
+    expect_true(x[0] == y);
+  }
+
   // test_that("writable::strings(ALTREP_SEXP)") {
   // SEXP x = PROTECT(R_compact_uint8_trange(1, 5));
   //// Need to find (or create) an altrep class that implements duplicate.

inst/include/cpp11/attribute_proxy.hpp

@@ -19,6 +19,9 @@ class attribute_proxy {
   attribute_proxy(const T& parent, const char* index)
       : parent_(parent), symbol_(safe[Rf_install](index)) {}
 
+  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) {}
 
   template <typename C>

inst/include/cpp11/environment.hpp

@@ -39,13 +39,16 @@ class environment {
   environment(SEXP env) : env_(env) {}
   proxy operator[](SEXP name) const { return {env_, name}; }
   proxy operator[](const char* name) const { return operator[](safe[Rf_install](name)); }
+  proxy operator[](const std::string& name) const { return operator[](name.c_str()); }
 
   bool exists(SEXP name) const {
     SEXP res = safe[Rf_findVarInFrame3](env_, name, FALSE);
     return res != R_UnboundValue;
   }
   bool exists(const char* name) const { return exists(safe[Rf_install](name)); }
 
+  bool exists(const std::string& name) const { return exists(name.c_str()); }
+
   void remove(SEXP name) {
 #ifdef HAS_REMOVE_VAR_FROM_FRAME
     R_removeVarFromFrame(name, env_);

inst/include/cpp11/function.hpp

@@ -51,9 +51,11 @@ class function {
 class package {
  public:
   package(const char* name) : data_(get_namespace(name)) {}
+  package(const std::string& name) : data_(get_namespace(name.c_str())) {}
   function operator[](const char* name) {
     return safe[Rf_findFun](safe[Rf_install](name), data_);
   }
+  function operator[](const std::string& name) { return operator[](name.c_str()); }
 
  private:
   static SEXP get_namespace(const char* name) {

inst/include/cpp11/list_of.hpp

@@ -16,6 +16,8 @@ class list_of : public list {
   T operator[](R_xlen_t pos) { return list::operator[](pos); }
 
   T operator[](const char* pos) { return list::operator[](pos); }
+
+  T operator[](const std::string& pos) { return list::operator[](pos.c_str()); }
 };
 
 namespace writable {
@@ -36,6 +38,10 @@ class list_of : public writable::list {
   T operator[](const char* pos) {
     return static_cast<SEXP>(writable::list::operator[](pos));
   }
+
+  T operator[](const std::string& pos) {
+    return static_cast<SEXP>(writable::list::operator[](pos.c_str()));
+  }
 };
 }  // namespace writable
 

inst/include/cpp11/protect.hpp

@@ -8,6 +8,8 @@
 #include "R_ext/Utils.h"  // for R_CheckUserInterrupt
 #include "Rversion.h"     // for R_VERSION, R_Version
 
+#include <string>
+
 #if defined(R_VERSION) && R_VERSION >= R_Version(3, 5, 0)
 #define HAS_UNWIND_PROTECT
 #endif
@@ -197,9 +199,19 @@ void stop(const char* fmt, Args... args) {
   unwind_protect([&] { Rf_error(fmt, args...); });
 }
 
+template <typename... Args>
+void stop(const std::string& fmt, Args... args) {
+  unwind_protect([&] { Rf_error(fmt.c_str(), args...); });
+}
+
 template <typename... Args>
 void warning(const char* fmt, Args... args) {
   unwind_protect([&] { Rf_warning(fmt, args...); });
 }
 
+template <typename... Args>
+void warning(const std::string& fmt, Args... args) {
+  unwind_protect([&] { Rf_warning(fmt.c_str(), args...); });
+}
+
 }  // namespace cpp11

inst/include/cpp11/r_string.hpp

@@ -14,6 +14,7 @@ class r_string {
   r_string() = default;
   r_string(SEXP data) : data_(data) {}
   r_string(const char* data) : data_(safe[Rf_mkCharCE](data, CE_UTF8)) {}
+  r_string(const std::string& data) : data_(safe[Rf_mkCharCE](data.c_str(), CE_UTF8)) {}
 
   operator SEXP() const { return data_; }
   operator std::string() const {
@@ -35,6 +36,10 @@ class r_string {
     return static_cast<std::string>(*this) == rhs;
   }
 
+  bool operator==(const std::string& rhs) const {
+    return static_cast<std::string>(*this) == rhs;
+  }
+
   R_xlen_t size() const { return Rf_xlength(data_); }
 
  private:

inst/include/cpp11/r_vector.hpp

@@ -278,6 +278,7 @@ class r_vector : public cpp11::r_vector<T> {
   r_vector(std::initializer_list<T> il);
   r_vector(std::initializer_list<named_arg> il);
   r_vector(std::initializer_list<const char*> il);
+  r_vector(std::initializer_list<std::string> il);
 
   template <typename Iter>
   r_vector(Iter first, Iter last);

inst/include/cpp11/strings.hpp

@@ -114,6 +114,10 @@ template <>
 inline r_vector<r_string>::r_vector(std::initializer_list<const char*> il)
     : cpp11::r_vector<r_string>(as_sexp(il)), capacity_(il.size()) {}
 
+template <>
+inline r_vector<r_string>::r_vector(std::initializer_list<std::string> il)
+    : cpp11::r_vector<r_string>(as_sexp(il)), capacity_(il.size()) {}
+
 template <>
 inline r_vector<r_string>::r_vector(std::initializer_list<named_arg> il)
     : cpp11::r_vector<r_string>(safe[Rf_allocVector](STRSXP, il.size())),