Added EnumInfo for efficient runtime enum lookup.

Author: TurkeyMan

src/urt/algorithm.d

@@ -1,6 +1,7 @@
 module urt.algorithm;
 
-import urt.traits : lvalue_of;
+import urt.meta : AliasSeq;
+import urt.traits : is_some_function, lvalue_of, Parameters, ReturnType, Unqual;
 import urt.util : swap;
 
 version = SmallSize;
@@ -56,8 +57,36 @@ auto compare(T, U)(auto ref T a, auto ref U b)
         return a < b ? -1 : (a > b ? 1 : 0);
 }
 
+size_t binary_search(Pred)(const void[] arr, size_t stride, const void* value, auto ref Pred pred)
+    if (is_some_function!Pred && is(ReturnType!Pred == int) && is(Parameters!Pred == AliasSeq!(const void*, const void*)))
+{
+    const void* p = arr.ptr;
+    size_t low = 0;
+    size_t high = arr.length;
+    while (low < high)
+    {
+        size_t mid = low + (high - low) / 2;
+
+        // should we chase the first in a sequence of same values?
+        int cmp = pred(p + mid*stride, value);
+        if (cmp < 0)
+            low = mid + 1;
+        else
+            high = mid;
+    }
+    if (low == arr.length)
+        return arr.length;
+    if (pred(p + low*stride, value) == 0)
+        return low;
+    return arr.length;
+}
+
 size_t binary_search(alias pred = void, T, Cmp...)(T[] arr, auto ref Cmp cmp_args)
+    if (!is(Unqual!T == void))
 {
+    static if (is(pred == void))
+        static assert (cmp_args.length == 1, "binary_search without a predicate requires exactly one comparison argument");
+
     T* p = arr.ptr;
     size_t low = 0;
     size_t high = arr.length;
@@ -82,6 +111,8 @@ size_t binary_search(alias pred = void, T, Cmp...)(T[] arr, auto ref Cmp cmp_arg
                 high = mid;
         }
     }
+    if (low == arr.length)
+        return arr.length;
     static if (is(pred == void))
     {
         if (p[low] == cmp_args[0])
@@ -96,22 +127,27 @@ size_t binary_search(alias pred = void, T, Cmp...)(T[] arr, auto ref Cmp cmp_arg
 }
 
 
-void qsort(alias pred = void, T)(T[] arr)
+void qsort(alias pred = void, T)(T[] arr) pure
 {
     version (SmallSize)
+        enum use_small_size_impl = true;
+    else
+        enum use_small_size_impl = false;
+
+    if (!__ctfe && use_small_size_impl)
     {
         static if (is(pred == void))
             static if (__traits(compiles, lvalue_of!T.opCmp(lvalue_of!T)))
-                static int compare(const void* a, const void* b) nothrow @nogc
+                static int compare(const void* a, const void* b) pure nothrow @nogc
                     => (*cast(const T*)a).opCmp(*cast(const T*)b);
             else
-                static int compare(const void* a, const void* b) nothrow @nogc
+                static int compare(const void* a, const void* b) pure nothrow @nogc
                     => *cast(const T*)a < *cast(const T*)b ? -1 : *cast(const T*)a > *cast(const T*)b ? 1 : 0;
         else
-            static int compare(const void* a, const void* b) nothrow @nogc
+            static int compare(const void* a, const void* b) pure nothrow @nogc
                 => pred(*cast(T*)a, *cast(T*)b);
 
-        qsort(arr[], T.sizeof, &compare, (void* a, void* b) nothrow @nogc {
+        qsort(arr[], T.sizeof, &compare, (void* a, void* b) pure nothrow @nogc {
                   swap(*cast(T*)a, *cast(T*)b);
               });
     }
@@ -121,7 +157,7 @@ void qsort(alias pred = void, T)(T[] arr)
         if (arr.length > 1)
         {
             size_t pivotIndex = arr.length / 2;
-            T* pivot = &p[pivotIndex];
+            T* pivot = p + pivotIndex;
 
             size_t i = 0;
             size_t j = arr.length - 1;
@@ -135,8 +171,8 @@ void qsort(alias pred = void, T)(T[] arr)
                 }
                 else
                 {
-                    while (pred(*cast(T*)&p[i], *cast(T*)pivot) < 0) i++;
-                    while (pred(*cast(T*)&p[j], *cast(T*)pivot) > 0) j--;
+                    while (pred(p[i], *pivot) < 0) i++;
+                    while (pred(p[j], *pivot) > 0) j--;
                 }
                 if (i <= j)
                 {
@@ -147,9 +183,9 @@ void qsort(alias pred = void, T)(T[] arr)
             }
 
             if (j > 0)
-                qsort(p[0 .. j + 1]);
+                qsort!pred(p[0 .. j + 1]);
             if (i < arr.length)
-                qsort(p[i .. arr.length]);
+                qsort!pred(p[i .. arr.length]);
         }
     }
 }
@@ -159,15 +195,15 @@ unittest
     struct S
     {
         int x;
-        int opCmp(ref const S rh) const nothrow @nogc
+        int opCmp(ref const S rh) pure const nothrow @nogc
             => x < rh.x ? -1 : x > rh.x ? 1 : 0;
     }
 
     int[5] arr = [3, 100, -1, 17, 30];
     qsort(arr);
     assert(arr == [-1, 3, 17, 30, 100]);
 
-    S[5] arr2 = [ S(3), S(100), S(-1), S(17), S(30)];
+    S[5] arr2 = [ S(3), S(100), S(-1), S(17), S(30) ];
     qsort(arr2);
     foreach (i, ref s; arr2)
         assert(s.x == arr[i]);
@@ -189,7 +225,7 @@ version (SmallSize)
     // just one generic implementation to minimise the code...
     // kinda slow though... look at all those multiplies!
     // maybe there's some way to make this faster :/
-    void qsort(void[] arr, size_t element_size, int function(const void* a, const void* b) nothrow @nogc compare, void function(void* a, void* b) nothrow @nogc swap)
+    void qsort(void[] arr, size_t element_size, int function(const void* a, const void* b) pure nothrow @nogc compare, void function(void* a, void* b) pure nothrow @nogc swap) pure
     {
         void* p = arr.ptr;
         size_t length = arr.length / element_size;