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.1.d

@@ -0,0 +1,219 @@
+module li_std_vector_runme;
+
+import tango.core.Exception;
+import tango.io.Stdout;
+import Integer = tango.text.convert.Integer;
+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;
+    }
+
+    if (vector.length != SIZE) {
+      throw new Exception("length test failed.");
+    }
+
+    vector[0] = 200;
+    if (vector[0] != 200) {
+      throw new Exception("indexing test failed");
+    }
+    vector[0] = 0 * 10;
+
+    try {
+      vector[vector.length] = 777;
+      throw new Exception("out of range test failed");
+    } catch (NoSuchElementException) {
+    }
+
+    foreach (i, value; vector) {
+      if (value != (i * 10)) {
+	throw new Exception("foreach test failed, i: " ~ Integer.toString(i));
+      }
+    }
+
+    vector.clear();
+    if (vector.size != 0) {
+      throw new Exception("clear test failed");
+    }
+  }
+
+  // Slice tests.
+  {
+    auto dVector = new DoubleVector();
+    for (size_t i = 0; i < SIZE; ++i) {
+      dVector ~= i * 10.1f;
+    }
+
+    double[] dArray = dVector[];
+    foreach (i, value; dArray) {
+      if (dVector[i] != value) {
+	throw new Exception("slice test 1 failed, i: " ~ Integer.toString(i));
+      }
+    }
+
+
+    auto sVector = new StructVector();
+    for (size_t i = 0; i < SIZE; i++) {
+      sVector ~= new Struct(i / 10.0);
+    }
+
+    Struct[] array = sVector[];
+
+    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(sVector[i]);
+      if (aPtr != vPtr) {
+	throw new Exception("slice test 2 failed, i: " ~
+	  Integer.toString(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);
+
+    try {
+      iVector.remove(iVector.size);
+      throw new Exception("remove test failed");
+    } catch (NoSuchElementException) {
+    }
+  }
+
+  // Capacity tests.
+  {
+    auto dv = new DoubleVector(10);
+    if ((dv.capacity != 10) || (dv.length != 0)) {
+      throw new Exception("constructor setting capacity test failed");
+    }
+
+    // TODO: Is this really required (and spec'ed) behavior?
+    dv.capacity = 20;
+    if (dv.capacity != 20) {
+      throw new Exception("capacity test 1 failed");
+    }
+
+    dv ~= 1.11;
+    try {
+      dv.capacity = dv.length - 1;
+      throw new Exception("capacity test 2 failed");
+    } catch (IllegalArgumentException) {
+    }
+  }
+
+  // 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 = 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]);
+      if (aPtr != vPtr) {
+	throw new Exception("StructPtrVector test 1 failed, i: " ~
+	  Integer.toString(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 = 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]);
+      if (aPtr != vPtr) {
+	throw new Exception("StructConstPtrVector test 1 failed, i: " ~
+	  Integer.toString(i));
+      }
+    }
+  }
+
+  // Test vectors destroyed via dispose().
+  {
+    {
+      scope vector = new StructVector();
+      vector ~= new Struct(0.0);
+      vector ~= new Struct(11.1);
+    }
+    {
+      scope vector = new DoubleVector();
+      vector ~= 0.0;
+      vector ~= 11.1;
+    }
+  }
+}