Enhancements and a fix to templated containers.

include/core/SkTArray.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 SkTArray_DEFINED
 #define SkTArray_DEFINED
 
@@ skipping 23 matching lines @@
 template<typename T>
 inline void copyAndDelete(SkTArray<T, false>* self, char* newMemArray) {
     for (int i = 0; i < self->fCount; ++i) {
         SkNEW_PLACEMENT_ARGS(newMemArray + sizeof(T) * i, T, (self->fItemArray[i]));
         self->fItemArray[i].~T();
     }
 }
 
 }
 
+template <typename T, bool MEM_COPY> void* operator new(size_t, SkTArray<T, MEM_COPY>*, int);
+
 /** When MEM_COPY is true T will be bit copied when moved.
     When MEM_COPY is false, T will be copy constructed / destructed.
     In all cases T's constructor will be called on allocation,
     and its destructor will be called from this object's destructor.
 */
 template <typename T, bool MEM_COPY> class SkTArray {
 public:
     /**
      * Creates an empty array with no initial storage
      */
@@ skipping 30 matching lines @@
     }
 
     /**
      * assign copy of array to this
      */
     SkTArray& operator =(const SkTArray& array) {
         for (int i = 0; i < fCount; ++i) {
             fItemArray[i].~T();
         }
         fCount = 0;
-        checkRealloc((int)array.count());
+        this->checkRealloc((int)array.count());
         fCount = array.count();
         SkTArrayExt::copy(this, static_cast<const T*>(array.fMemArray));
         return *this;
     }
 
     virtual ~SkTArray() {
         for (int i = 0; i < fCount; ++i) {
             fItemArray[i].~T();
         }
         if (fMemArray != fPreAllocMemArray) {
@@ skipping 47 matching lines @@
      * Is the array empty.
      */
     bool empty() const { return !fCount; }
 
     /**
      * Adds 1 new default-constructed T value and returns in by reference. Note
      * the reference only remains valid until the next call that adds or removes
      * elements.
      */
     T& push_back() {
-        this->checkRealloc(1);
-        SkNEW_PLACEMENT((char*)fMemArray + sizeof(T) * fCount, T);
-        ++fCount;
-        return fItemArray[fCount-1];
+        T* newT = reinterpret_cast<T*>(this->push_back_raw(1));
+        SkNEW_PLACEMENT(newT, T);
+        return *newT;
     }
 
     /**
      * Version of above that uses a copy constructor to initialize the new item
      */
     T& push_back(const T& t) {
-        this->checkRealloc(1);
-        SkNEW_PLACEMENT_ARGS((char*)fMemArray + sizeof(T) * fCount, T, (t));
-        ++fCount;
-        return fItemArray[fCount-1];
+        T* newT = reinterpret_cast<T*>(this->push_back_raw(1));
+        SkNEW_PLACEMENT_ARGS(newT, T, (t));
+        return *newT;
     }
 
     /**
      * Allocates n more default T values, and returns the address of the start
      * of that new range. Note: this address is only valid until the next API
      * call made on the array that might add or remove elements.
      */
     T* push_back_n(int n) {
         SkASSERT(n >= 0);
-        this->checkRealloc(n);
+        T* newTs = reinterpret_cast<T*>(this->push_back_raw(n));
         for (int i = 0; i < n; ++i) {
-            SkNEW_PLACEMENT(fItemArray + fCount + i, T);
+            SkNEW_PLACEMENT(newTs + i, T);
         }
-        fCount += n;
-        return fItemArray + fCount - n;
+        return newTs;
     }
 
     /**
      * Version of above that uses a copy constructor to initialize all n items
      * to the same T.
      */
     T* push_back_n(int n, const T& t) {
         SkASSERT(n >= 0);
-        this->checkRealloc(n);
+        T* newTs = reinterpret_cast<T*>(this->push_back_raw(n));
         for (int i = 0; i < n; ++i) {
-            SkNEW_PLACEMENT_ARGS(fItemArray + fCount + i, T, (t));
+            SkNEW_PLACEMENT_ARGS(newTs[i], T, (t));
         }
-        fCount += n;
-        return fItemArray + fCount - n;
+        return newTs;
     }
 
     /**
      * Version of above that uses a copy constructor to initialize the n items
      * to separate T values.
      */
     T* push_back_n(int n, const T t[]) {
         SkASSERT(n >= 0);
         this->checkRealloc(n);
         for (int i = 0; i < n; ++i) {
@@ skipping 14 matching lines @@
     }
 
     /**
      * Removes the last n elements. Not safe to call when count() < n.
      */
     void pop_back_n(int n) {
         SkASSERT(n >= 0);
         SkASSERT(fCount >= n);
         fCount -= n;
         for (int i = 0; i < n; ++i) {
-            fItemArray[i].~T();
+            fItemArray[fCount + i].~T();
         }
         this->checkRealloc(0);
     }
 
     /**
      * Pushes or pops from the back to resize. Pushes will be default
      * initialized.
      */
     void resize_back(int newCount) {
         SkASSERT(newCount >= 0);
@@ skipping 127 matching lines @@
             fMemArray = sk_malloc_throw(fAllocCount * sizeof(T));
         }
 
         SkTArrayExt::copy(this, array);
     }
 
 private:
 
     static const int gMIN_ALLOC_COUNT = 8;
 
+    // Helper function that makes space for n objects, adjusts the count, but does not initialize
+    // the new objects.
+    void* push_back_raw(int n) {
+        this->checkRealloc(n);
+        void* ptr = fItemArray + fCount;
+        fCount += n;
+        return ptr;
+    }
+
     inline void checkRealloc(int delta) {
         SkASSERT(fCount >= 0);
         SkASSERT(fAllocCount >= 0);
 
         SkASSERT(-delta <= fCount);
 
         int newCount = fCount + delta;
         int newAllocCount = fAllocCount;
 
         if (newCount > fAllocCount || newCount < (fAllocCount / 3)) {
@@ skipping 14 matching lines @@
 
             SkTArrayExt::copyAndDelete<T>(this, newMemArray);
 
             if (fMemArray != fPreAllocMemArray) {
                 sk_free(fMemArray);
             }
             fMemArray = newMemArray;
         }
     }
 
+    friend void* operator new<T>(size_t, SkTArray*, int);
+
     template<typename X> friend void SkTArrayExt::copy(SkTArray<X, true>* that, const X*);
     template<typename X> friend void SkTArrayExt::copyAndDelete(SkTArray<X, true>* that, char*);
 
     template<typename X> friend void SkTArrayExt::copy(SkTArray<X, false>* that, const X*);
     template<typename X> friend void SkTArrayExt::copyAndDelete(SkTArray<X, false>* that, char*);
 
     int fReserveCount;
     int fCount;
     int fAllocCount;
     void*    fPreAllocMemArray;
     union {
         T*       fItemArray;
         void*    fMemArray;
     };
 };
 
+// Use the below macro (SkNEW_APPEND_TO_TARRAY) rather than calling this directly
+template <typename T, bool MEM_COPY>
+void* operator new(size_t, SkTArray<T, MEM_COPY>* array, int atIndex) {
+    // Currently, we only support adding to the end of the array. When the array class itself
+    // supports random insertion then this should be updated.
+    // SkASSERT(atIndex >= 0 && atIndex <= array->count());
+    SkASSERT(atIndex == array->count());
+    return array->push_back_raw(1);
+}
+
+// Constructs a new object as the last element of an SkTArray.
+#define SkNEW_APPEND_TO_TARRAY(array_ptr, type_name, args)  \
+    (new ((array_ptr), (array_ptr)->count()) type_name args)
+
+
 /**
  * Subclass of SkTArray that contains a preallocated memory block for the array.
  */
 template <int N, typename T, bool MEM_COPY = false>
 class SkSTArray : public SkTArray<T, MEM_COPY> {
 private:
     typedef SkTArray<T, MEM_COPY> INHERITED;
 
 public:
     SkSTArray() : INHERITED(&fStorage) {
@@ skipping 18 matching lines @@
     SkSTArray& operator= (const INHERITED& array) {
         INHERITED::operator=(array);
         return *this;
     }
 
 private:
     SkAlignedSTStorage<N,T> fStorage;
 };
 
 #endif