Merge pull request #2708 from TurkeyMan/std_vector

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

Author: dlang-bot

src/core/stdcpp/vector.d

@@ -50,9 +50,6 @@ extern(D):
     ///
     alias const_pointer = const(T)*;
 
-    ///
-    alias as_array this;
-
     /// MSVC allocates on default initialisation in debug, which can't be modelled by D `struct`
     @disable this();
 
@@ -62,27 +59,52 @@ extern(D):
     alias opDollar = length;
 
     ///
-    ref inout(T) front() inout pure nothrow @safe @nogc                     { return this[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]]; }
     ///
-    ref inout(T) back() inout pure nothrow @safe @nogc                      { return this[$-1]; }
+    inout(T)[] opIndex() inout pure nothrow @safe @nogc                     { return as_array(); }
 
+    ///
+    ref vector opAssign(U)(auto ref vector!(U, Alloc) s)                    { opAssign(s.as_array); return this; }
+    ///
+    ref vector opAssign(T[] array)
+    {
+        clear();
+        reserve(array.length);
+        insert(0, array);
+        return this;
+    }
 
-    // WIP...
+    ///
+    void opIndexAssign()(auto ref T val, size_t index)                      { as_array[index] = val; }
+    ///
+    void opIndexAssign()(auto ref T val, size_t[2] slice)                   { as_array[slice[0] .. slice[1]] = val; }
+    ///
+    void opIndexAssign(T[] val, size_t[2] slice)                            { as_array[slice[0] .. slice[1]] = val[]; }
+    ///
+    void opIndexAssign()(auto ref T val)                                    { as_array[] = val; }
+    ///
+    void opIndexAssign(T[] val)                                             { as_array[] = val[]; }
 
-//    this(size_type count);
-//    this(size_type count, ref const(value_type) val);
-//    this(size_type count, ref const(value_type) val, ref const(allocator_type) al);
-//    this(ref const(vector) x);
-//    this(iterator first, iterator last);
-//    this(iterator first, iterator last, ref const(allocator_type) al = defaultAlloc);
-//    this(const_iterator first, const_iterator last);
-//    this(const_iterator first, const_iterator last, ref const(allocator_type) al = defaultAlloc);
-//    this(T[] arr)                                                     { this(arr.ptr, arr.ptr + arr.length); }
-//    this(T[] arr, ref const(allocator_type) al = defaultAlloc)        { this(arr.ptr, arr.ptr + arr.length); }
-//    this(const(T)[] arr)                                              { this(arr.ptr, arr.ptr + arr.length); }
-//    this(const(T)[] arr, ref const(allocator_type) al = defaultAlloc) { this(arr.ptr, arr.ptr + arr.length); }
+    ///
+    void opIndexOpAssign(string op)(auto ref T val, size_t index)           { mixin("as_array[index] " ~ op ~ "= val;"); }
+    ///
+    void opIndexOpAssign(string op)(auto ref T val, size_t[2] slice)        { mixin("as_array[slice[0] .. slice[1]] " ~ op ~ "= val;"); }
+    ///
+    void opIndexOpAssign(string op)(T[] val, size_t[2] slice)               { mixin("as_array[slice[0] .. slice[1]] " ~ op ~ "= val[];"); }
+    ///
+    void opIndexOpAssign(string op)(auto ref T val)                         { mixin("as_array[] " ~ op ~ "= val;"); }
+    ///
+    void opIndexOpAssign(string op)(T[] val)                                { mixin("as_array[] " ~ op ~ "= val[];"); }
 
-//    ref vector opAssign(ref const(vector) s);
+    ///
+    ref inout(T) front() inout pure nothrow @safe @nogc                     { return as_array[0]; }
+    ///
+    ref inout(T) back() inout pure nothrow @safe @nogc                      { return as_array[$-1]; }
 
     ///
     ref vector opOpAssign(string op : "~")(auto ref T item)                 { push_back(forward!item); return this; }
@@ -109,7 +131,7 @@ extern(D):
         ///
         this(DefaultConstruct) @nogc                                        { _Alloc_proxy(); }
         ///
