Merge pull request #2712 from TurkeyMan/std_string_improvements

std::string improvements
merged-on-behalf-of: Nicholas Wilson <thewilsonator@users.noreply.github.com>

Author: dlang-bot

changelog/std_string.dd

@@ -1,3 +1,5 @@
 Added `core.stdcpp.string`.
 
 Added `core.stdcpp.string`, which links against C++ `std::string`
+
+Currently only supported and tested for the Visual Studio C++ runtime library. Other runtimes coming soon(tm)!

src/core/stdcpp/string.d

@@ -85,8 +85,6 @@ extern(D):
     ///
     alias const_pointer = const(value_type)*;
 
-    ///
-    alias as_array this;
     ///
     alias toString = as_array;
 
@@ -100,6 +98,16 @@ extern(D):
     ///
     bool empty() const nothrow @safe                                        { return size() == 0; }
 
+    ///
+    size_t[2] opSlice(size_t dim : 0)(size_t start, size_t end) const pure nothrow @safe @nogc { return [start, end]; }
+
+    ///
+    ref inout(T) opIndex(size_t index) inout pure nothrow @safe @nogc       { return as_array[index]; }
+    ///
+    inout(T)[] opIndex(size_t[2] slice) inout pure nothrow @safe @nogc      { return as_array[slice[0] .. slice[1]]; }
+    ///
+    inout(T)[] opIndex() inout pure nothrow @safe @nogc                     { return as_array(); }
+
     ///
     void clear()                                                            { eos(0); } // TODO: bounds-check
     ///
@@ -123,12 +131,36 @@ extern(D):
     const(T)* c_str() const nothrow @safe                                   { return data(); }
 
     // Modifiers
+    ///
+    ref basic_string opAssign()(auto ref basic_string str)                  { return assign(str.as_array); }
 //    ref basic_string assign(size_type n, T c);
     ///
     ref basic_string opAssign(const(T)[] str)                               { return assign(str); }
     ///
     ref basic_string opAssign(T c)                                          { return assign((&c)[0 .. 1]); }
 
+    ///
+    ref basic_string opIndexAssign(T c, size_t index)                       { as_array[index] = c; return this; }
+    ///
+    ref basic_string opIndexAssign(T c, size_t[2] slice)                    { as_array[slice[0] .. slice[1]] = c; return this; }
+    ///
+    ref basic_string opIndexAssign(const(T)[] str, size_t[2] slice)         { as_array[slice[0] .. slice[1]] = str[]; return this; }
+    ///
+    ref basic_string opIndexAssign(T c)                                     { as_array[] = c; return this; }
+    ///
+    ref basic_string opIndexAssign(const(T)[] str)                          { as_array[] = str[]; return this; }
+
+    ///
+    ref basic_string opIndexOpAssign(string op)(T c, size_t index)          { mixin("as_array[index] " ~ op ~ "= c;"); return this; }
+    ///
+    ref basic_string opIndexOpAssign(string op)(T c, size_t[2] slice)       { mixin("as_array[slice[0] .. slice[1]] " ~ op ~ "= c;"); return this; }
+    ///
+    ref basic_string opIndexOpAssign(string op)(const(T)[] str, size_t[2] slice)    { mixin("as_array[slice[0] .. slice[1]] " ~ op ~ "= str[];"); return this; }
+    ///
+    ref basic_string opIndexOpAssign(string op)(T c)                        { mixin("as_array[] " ~ op ~ "= c;"); return this; }
+    ///
+    ref basic_string opIndexOpAssign(string op)(const(T)[] str)             { mixin("as_array[] " ~ op ~ "= str[];"); return this; }
+
 //    ref basic_string append(size_type n, T c);
     ///
     ref basic_string append(T c)                                            { return append((&c)[0 .. 1]); }

test/stdcpp/src/string_test.d

@@ -18,12 +18,36 @@ unittest
         assert(sumOfElements_val(str) == 1500);
         assert(sumOfElements_ref(str) == 500);
 
+        str = "Hello again with a long long string woo";
+        assert(sumOfElements_val(str) == 10935);
+        assert(sumOfElements_ref(str) == 3645);
+
         std_string str2 = std_string(Default);
         assert(str2.size == 0);
         assert(str2.length == 0);
         assert(str2.empty == true);
         assert(str2[] == []);
 
+        str2 = std_string("World");
+        assert(str2[] == "World");
+        str = str2;
+        assert(str[] == "World");
+        str2 = "Direct";
+        assert(str2[] == "Direct");
+        assert(str2[2] == 'r');
+        assert(str2[2 .. 5] == "rec");
+        str2[] = "Plonk!";
+        assert(str2[] == "Plonk!");
+        str2[2] = 'a';
+        str2[3 .. 5] = "ne";
+        assert(str2[] == "Plane!");
+        str2[] = 'a';
+        str2[1 .. 5] = 'b';
+        str2[] += 1;
+        str2[1] += 1;
+        str2[2 .. 4] += 2;
+        assert(str2[] == "bdeecb");
+
         // test local instantiations...
         // there's no basic_string<char16_t> instantiation in C++
         std_wstring str3 = std_wstring("Hello"w);
@@ -48,7 +72,7 @@ int sumOfElements_ref(ref const(std_string));
 // test the ABI for calls from C++
 int fromC_val(std_string str)
 {
-    assert(str[] == "Hello");
+    assert(str[0 .. 5] == "Hello");
     assert(str.front == 'H');
     assert(str.back == 'o');
     assert(str.at(2) == 'l');
@@ -58,8 +82,6 @@ int fromC_val(std_string str)
     int r;
     foreach (e; str[])
         r += e;
-
-    assert(r == 500);
     return r;
 }