indigo. tools. vector

Implements a random-access-iterator for Vector.  Obtain an iterator from a vector with Vector.begin or Vector.end.  You can then navigate through the vector with the arithmetic operators, and compare iterators with each other.

The value property can be used to obtain/change the value the iterator points to (note that you cannot use operator * for this purpose).  The ptr property returns a pointer to the item, which is useful for structs as items.

Note

The iterator will not check for vector bounds, not even in debug mode.  You always have to ensure it points to a valid item in a vector, or to Vector.end.

Wraps the builtin dynamic arrays.  It tries to fully behave like one, and greatly simplifies their use.  It automatically handles allocation of needed space in an efficient manner, and provides fast index-based access and a lot of convenience functions.  This comes at a cost: It is slightly larger than a dynamic array (12 bytes instead of 8 on a 32 bit machine).  Similar containers are List and LinkedList.  There are some hints on which container to choose (Container types).

Vector implements almost all of the functions that QVector (http://doc.trolltech.com/4.0/qvector.html) has, thus also providing an STL-compatible interface, as far as this is possible in D.  Finally Vector implements the standard properties and operators of D.

The Vector is “automagically” instantiated with or without support for comparisons and sorting, depending on the type you supply.

Vector!(int) sortableVector;
Vector!(structWithoutOpCmp) unsortableVector;

To access items, use operator [], ptrAt(), at() or value(size_t).  Use data to convert the vector into a dynamic array, and ptr to obtain a pointer to the first element.

To find all occurences of a particular value in a vector, use indexOf() or lastIndexOf().  Both return the index of the matching item, or length if they could not find one.  If you simply want to check whether the vector contains a value, use contains().  Use count(T) to count the number of occurences.

To change the contents of the vector, there are the functions insert(size_t, T), remove(size_t), prepend(T) and append(T).  While append(T) is fast (constant time), the others can be slow for large vectors.  Use List or LinkedList if you need fast insertions/deletions.  If you need to concatenate a number of vectors, arrays or items, use appendAll().

A vector can be resized at any time by calling resize() or changing the length property.  Other functions like append(T) change the length as needed.  Vector tries to reduce the number of reallocations by preallocating more memory than actually needed.  If you know in advance approximately how many items the vector will contain, call reserve().  Call capacity to find out how much memory the vector actually allocated.

Vector also provides iterator-based access with Iterator.  These are random-access-iterators with full operator overloads.  The only difference is that you cannot use operator * to retrieve the value the iterator points to.  Use VectorIterator.value instead:

Vector!(int) vec;
// ...
for (vec.Iterator iter = vec.begin, endIter = vec.end; iter != endIter; ++iter)
  printf("%i\n", iter.value);

Note

If you store objects (i.e. instances of a class) in a vector, the vector only stores references to the objects.  They are initialized with null by default.  Functions like contains() always compare on identity (with is).

If you store pointers, object references or dynamic arrays in the container, they will not get nullified automatically when deleting items.  This may lead to space waste because the garbage collector thinks they are still being used.  Call squeeze() to get rid of them.