Array: add capability to insert while keeping a specific order

Adds two new functions, Util.lowerBound and Util.insertSorted,
that take an array, a value and a comparator, and find the
first position at which the value can be inserted without
violating the order, in optimal time.

https://bugzilla.gnome.org/show_bug.cgi?id=666429

js/misc/util.js

@@ -232,3 +232,53 @@ function fixupPCIDescription(desc) {
 
     return out.join(' ');
 }
+
+// lowerBound:
+// @array: an array or array-like object, already sorted
+//         according to @cmp
+// @val: the value to add
+// @cmp: a comparator (or undefined to compare as numbers)
+//
+// Returns the position of the first element that is not
+// lower than @val, according to @cmp.
+// That is, returns the first position at which it
+// is possible to insert @val without violating the
+// order.
+// This is quite like an ordinary binary search, except
+// that it doesn't stop at first element comparing equal.
+
+function lowerBound(array, val, cmp) {
+    let min, max, mid, v;
+    cmp = cmp || function(a, b) { return a - b; };
+
+    if (array.length == 0)
+        return 0;
+
+    min = 0; max = array.length;
+    while (min < (max - 1)) {
+        mid = Math.floor((min + max) / 2);
+        v = cmp(array[mid], val);
+
+        if (v < 0)
+            min = mid + 1;
+        else
+            max = mid;
+    }
+
+    return (cmp(array[min], val) < 0) ? max : min;
+}
+
+// insertSorted:
+// @array: an array sorted according to @cmp
+// @val: a value to insert
+// @cmp: the sorting function
+//
+// Inserts @val into @array, preserving the
+// sorting invariants.
+// Returns the position at which it was inserted
+function insertSorted(array, val, cmp) {
+    let pos = lowerBound(array, val, cmp);
+    array.splice(pos, 0, val);
+
+    return pos;
+}