[Bf-blender-cvs] [23c1b1edc8b] functions: deduplicate string ref code

[Jacques Lucke]

Commit: 23c1b1edc8bf3c9e55576ee2893d1b6b3cb2e90b
Author: Jacques Lucke
Date:   Wed May 15 11:38:06 2019 +0200
Branches: functions
https://developer.blender.org/rB23c1b1edc8bf3c9e55576ee2893d1b6b3cb2e90b

deduplicate string ref code

===================================================================

M	source/blender/blenlib/BLI_string_ref.hpp
M	tests/gtests/blenlib/BLI_string_ref_test.cc

===================================================================

diff --git a/source/blender/blenlib/BLI_string_ref.hpp b/source/blender/blenlib/BLI_string_ref.hpp
index 17d8577886e..1a214a29544 100644
--- a/source/blender/blenlib/BLI_string_ref.hpp
+++ b/source/blender/blenlib/BLI_string_ref.hpp
@@ -10,29 +10,19 @@
 
 namespace BLI {
 
-class StringRefNull {
+class StringRefBase {
  public:
   using size_type = size_t;
 
- private:
+ protected:
   const char *m_data;
   size_type m_size;
 
- public:
-  StringRefNull() : m_data(""), m_size(0)
-  {
-  }
-
-  StringRefNull(const char *str) : m_data(str), m_size(strlen(str))
-  {
-    BLI_assert(str != NULL);
-    BLI_assert(m_data[m_size] == '\0');
-  }
-
-  StringRefNull(const std::string &str) : StringRefNull(str.data())
+  StringRefBase(const char *data, size_type size) : m_data(data), m_size(size)
   {
   }
 
+ public:
   size_type size() const
   {
     return m_size;
@@ -54,87 +44,76 @@ class StringRefNull {
     return std::string(m_data, m_size);
   }
 
-  friend std::ostream &operator<<(std::ostream &stream, StringRefNull ref)
+  friend std::ostream &operator<<(std::ostream &stream, StringRefBase ref)
   {
     stream << ref.to_std_string();
     return stream;
   }
 
-  friend std::string operator+(const char *a, const StringRefNull b)
+  friend std::string operator+(const StringRefBase a, const StringRefBase b)
+  {
+    return a.to_std_string() + b.data();
+  }
+
+  friend std::string operator+(const char *a, const StringRefBase b)
   {
     return a + b.to_std_string();
   }
 
-  friend std::string operator+(const StringRefNull a, const char *b)
+  friend std::string operator+(const StringRefBase a, const char *b)
   {
     return a.to_std_string() + b;
   }
 
-  friend std::string operator+(const std::string &a, const StringRefNull b)
+  friend std::string operator+(const std::string &a, const StringRefBase b)
   {
     return a + b.data();
   }
 
-  friend std::string operator+(const StringRefNull a, const std::string &b)
+  friend std::string operator+(const StringRefBase a, const std::string &b)
   {
     return a.data() + b;
   }
 };
 
-class StringRef {
- public:
-  using size_type = size_t;
-
- private:
-  const char *m_data;
-  size_type m_size;
+class StringRefNull : public StringRefBase {
 
  public:
-  StringRef() : m_data(nullptr), m_size(0)
-  {
-  }
-
-  StringRef(StringRefNull other) : m_data(other.data()), m_size(other.size())
-  {
-  }
-
-  StringRef(const char *str) : m_data(str), m_size(str ? strlen(str) : 0)
+  StringRefNull() : StringRefBase("", 0)
   {
   }
 
-  StringRef(const char *str, size_type length) : m_data(str), m_size(length)
+  StringRefNull(const char *str) : StringRefBase(str, strlen(str))
   {
+    BLI_assert(str != NULL);
+    BLI_assert(m_data[m_size] == '\0');
   }
 
-  StringRef(const std::string &str) : m_data(str.data()), m_size(str.size())
+  StringRefNull(const std::string &str) : StringRefNull(str.data())
   {
   }
+};
 
-  size_type size() const
+class StringRef : public StringRefBase {
+ public:
+  StringRef() : StringRefBase(nullptr, 0)
   {
-    return m_size;
   }
 
-  const char *data() const
+  StringRef(StringRefNull other) : StringRefBase(other.data(), other.size())
   {
-    return m_data;
   }
 
-  char operator[](size_type index) const
+  StringRef(const char *str) : StringRefBase(str, str ? strlen(str) : 0)
   {
-    BLI_assert(index < m_size);
-    return m_data[index];
   }
 
-  std::string to_std_string() const
+  StringRef(const char *str, size_type length) : StringRefBase(str, length)
   {
-    return std::string(m_data, m_size);
   }
 
-  friend std::ostream &operator<<(std::ostream &stream, StringRef ref)
+  StringRef(const std::string &str) : StringRefBase(str.data(), str.size())
   {
-    stream << ref.to_std_string();
-    return stream;
   }
 };
 
diff --git a/tests/gtests/blenlib/BLI_string_ref_test.cc b/tests/gtests/blenlib/BLI_string_ref_test.cc
index 5cff6adb7a4..fe994553a5c 100644
--- a/tests/gtests/blenlib/BLI_string_ref_test.cc
+++ b/tests/gtests/blenlib/BLI_string_ref_test.cc
@@ -78,3 +78,39 @@ TEST(string_ref, Print)
   EXPECT_EQ(str.size(), 8);
   EXPECT_EQ(str, "testtest");
 }
+
+TEST(string_ref, Add)
+{
+  StringRef a("qwe");
+  StringRef b("asd");
+  std::string result = a + b;
+  EXPECT_EQ(result, "qweasd");
+}
+
+TEST(string_ref, AddCharPtr1)
+{
+  StringRef ref("test");
+  std::string result = ref + "qwe";
+  EXPECT_EQ(result, "testqwe");
+}
+
+TEST(string_ref, AddCharPtr2)
+{
+  StringRef ref("test");
+  std::string result = "qwe" + ref;
+  EXPECT_EQ(result, "qwetest");
+}
+
+TEST(string_ref, AddString1)
+{
+  StringRef ref("test");
+  std::string result = ref + std::string("asd");
+  EXPECT_EQ(result, "testasd");
+}
+
+TEST(string_ref, AddString2)
+{
+  StringRef ref("test");
+  std::string result = std::string("asd") + ref;
+  EXPECT_EQ(result, "asdtest");
+}