BBHs: void* data -> unsigned data

src/core/SkRTree.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkRTree.h"
 #include "SkTSort.h"
 
@@ skipping 26 matching lines @@
     SkASSERT(minChildren < maxChildren && minChildren > 0 && maxChildren <
              static_cast<int>(SK_MaxU16));
     SkASSERT((maxChildren + 1) / 2 >= minChildren);
     this->validate();
 }
 
 SkRTree::~SkRTree() {
     this->clear();
 }
 
-void SkRTree::insert(void* data, const SkRect& fbounds, bool defer) {
+void SkRTree::insert(unsigned opIndex, const SkRect& fbounds, bool defer) {
     SkIRect bounds;
     if (fbounds.isLargest()) {
         bounds.setLargest();
     } else {
         fbounds.roundOut(&bounds);
     }
 
     this->validate();
     if (bounds.isEmpty()) {
         SkASSERT(false);
         return;
     }
     Branch newBranch;
     newBranch.fBounds = bounds;
-    newBranch.fChild.data = data;
+    newBranch.fChild.opIndex = opIndex;
     if (this->isEmpty()) {
         // since a bulk-load into an existing tree is as of yet unimplemented (and arguably not
         // of vital importance right now), we only batch up inserts if the tree is empty.
         if (defer) {
             fDeferredInserts.push(newBranch);
             return;
         } else {
             fRoot.fChild.subtree = allocateNode(0);
             fRoot.fChild.subtree->fNumChildren = 0;
         }
@@ skipping 29 matching lines @@
             fRoot = this->bulkLoad(&fDeferredInserts);
         }
     } else {
         // TODO: some algorithm for bulk loading into an already populated tree
         SkASSERT(0 == fDeferredInserts.count());
     }
     fDeferredInserts.rewind();
     this->validate();
 }
 
-void SkRTree::search(const SkRect& fquery, SkTDArray<void*>* results) const {
+void SkRTree::search(const SkRect& fquery, SkTDArray<unsigned>* results) const {
     SkIRect query;
     fquery.roundOut(&query);
     this->validate();
     SkASSERT(0 == fDeferredInserts.count());  // If this fails, you should have flushed.
     if (!this->isEmpty() && SkIRect::IntersectsNoEmptyCheck(fRoot.fBounds, query)) {
         this->search(fRoot.fChild.subtree, query, results);
     }
     this->validate();
 }
 
@@ skipping 179 matching lines @@
 
     // replicate the sort of the winning distribution, (we can skip this if the last
     // sort ended up being best)
     if (!(axis == 1 && sortSide == 1)) {
         SkTQSort(children, children + fMaxChildren, RectLessThan(sorts[axis][sortSide]));
     }
 
     return fMinChildren - 1 + k;
 }
 
-void SkRTree::search(Node* root, const SkIRect query, SkTDArray<void*>* results) const {
+void SkRTree::search(Node* root, const SkIRect query, SkTDArray<unsigned>* results) const {
     for (int i = 0; i < root->fNumChildren; ++i) {
         if (SkIRect::IntersectsNoEmptyCheck(root->child(i)->fBounds, query)) {
             if (root->isLeaf()) {
-                results->push(root->child(i)->fChild.data);
+                results->push(root->child(i)->fChild.opIndex);
             } else {
                 this->search(root->child(i)->fChild.subtree, query, results);
             }
         }
     }
 }
 
 SkRTree::Branch SkRTree::bulkLoad(SkTDArray<Branch>* branches, int level) {
     if (branches->count() == 1) {
         // Only one branch: it will be the root
@@ skipping 114 matching lines @@
         int childCount = 0;
         for (int i = 0; i < root->fNumChildren; ++i) {
             SkASSERT(root->child(i)->fChild.subtree->fLevel == root->fLevel - 1);
             childCount += this->validateSubtree(root->child(i)->fChild.subtree,
                                                 root->child(i)->fBounds);
         }
         return childCount;
     }
 }
 
-void SkRTree::rewindInserts() {
-    SkASSERT(this->isEmpty()); // Currently only supports deferred inserts
-    while (!fDeferredInserts.isEmpty() &&
-           fClient->shouldRewind(fDeferredInserts.top().fChild.data)) {
-        fDeferredInserts.pop();
-    }
-}
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 static inline uint32_t get_area(const SkIRect& rect) {
     return rect.width() * rect.height();
 }
 
 static inline uint32_t get_overlap(const SkIRect& rect1, const SkIRect& rect2) {
     // I suspect there's a more efficient way of computing this...
     return SkMax32(0, SkMin32(rect1.fRight, rect2.fRight) - SkMax32(rect1.fLeft, rect2.fLeft)) *
            SkMax32(0, SkMin32(rect1.fBottom, rect2.fBottom) - SkMax32(rect1.fTop, rect2.fTop));
@@ skipping 11 matching lines @@
 
 // Expand 'out' to include 'joinWith'
 static inline void join_no_empty_check(const SkIRect& joinWith, SkIRect* out) {
     // since we check for empty bounds on insert, we know we'll never have empty rects
     // and we can save the empty check that SkIRect::join requires
     if (joinWith.fLeft < out->fLeft) { out->fLeft = joinWith.fLeft; }
     if (joinWith.fTop < out->fTop) { out->fTop = joinWith.fTop; }
     if (joinWith.fRight > out->fRight) { out->fRight = joinWith.fRight; }
     if (joinWith.fBottom > out->fBottom) { out->fBottom = joinWith.fBottom; }
 }