Added support for the D programming languge.

It is still a bit rough around some edges, particularly with regard to multi-threading and operator overloading, and there are some documentation bits missing, but it should be fine for basic use.

The test-suite should build and run fine with the current versions of DMD, LDC and Tango (at least) on Linux x86_64 and Mac OS X 10.6.

git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk@12299 626c5289-ae23-0410-ae9c-e8d60b6d4f22

Examples/test-suite/d/li_std_vector_runme.2.d

@@ -0,0 +1,207 @@
+module li_std_vector_runme;
+
+import std.algorithm;
+import std.array;
+import std.conv;
+import std.exception;
+import std.stdio;
+import li_std_vector.li_std_vector;
+import li_std_vector.DoubleVector;
+import li_std_vector.IntVector;
+import li_std_vector.IntPtrVector;
+import li_std_vector.IntConstPtrVector;
+import li_std_vector.RealVector;
+import li_std_vector.Struct;
+import li_std_vector.StructVector;
+import li_std_vector.StructPtrVector;
+import li_std_vector.StructConstPtrVector;
+
+const size_t SIZE = 20;
+
+void main() {
+  // Basic functionality tests.
+  {
+    auto vector = new IntVector();
+    for (size_t i = 0; i < SIZE; ++i) {
+      vector ~= i * 10;
+    }
+
+    enforce(vector.length == SIZE, "length test failed.");
+
+    vector[0] = 200;
+    enforce(vector[0] == 200, "indexing test failed");
+    vector[0] = 0 * 10;
+
+    enforceThrows((){ vector[vector.length] = 777; }, "out of range test failed" );
+
+    foreach (i, value; vector) {
+      enforce(value == (i * 10), "foreach test failed, i: " ~ to!string(i));
+    }
+
+    enforce(canFind!`a == 0 * 10`(vector[]), "canFind test 1 failed");
+    enforce(canFind!`a == 10 * 10`(vector[]), "canFind test 2 failed");
+    enforce(canFind!`a == 19 * 10`(vector[]), "canFind test 3 failed");
+    enforce(!canFind!`a == 20 * 10`(vector[]), "canFind test 4 failed");
+
+    foreach (i, _; vector) {
+      enforce(indexOf(vector[], i * 10) == i, "indexOf test failed, i: " ~ to!string(i));
+    }
+
+    enforce(indexOf(vector[], 42) == -1, "non-existant item indexOf test failed");
+
+    vector.clear();
+    enforce(vector.length == 0, "clear test failed");
+  }
+
+  // To array conversion tests.
+  {
+    auto dVector = new DoubleVector();
+    for (size_t i = 0; i < SIZE; ++i) {
+      dVector ~= i * 10.1f;
+    }
+
+    double[] dArray = array(dVector[]);
+    foreach (i, value; dArray) {
+      enforce(dVector[i] == value, "slice test 1 failed, i: " ~ to!string(i));
+    }
+
+
+    auto sVector = new StructVector();
+    for (size_t i = 0; i < SIZE; i++) {
+      sVector ~= new Struct(i / 10.0);
+    }
+
+    Struct[] sArray = array(sVector[]);
+
+    for (size_t i = 0; i < SIZE; i++) {
+      // Make sure that a shallow copy has been made.
+      void* aPtr = Struct.swigGetCPtr(sArray[i]);
+      void* vPtr = Struct.swigGetCPtr(sVector[i]);
+      enforce(aPtr == vPtr, "slice test 2 failed, i: " ~ to!string(i));
+    }
+  }
+
+  // remove() tests.
+  {
+    auto iVector = new IntVector();
+    for (int i = 0; i < SIZE; i++) {
+      iVector ~= i;
+    }
+
+    iVector.remove(iVector.length - 1);
+    iVector.remove(SIZE / 2);
+    iVector.remove(0);
+
+    enforceThrows((){ iVector.remove(iVector.length); }, "remove test failed");
+  }
+
+  // Capacity tests.
+  {
+    auto dv = new DoubleVector(10);
+    enforce(dv.capacity == 10, "constructor setting capacity test failed (1)");
+    enforce(dv.length == 0, "constructor setting capacity test failed (1)");
+
+    dv.reserve(20);
+    enforce(dv.capacity == 20, "capacity test failed");
+  }
+
+  // Test the methods being wrapped.
+  {
+    auto iv = new IntVector();
+    for (int i=0; i<4; i++) {
+      iv ~= i;
+    }
+
+    double x = average(iv);
+    x += average(new IntVector([1, 2, 3, 4]));
+    RealVector rv = half(new RealVector([10.0f, 10.5f, 11.0f, 11.5f]));
+
+    auto dv = new DoubleVector();
+    for (size_t i = 0; i < SIZE; i++) {
+      dv ~= i / 2.0;
+    }
+    halve_in_place(dv);
+
+    RealVector v0 = vecreal(new RealVector());
+    float flo = 123.456f;
+    v0 ~= flo;
+    flo = v0[0];
+
+    IntVector v1 = vecintptr(new IntVector());
+    IntPtrVector v2 = vecintptr(new IntPtrVector());
+    IntConstPtrVector v3 = vecintconstptr(new IntConstPtrVector());
+
+    v1 ~= 123;
+    v2.clear();
+    v3.clear();
+
+    StructVector v4 = vecstruct(new StructVector());
+    StructPtrVector v5 = vecstructptr(new StructPtrVector());
+    StructConstPtrVector v6 = vecstructconstptr(new StructConstPtrVector());
+
+    v4 ~= new Struct(123);
+    v5 ~= new Struct(123);
+    v6 ~= new Struct(123);
+  }
+
+  // Test vectors of pointers.
+  {
+    auto vector = new StructPtrVector();
+    for (size_t i = 0; i < SIZE; i++) {
+      vector ~= new Struct(i / 10.0);
+    }
+
+    Struct[] array = array(vector[]);
+
+    for (size_t i = 0; i < SIZE; i++) {
+      // Make sure that a shallow copy has been made.
+      void* aPtr = Struct.swigGetCPtr(array[i]);
+      void* vPtr = Struct.swigGetCPtr(vector[i]);
+      enforce(aPtr == vPtr, "StructConstPtrVector test 1 failed, i: " ~ to!string(i));
+    }
+  }
+
+  // Test vectors of const pointers.
+  {
+    auto vector = new StructConstPtrVector();
+    for (size_t i = 0; i < SIZE; i++) {
+      vector ~= new Struct(i / 10.0);
+    }
+
+    Struct[] array = array(vector[]);
+
+    for (size_t i = 0; i < SIZE; i++) {
+      // Make sure that a shallow copy has been made.
+      void* aPtr = Struct.swigGetCPtr(array[i]);
+      void* vPtr = Struct.swigGetCPtr(vector[i]);
+      enforce(aPtr == vPtr, "StructConstPtrVector test 1 failed, i: " ~ to!string(i));
+    }
+  }
+
+  // Test vectors destroyed via scope.
+  {
+    {
+      scope vector = new StructVector();
+      vector ~= new Struct(0.0);
+      vector ~= new Struct(11.1);
+    }
+    {
+      scope vector = new DoubleVector();
+      vector ~= 0.0;
+      vector ~= 11.1;
+    }
+  }
+}
+
+private void enforceThrows(void delegate() dg, string errorMessage) {
+  bool hasThrown;
+  try {
+    dg();
+  } catch (Exception) {
+    hasThrown = true;
+  } finally {
+    if (!hasThrown) {
+      throw new Exception(errorMessage);
+    }
+  }
+}