Third wave of Win64 warning cleanup

include/core/SkTDArray.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 SkTDArray_DEFINED
 #define SkTDArray_DEFINED
 
 #include "SkTypes.h"
 
 template <typename T> class SK_API SkTDArray {
 public:
     SkTDArray() {
         fReserve = fCount = 0;
         fArray = NULL;
 #ifdef SK_DEBUG
         fData = NULL;
 #endif
     }
-    SkTDArray(const T src[], size_t count) {
+    SkTDArray(const T src[], int count) {
         SkASSERT(src || count == 0);
 
         fReserve = fCount = 0;
         fArray = NULL;
 #ifdef SK_DEBUG
         fData = NULL;
 #endif
         if (count) {
             fArray = (T*)sk_malloc_throw(count * sizeof(T));
 #ifdef SK_DEBUG
@@ skipping 56 matching lines @@
         fReserve = fCount = 0;
         SkDEBUGCODE(fData = NULL;)
         return array;
     }
 
     bool isEmpty() const { return fCount == 0; }
 
     /**
      *  Return the number of elements in the array
      */
-    int count() const { return (int)fCount; }
+    int count() const { return fCount; }
 
     /**
      *  return the number of bytes in the array: count * sizeof(T)
      */
     size_t bytes() const { return fCount * sizeof(T); }
 
     T*  begin() { return fArray; }
     const T*  begin() const { return fArray; }
     T*  end() { return fArray ? fArray + fCount : NULL; }
     const T*  end() const { return fArray ? fArray + fCount : NULL; }
 
     T&  operator[](int index) {
-        SkASSERT((unsigned)index < fCount);
+        SkASSERT(index < fCount);
         return fArray[index];
     }
     const T&  operator[](int index) const {
-        SkASSERT((unsigned)index < fCount);
+        SkASSERT(index < fCount);
         return fArray[index];
     }
 
     T&  getAt(int index)  {
         return (*this)[index];
     }
     const T&  getAt(int index) const {
         return (*this)[index];
     }
 
     void reset() {
         if (fArray) {
             sk_free(fArray);
             fArray = NULL;
 #ifdef SK_DEBUG
             fData = NULL;
 #endif
             fReserve = fCount = 0;
         } else {
             SkASSERT(fReserve == 0 && fCount == 0);
         }
     }
 
     void rewind() {
         // same as setCount(0)
         fCount = 0;
     }
 
-    void setCount(size_t count) {
+    void setCount(int count) {
         if (count > fReserve) {
             this->growBy(count - fCount);
         } else {
             fCount = count;
         }
     }
 
-    void setReserve(size_t reserve) {
+    void setReserve(int reserve) {
         if (reserve > fReserve) {
             SkASSERT(reserve > fCount);
-            size_t count = fCount;
+            int count = fCount;
             this->growBy(reserve - fCount);
             fCount = count;
         }
     }
 
     T* prepend() {
         this->growBy(1);
         memmove(fArray + 1, fArray, (fCount - 1) * sizeof(T));
         return fArray;
     }
 
     T* append() {
         return this->append(1, NULL);
     }
-    T* append(size_t count, const T* src = NULL) {
-        size_t oldCount = fCount;
+    T* append(int count, const T* src = NULL) {
+        int oldCount = fCount;
         if (count)  {
             SkASSERT(src == NULL || fArray == NULL ||
                     src + count <= fArray || fArray + oldCount <= src);
 
             this->growBy(count);
             if (src) {
                 memcpy(fArray + oldCount, src, sizeof(T) * count);
             }
         }
         return fArray + oldCount;
     }
 
     T* appendClear() {
         T* result = this->append();
         *result = 0;
         return result;
     }
 
-    T* insert(size_t index) {
+    T* insert(int index) {
         return this->insert(index, 1, NULL);
     }
-    T* insert(size_t index, size_t count, const T* src = NULL) {
+    T* insert(int index, int count, const T* src = NULL) {
         SkASSERT(count);
         SkASSERT(index <= fCount);
         size_t oldCount = fCount;
         this->growBy(count);
         T* dst = fArray + index;
         memmove(dst + count, dst, sizeof(T) * (oldCount - index));
         if (src) {
             memcpy(dst, src, sizeof(T) * count);
         }
         return dst;
     }
 
-    void remove(size_t index, size_t count = 1) {
+    void remove(int index, int count = 1) {
         SkASSERT(index + count <= fCount);
         fCount = fCount - count;
         memmove(fArray + index, fArray + index + count, sizeof(T) * (fCount - index));
     }
 
-    void removeShuffle(size_t index) {
+    void removeShuffle(int index) {
         SkASSERT(index < fCount);
-        size_t newCount = fCount - 1;
+        int newCount = fCount - 1;
         fCount = newCount;
         if (index != newCount) {
             memcpy(fArray + index, fArray + newCount, sizeof(T));
         }
     }
 
     int find(const T& elem) const {
         const T* iter = fArray;
         const T* stop = fArray + fCount;
 
@@ skipping 21 matching lines @@
      * Returns true iff the array contains this element.
      */
     bool contains(const T& elem) const {
         return (this->find(elem) >= 0);
     }
 
     /**
      * Copies up to max elements into dst. The number of items copied is
      * capped by count - index. The actual number copied is returned.
      */
-    int copyRange(T* dst, size_t index, int max) const {
+    int copyRange(T* dst, int index, int max) const {
         SkASSERT(max >= 0);
         SkASSERT(!max || dst);
         if (index >= fCount) {
             return 0;
         }
         int count = SkMin32(max, fCount - index);
         memcpy(dst, fArray + index, sizeof(T) * count);
         return count;
     }
 
@@ skipping 69 matching lines @@
 
 private:
 #ifdef SK_DEBUG
     enum {
         kDebugArraySize = 16
     };
     typedef T ArrayT[kDebugArraySize];
     ArrayT* fData;
 #endif
     T*      fArray;
-    size_t  fReserve, fCount;
+    int     fReserve;
+    int     fCount;
 
-    void growBy(size_t extra) {
+    void growBy(int extra) {
         SkASSERT(extra);
 
         if (fCount + extra > fReserve) {
-            size_t size = fCount + extra + 4;
+            int size = fCount + extra + 4;
             size += size >> 2;
 
             fArray = (T*)sk_realloc_throw(fArray, size * sizeof(T));
 #ifdef SK_DEBUG
             fData = (ArrayT*)fArray;
 #endif
             fReserve = size;
         }
         fCount += extra;
     }
 };
 
 #endif