Sort GL extension strings and search to find.

src/core/SkTSort.h

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #ifndef SkTSort_DEFINED
@@ skipping 74 matching lines @@
             array[root-1] = array[child-1];
             root = child;
             child = root << 1;
         } else {
             break;
         }
     }
     array[root-1] = x;
 }
 
-/** Sorts the array of size count using comparator lessThan using a Heap Sort algorithm
+/** Sorts the array of size count using comparator lessThan using a Heap Sort algorithm. Be sure to
+ *  specialize SkTSwap if T has an efficient swap operation.
  *
  *  @param array the array to be sorted.
  *  @param count the number of elements in the array.
  *  @param lessThan a functor with bool operator()(T a, T b) which returns true if a comes before b.
  */
 template <typename T, typename C> void SkTHeapSort(T array[], size_t count, C lessThan) {
     for (size_t i = count >> 1; i > 0; --i) {
         SkTHeapSort_SiftDown(array, i, count, lessThan);
     }
 
@@ skipping 67 matching lines @@
         --depth;
 
         T* pivot = left + ((right - left) >> 1);
         pivot = SkTQSort_Partition(left, right, pivot, lessThan);
 
         SkTIntroSort(depth, left, pivot - 1, lessThan);
         left = pivot + 1;
     }
 }
 
-/** Sorts the region from left to right using comparator lessThan using a Quick Sort algorithm.
+/** Sorts the region from left to right using comparator lessThan using a Quick Sort algorithm. Be
+ *  sure to specialize SkTSwap if T has an efficient swap operation.
  *
  *  @param left the beginning of the region to be sorted.
  *  @param right the end of the region to be sorted (inclusive).
  *  @param lessThan a functor with bool operator()(T a, T b) which returns true if a comes before b.
  */
 template <typename T, typename C> void SkTQSort(T* left, T* right, C lessThan) {
     if (left >= right) {
         return;
     }
     // Limit Intro Sort recursion depth to no more than 2 * ceil(log2(n)).
     int depth = 2 * SkNextLog2(SkToU32(right - left));
     SkTIntroSort(depth, left, right, lessThan);
 }
 
 /** Sorts the region from left to right using comparator '<' using a Quick Sort algorithm. */
 template <typename T> void SkTQSort(T* left, T* right) {
     SkTQSort(left, right, SkTCompareLT<T>());
 }
 
 /** Sorts the region from left to right using comparator '* < *' using a Quick Sort algorithm. */
 template <typename T> void SkTQSort(T** left, T** right) {
     SkTQSort(left, right, SkTPointerCompareLT<T>());
 }
 
+/** Adapts a tri-state SkTSearch comparison function to a bool less-than SkTSort functor */
+template <typename T, int (COMPARE)(const T*, const T*)>
+class SkTSearchCompareLTFunctor {
+public:
+    bool operator()(const T& a, const T& b) {
+        return COMPARE(&a, &b) < 0;
+    }
+};
+
+
 #endif