One SkTSearch to rule them all. Allow key to be of different type than the array.

src/core/SkPictureFlat.h

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #ifndef SkPictureFlat_DEFINED
 #define SkPictureFlat_DEFINED
 
@@ skipping 259 matching lines @@
      *  the buffers.
      *
      *  dataToCompare() returns 2 fields before the flattened data:
      *      - checksum
      *      - size
      *  This ensures that if we see two blocks of different length, we will
      *  notice that right away, and not read any further. It also ensures that
      *  we see the checksum right away, so that most of the time it is enough
      *  to short-circuit our comparison.
      */
-    static int Compare(const SkFlatData* a, const SkFlatData* b) {
-        const uint32_t* stop = a->dataStop();
-        const uint32_t* a_ptr = a->dataToCompare() - 1;
-        const uint32_t* b_ptr = b->dataToCompare() - 1;
+    static int Compare(const SkFlatData& a, const SkFlatData& b) {
+        const uint32_t* stop = a.dataStop();
+        const uint32_t* a_ptr = a.dataToCompare() - 1;
+        const uint32_t* b_ptr = b.dataToCompare() - 1;
         // We use -1 above, so we can pre-increment our pointers in the loop
         while (*++a_ptr == *++b_ptr) {}
 
         if (a_ptr == stop) {    // sentinel
-            SkASSERT(b->dataStop() == b_ptr);
+            SkASSERT(b.dataStop() == b_ptr);
             return 0;
         }
-        SkASSERT(a_ptr < a->dataStop());
-        SkASSERT(b_ptr < b->dataStop());
+        SkASSERT(a_ptr < a.dataStop());
+        SkASSERT(b_ptr < b.dataStop());
         return (*a_ptr < *b_ptr) ? -1 : 1;
     }
 
+    // Adapts Compare to be used with SkTSearch
+    static bool Less(const SkFlatData& a, const SkFlatData& b) {
+        return Compare(a, b) < 0;
+    }
+
     int index() const { return fIndex; }
     const void* data() const { return (const char*)this + sizeof(*this); }
     void* data() { return (char*)this + sizeof(*this); }
     // Our data is always 32bit aligned, so we can offer this accessor
     uint32_t* data32() { return (uint32_t*)this->data(); }
     // Returns the size of the flattened data.
     size_t flatSize() const { return fFlatSize; }
 
     void setSentinelInCache() {
         this->setSentinel(kInCache_Sentinel);
@@ skipping 215 matching lines @@
         T* dst = new T;
         this->unflatten(dst, element);
         return dst;
     }
 
     const SkFlatData* findAndReturnFlat(const T& element) {
         SkFlatData* flat = SkFlatData::Create(fController, &element, fNextIndex, fFlattenProc);
 
         int hashIndex = ChecksumToHashIndex(flat->checksum());
         const SkFlatData* candidate = fHash[hashIndex];
-        if (candidate && !SkFlatData::Compare(flat, candidate)) {
+        if (candidate && !SkFlatData::Compare(*flat, *candidate)) {
             fController->unalloc(flat);
             return candidate;
         }
 
-        int index = SkTSearch<SkFlatData>((const SkFlatData**) fSortedData.begin(),
-                                          fSortedData.count(), flat, sizeof(flat),
-                                          &SkFlatData::Compare);
+        int index = SkTSearch<const SkFlatData,
+                              SkFlatData::Less>((const SkFlatData**) fSortedData.begin(),
+                                                fSortedData.count(), flat, sizeof(flat));
         if (index >= 0) {
             fController->unalloc(flat);
             fHash[hashIndex] = fSortedData[index];
             return fSortedData[index];
         }
 
         index = ~index;
         *fSortedData.insert(index) = flat;
         *fIndexedData.insert(flat->index()) = flat;
         SkASSERT(fSortedData.count() == fNextIndex);
@@ skipping 160 matching lines @@
     static void flattenRegion(SkOrderedWriteBuffer& buffer, const void* obj) {
         buffer.getWriter32()->writeRegion(*(SkRegion*)obj);
     }
 
     static void unflattenRegion(SkOrderedReadBuffer& buffer, void* obj) {
         buffer.getReader32()->readRegion((SkRegion*)obj);
     }
 };
 
 #endif