-        this(size_t count)
+        this()(size_t count)
         {
             _Alloc_proxy();
             _Buy(count);
@@ -125,7 +147,7 @@ extern(D):
             _Get_data()._Mylast = _Ufill(_Get_data()._Myfirst, count, val);
         }
         ///
-        this(T[] array)
+        this()(T[] array)
         {
             _Alloc_proxy();
             _Buy(array.length);
@@ -209,16 +231,17 @@ extern(D):
         }
 
         ///
-        void clear() nothrow
+        void clear()
         {
             _Base._Orphan_all();
             _Destroy(_Get_data()._Myfirst, _Get_data()._Mylast);
             _Get_data()._Mylast = _Get_data()._Myfirst;
         }
 
         ///
-        void resize(const size_type newsize)
+        void resize()(const size_type newsize)
         {
+            static assert(is(typeof({static T i;})), T.stringof ~ ".this() is annotated with @disable.");
             _Resize(newsize, (pointer _Dest, size_type _Count) => _Udefault(_Dest, _Count));
         }
 
@@ -267,7 +290,7 @@ extern(D):
                 // nothing to do, avoid invalidating iterators
             }
             else if (_Count > _Unused_capacity())
-            {    // reallocate
+            {   // reallocate
                 const size_type _Oldsize = size();
 
 //                if (_Count > max_size() - _Oldsize)
@@ -306,7 +329,7 @@ extern(D):
                 _Change_array(_Newvec, _Newsize, _Newcapacity);
             }
             else
-            {    // Attempt to provide the strong guarantee for EmplaceConstructible failure.
+            {   // Attempt to provide the strong guarantee for EmplaceConstructible failure.
                 // If we encounter copy/move construction/assignment failure, provide the basic guarantee.
                 // (For one-at-back, this provides the strong guarantee.)
 
@@ -347,7 +370,7 @@ extern(D):
                     }
                 }
                 else
-                {    // affected elements don't overlap before/after
+                {   // affected elements don't overlap before/after
                     pointer _Relocated = _Where + _Count;
                     _Get_data()._Mylast = _Utransfer!true(_Where, _Oldlast, _Relocated);
                     _Destroy(_Where, _Oldlast);
@@ -650,7 +673,7 @@ extern(D):
                 _Backout._Emplace_back(val);
             return _Backout._Release();
         }
-        pointer _Udefault(pointer _Dest, size_t _Count)
+        pointer _Udefault()(pointer _Dest, size_t _Count)
         {
             // TODO: if zero init, then fast-path to zeromem
             auto _Backout = _Uninitialized_backout(_Dest);
@@ -716,10 +739,6 @@ extern(D):
     {
         static assert(false, "C++ runtime not supported");
     }
-
-private:
-    // HACK: because no rvalue->ref
-    __gshared static immutable allocator_type defaultAlloc;
 }
 
 

test/stdcpp/src/vector.cpp

@@ -1,17 +1,60 @@
 #include <vector>
 
+extern int vectorTest_numAllocated;
+
+struct NotPOD
+{
+    NotPOD() = delete;
+    NotPOD(int a)
+    {
+        for (int i = 0; i < 5; ++i)
+            x[i] = a + i + 1;
+        wasInit = true;
+        ++vectorTest_numAllocated;
+    }
+    NotPOD(const NotPOD& rh)
+    {
+        for (int i = 0; i < 5; ++i)
+            x[i] = rh.x[i];
+        wasInit = rh.wasInit;
+        if (rh.wasInit)
+            ++vectorTest_numAllocated;
+    }
+    NotPOD(NotPOD&& rh)
+    {
+        for (int i = 0; i < 5; ++i)
+            x[i] = rh.x[i];
+        wasInit = rh.wasInit;
+        rh.wasInit = false;
+    }
+    ~NotPOD()
+    {
+        if (wasInit)
+            --vectorTest_numAllocated;
+    }
+
+    int x[5];
+    bool wasInit;
+};
+
 int fromC_val(std::vector<int>);
 int fromC_ref(const std::vector<int>&);
+int fromC_nonPod_val(std::vector<NotPOD>);
 
-int sumOfElements_ref(const std::vector<int>& arr)
+int sumOfElements_ref(const std::vector<int>& vec)
 {
     int r = 0;
-    for (std::size_t i = 0; i < arr.size(); ++i)
-        r += arr[i];
+    for (std::size_t i = 0; i < vec.size(); ++i)
+        r += vec[i];
     return r;
 }
 
-int sumOfElements_val(std::vector<int> arr)
+int sumOfElements_val(std::vector<int> vec)
+{
+    return sumOfElements_ref(vec) + fromC_ref(vec) + fromC_val(vec);
+}
+
+int nonPod_val(std::vector<NotPOD> vec)
 {
-    return sumOfElements_ref(arr) + fromC_ref(arr) + fromC_val(arr);
+    return vec.size() == 3 && vec[2].x[0] == 4 && fromC_nonPod_val(vec);
 }

test/stdcpp/src/vector_test.d

@@ -1,10 +1,5 @@
 import core.stdcpp.vector;
 
-struct CustomInit
-{
-    int x = 10;
-}
-
 unittest
 {
     // test vector a bit
@@ -46,25 +41,76 @@ unittest
     vec = vector!int([1, 2, 3, 4]);
     vec2 = vec;
     assert(vec2[] == [1, 2, 3, 4]);
+    vec = [1, 2, 3];
+    assert(vec[] == [1, 2, 3]);
+    vec[] = 0;
+    assert(vec[] == [0, 0, 0]);
 
     vec2.emplace(1, 10);
-    vec2.emplace(3, 20);
+    vec2.emplace(3, 0);
+    vec2[3] = 20;
+    vec2[4 .. 6] = [8, 9];
+    vec2[1] *= 10;
     vec2[4 .. 6] *= 10;
-    assert(vec2[] == [1, 10, 2, 20, 30, 40]);
+    vec2[3 .. 5] *= [10, 100];
+    vec2[] *= 2;
+    vec2[] *= [10, 1, 10, 1, 1, 2];
+    assert(vec2[] == [20, 200, 40, 400, 16000, 360]);
 
     // test local instantiations...
     // there's no vector<float> instantiation in C++
     vector!CustomInit vec3 = vector!CustomInit(1);
     vec3.push_back(CustomInit(1));
     assert(vec3[0].x == 10 && vec3[1].x == 1);
+
+    // test out a non-pod type...
+    {
+        auto vec4 = vector!NotPOD(2, NotPOD(2));
+        vec4.push_back(NotPOD(3));
+        assert(nonPod_val(vec4) == 1);
+    }
+    assert(vectorTest_numAllocated == 0);
+}
+
+struct CustomInit
+{
+    int x = 10;
 }
 
 
 extern(C++):
 
+__gshared int vectorTest_numAllocated = 0;
+
+struct NotPOD
+{
+    this() @disable;
+    this(int a)
+    {
+        x[] = [a+1, a+2, a+3, a+4, a+5];
+        wasInit = true;
+        ++vectorTest_numAllocated;
+    }
+    this(this)
+    {
+        if (wasInit)
+            ++vectorTest_numAllocated;
+    }
+    ~this()
+    {
+        if (wasInit)
+            --vectorTest_numAllocated;
+    }
+
+    int[5] x = [1, 2, 3, 4, 5];
+    bool wasInit;
+}
+
 // test the ABI for calls to C++
 int sumOfElements_val(vector!int vec);
 int sumOfElements_ref(ref const(vector!int) vec);
+int nonPod_val(vector!NotPOD vec);
+
 
 // test the ABI for calls from C++
 int fromC_val(vector!int vec)
@@ -74,7 +120,7 @@ int fromC_val(vector!int vec)
     assert(vec.back == 5);
 
     int r;
-    foreach (e; vec)
+    foreach (e; vec[])
         r += e;
 
     assert(r == 15);
@@ -84,7 +130,12 @@ int fromC_val(vector!int vec)
 int fromC_ref(ref const(vector!int) vec)
 {
     int r;
-    foreach (e; vec)
+    foreach (e; vec[])
         r += e;
     return r;
 }
+
+int fromC_nonPod_val(vector!NotPOD vec)
+{
+    return vec.size() == 3 && vec[1].x[4] == 7;
+}