Add string_view API to str and String

Author: roligugus

include/cxx.h

@@ -14,6 +14,45 @@
 #include <basetsd.h>
 #endif
 
+#ifdef CXXBRIDGE_HAS_STRING_VIEW
+#error "string_view gets auto-detected"
+#endif
+
+// clang-format off
+// detect if string_view supported (C++17 required)
+#ifdef __has_include
+  #if __has_include(<version>)
+    // gcc >= 9, clang >= 9, msvc >= 19.22
+    #include <version>
+    #if __cpp_lib_string_view >= 201603L
+      #define CXXBRIDGE_HAS_STRING_VIEW
+    #endif
+  #else
+    // no <version> include
+    #if defined(__cpp_lib_string_view) && __cpp_lib_string_view >= 201603L
+      // gcc: 8, clang: 5 - 8, msvc: 19.15 - 19.21
+      #define CXXBRIDGE_HAS_STRING_VIEW
+    #else
+      // only include if compiled with c++17
+      #if (__GNUC__ >= 7 && __cplusplus >= 201703L) || (_MSVC_LANG >= 201703L)
+        // gcc: 7, msvc: 19.14
+        #define CXXBRIDGE_HAS_STRING_VIEW
+      #endif
+    #endif
+  #endif
+#else
+  // no __has_include
+  #if _MSC_VER >= 1910L && _MSVC_LANG > 201402L
+    // msvc: 19.10 requires c++latest (!)
+    #define CPPBRIDGE_HAS_STRING_VIEW
+  #endif
+#endif
+// clang-format on
+
+#ifdef CXXBRIDGE_HAS_STRING_VIEW
+#include <string_view>
+#endif
+
 namespace rust {
 inline namespace cxxbridge1 {
 
@@ -33,14 +72,21 @@ class String final {
   String(String &&) noexcept;
   ~String() noexcept;
 
+#ifdef CXXBRIDGE_HAS_STRING_VIEW
+  String(std::string_view);
+#else
   String(const std::string &);
+#endif
   String(const char *);
   String(const char *, size_t);
 
   String &operator=(const String &) noexcept;
   String &operator=(String &&) noexcept;
 
   explicit operator std::string() const;
+#ifdef CXXBRIDGE_HAS_STRING_VIEW
+  explicit operator std::string_view() const noexcept;
+#endif
 
   // Note: no null terminator.
   const char *data() const noexcept;
@@ -60,13 +106,20 @@ class String final {
 class Str final {
 public:
   Str() noexcept;
+#ifdef CXXBRIDGE_HAS_STRING_VIEW
+  Str(std::string_view);
+#else
   Str(const std::string &);
+#endif
   Str(const char *);
   Str(const char *, size_t);
 
   Str &operator=(const Str &) noexcept = default;
 
   explicit operator std::string() const;
+#ifdef CXXBRIDGE_HAS_STRING_VIEW
+  explicit operator std::string_view() const noexcept;
+#endif
 
   // Note: no null terminator.
   const char *data() const noexcept;

src/cxx.cc

@@ -79,7 +79,11 @@ static void initString(String *self, const char *s, size_t len) {
   }
 }
 
+#ifdef CXXBRIDGE_HAS_STRING_VIEW
+String::String(std::string_view sv) : String(sv.data(), sv.length()) {}
+#else
 String::String(const std::string &s) { initString(this, s.data(), s.length()); }
+#endif
 
 String::String(const char *s) {
   assert(s != nullptr);
@@ -114,6 +118,12 @@ String::operator std::string() const {
   return std::string(this->data(), this->size());
 }
 
+#ifdef CXXBRIDGE_HAS_STRING_VIEW
+String::operator std::string_view() const noexcept {
+  return {this->data(), this->size()};
+}
+#endif
+
 const char *String::data() const noexcept {
   return cxxbridge1$string$ptr(this);
 }
@@ -138,9 +148,13 @@ static void initStr(const char *ptr, size_t len) {
   }
 }
 
+#ifdef CXXBRIDGE_HAS_STRING_VIEW
+Str::Str(std::string_view sv) : Str(sv.data(), sv.length()) {}
+#else
 Str::Str(const std::string &s) : ptr(s.data()), len(s.length()) {
   initStr(this->ptr, this->len);
 }
+#endif
 
 Str::Str(const char *s) : ptr(s), len(std::strlen(s)) {
   assert(s != nullptr);
@@ -158,6 +172,12 @@ Str::operator std::string() const {
   return std::string(this->data(), this->size());
 }
 
+#ifdef CXXBRIDGE_HAS_STRING_VIEW
+Str::operator std::string_view() const noexcept {
+  return {this->data(), this->size()};
+}
+#endif
+
 std::ostream &operator<<(std::ostream &os, const Str &s) {
   os.write(s.data(), s.size());
   return os;

tests/ffi/lib.rs

@@ -255,8 +255,10 @@ pub mod ffi {
         fn r_take_ref_r(r: &R);
         fn r_take_ref_c(c: &C);
         fn r_take_str(s: &str);
+        fn r_take_empty_str(s: &str);
         fn r_take_sliceu8(s: &[u8]);
         fn r_take_rust_string(s: String);
+        fn r_take_empty_rust_string(s: String);
         fn r_take_unique_ptr_string(s: UniquePtr<CxxString>);
         fn r_take_ref_vector(v: &CxxVector<u8>);
         fn r_take_ref_empty_vector(v: &CxxVector<u64>);
@@ -439,10 +441,18 @@ fn r_take_str(s: &str) {
     assert_eq!(s, "2020");
 }
 
+fn r_take_empty_str(s: &str) {
+    assert_eq!(s.len(), 0);
+}
+
 fn r_take_rust_string(s: String) {
     assert_eq!(s, "2020");
 }
 
+fn r_take_empty_rust_string(s: String) {
+    assert_eq!(s.len(), 0);
+}
+
 fn r_take_sliceu8(s: &[u8]) {
     assert_eq!(s.len(), 5);
     assert_eq!(std::str::from_utf8(s).unwrap(), "2020\0");

tests/ffi/tests.cc

@@ -605,9 +605,26 @@ extern "C" const char *cxx_run_test() noexcept {
   r_take_unique_ptr(std::unique_ptr<C>(new C{2020}));
   r_take_ref_c(C{2020});
   r_take_str(rust::Str("2020"));
+  r_take_empty_str(rust::Str(""));
+  r_take_empty_str(rust::Str(nullptr, 0));
+#ifdef CXXBRIDGE_HAS_STRING_VIEW
+  r_take_str(std::string_view("2020"));
+  r_take_empty_str(std::string_view{});
+  r_take_empty_str(std::string_view(""));
+  ASSERT(static_cast<std::string_view>(rust::Str("2020")) == "2020");
+#endif
   r_take_sliceu8(rust::Slice<const uint8_t>(
       reinterpret_cast<const uint8_t *>(SLICE_DATA), sizeof(SLICE_DATA)));
   r_take_rust_string(rust::String("2020"));
+  r_take_empty_rust_string(rust::String(""));
+  r_take_empty_rust_string(rust::String(nullptr, 0));
+#ifdef CXXBRIDGE_HAS_STRING_VIEW
+  r_take_rust_string(std::string_view("2020"));
+  r_take_empty_rust_string(std::string_view{});
+  r_take_empty_rust_string(std::string_view(""));
+  const auto rustString = rust::String("2020"); // avoid lifetime issue
+  ASSERT(static_cast<std::string_view>(rustString) == "2020");
+#endif
   r_take_unique_ptr_string(
       std::unique_ptr<std::string>(new std::string("2020")));
   r_take_ref_vector(std::vector<uint8_t>{20, 2, 0});