Add SkSTDArray.

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"
+#include "SkTemplates.h"
 
 template <typename T> class SK_API SkTDArray {
 public:
     SkTDArray() {
-        fReserve = fCount = 0;
-        fArray = NULL;
-#ifdef SK_DEBUG
-        fData = NULL;
-#endif
+        this->init(NULL, 0, NULL, 0);
     }
     SkTDArray(const T src[], size_t 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
-            fData = (ArrayT*)fArray;
-#endif
-            memcpy(fArray, src, sizeof(T) * count);
-            fReserve = fCount = count;
-        }
+        this->init(src, count, NULL, 0);
     }
     SkTDArray(const SkTDArray<T>& src) {
-        fReserve = fCount = 0;
-        fArray = NULL;
-#ifdef SK_DEBUG
-        fData = NULL;
-#endif
-        SkTDArray<T> tmp(src.fArray, src.fCount);
-        this->swap(tmp);
+        this->init(src.fArray, src.fCount, NULL, 0);
     }
+
     ~SkTDArray() {
-        sk_free(fArray);
+        if (fArray != fPreAllocMemArray) {
+            sk_free(fArray);
+        }
     }
 
     SkTDArray<T>& operator=(const SkTDArray<T>& src) {
         if (this != &src) {
             if (src.fCount > fReserve) {
                 SkTDArray<T> tmp(src.fArray, src.fCount);
                 this->swap(tmp);
             } else {
                 memcpy(fArray, src.fArray, sizeof(T) * src.fCount);
                 fCount = src.fCount;
             }
         }
         return *this;
     }
 
     friend bool operator==(const SkTDArray<T>& a, const SkTDArray<T>& b) {
         return  a.fCount == b.fCount &&
                 (a.fCount == 0 ||
                  !memcmp(a.fArray, b.fArray, a.fCount * sizeof(T)));
     }
 
     void swap(SkTDArray<T>& other) {
         SkTSwap(fArray, other.fArray);
-#ifdef SK_DEBUG
-        SkTSwap(fData, other.fData);
-#endif
         SkTSwap(fReserve, other.fReserve);
         SkTSwap(fCount, other.fCount);
     }
 
     /** Return a ptr to the array of data, to be freed with sk_free. This also
         resets the SkTDArray to be empty.
      */
     T* detach() {
         T* array = fArray;
-        fArray = NULL;
-        fReserve = fCount = 0;
-        SkDEBUGCODE(fData = NULL;)
+        if (fArray == fPreAllocMemArray) {

[reed1, 2013/04/26 16:06:52]

 && fCount > 0 ?

[bungeman-skia, 2013/04/26 16:26:16]

I did this equivalently in PS5 with '&& fArray != NULL'. I was thinking about
this from the perspective of "if array starts out NULL then it should finish
NULL". Testing against count seems to be stating "if the count is 0, just return
whatever, it shouldn't matter". In this case both should have the same results
since I'm trying to maintain "if count==0 then fArray==NULL". This is true in
PS5, but not here in PS2.

+            array = (T*)sk_malloc_throw(fCount * sizeof(T));
+            memcpy(array, fPreAllocMemArray, fCount * sizeof(T));
+        }
+        this->init(NULL, 0, fPreAllocMemArray, fPreAllocMemArraySize);
         return array;
     }
 
     bool isEmpty() const { return fCount == 0; }
 
     /**
      *  Return the number of elements in the array
      */
     int count() const { return (int)fCount; }
 
@@ skipping 17 matching lines @@
     }
 
     T&  getAt(int index)  {
         return (*this)[index];
     }
     const T&  getAt(int index) const {
         return (*this)[index];
     }
 
     void reset() {
-        if (fArray) {
+        if (fArray != fPreAllocMemArray) {
             sk_free(fArray);
-            fArray = NULL;
-#ifdef SK_DEBUG
-            fData = NULL;
-#endif
-            fReserve = fCount = 0;
-        } else {
-            SkASSERT(fReserve == 0 && fCount == 0);
         }
+        this->init(NULL, 0, fPreAllocMemArray, fPreAllocMemArraySize);
     }
 
     void rewind() {
         // same as setCount(0)
         fCount = 0;
     }
 
     void setCount(size_t count) {
         if (count > fReserve) {
             this->growBy(count - fCount);
@@ skipping 176 matching lines @@
                 visitor(*curr);
             }
         }
     }
 
 #ifdef SK_DEBUG
     void validate() const {
         SkASSERT((fReserve == 0 && fArray == NULL) ||
                  (fReserve > 0 && fArray != NULL));
         SkASSERT(fCount <= fReserve);
-        SkASSERT(fData == (ArrayT*)fArray);
     }
 #endif
 
+protected:
+    template <size_t N> SkTDArray(SkAlignedSTStorage<N, T>* storage) {
+        this->init(NULL, 0, (T*)storage->get(), N);
+    }
+    template <size_t N> SkTDArray(const T src[], size_t count, SkAlignedSTStorage<N, T>* storage) {
+        this->init(src, count, (T*)storage->get(), N);
+    }
+    template <size_t N> SkTDArray(const SkTDArray<T>& src, SkAlignedSTStorage<N, T>* storage) {
+        this->init(src.fData, src.fCount, (T*)storage->get(), N);
+    }
+
+    void init(const T* src, size_t count, T* preAllocStorage, size_t preAllocCount) {
+        SkASSERT(src || count == 0);
+
+        fCount = count;
+        fReserve = preAllocCount;
+        fPreAllocMemArray = preAllocStorage;
+        fPreAllocMemArraySize = preAllocCount;
+        fArray = preAllocStorage;
+        if (count) {
+            if (NULL == preAllocStorage || fCount > fReserve) {
+                fArray = (T*)sk_malloc_throw(fCount * sizeof(T));
+                fReserve = fCount = count;
+            }
+            memcpy(fArray, src, sizeof(T) * count);
+        }
+    }
+
 private:
-#ifdef SK_DEBUG
-    enum {
-        kDebugArraySize = 16
-    };
-    typedef T ArrayT[kDebugArraySize];
-    ArrayT* fData;

[bungeman-skia, 2013/04/25 22:41:30]

I removed fData here as it was somewhat of a pain to keep around, and all modern
debuggers allow you to see any pointer as an array (with a@n or a,n) anyway.

-#endif
-    T*      fArray;
-    size_t  fReserve, fCount;
+    T* fArray;
+    T* fPreAllocMemArray;
+    size_t fReserve, fCount, fPreAllocMemArraySize;
 
     void growBy(size_t extra) {
         SkASSERT(extra);
 
         if (fCount + extra > fReserve) {
             size_t size = fCount + extra + 4;
             size += size >> 2;
 
-            fArray = (T*)sk_realloc_throw(fArray, size * sizeof(T));
-#ifdef SK_DEBUG
-            fData = (ArrayT*)fArray;
-#endif
+            if (fArray == fPreAllocMemArray) {
+                fArray = (T*)sk_malloc_throw(size * sizeof(T));
+                memcpy(fArray, fPreAllocMemArray, fCount * sizeof(T));
+            } else {
+                fArray = (T*)sk_realloc_throw(fArray, size * sizeof(T));
+            }
             fReserve = size;
         }
         fCount += extra;
     }
 };
 
+
+/**
+ * Subclass of SkTDArray that contains a preallocated memory block for the array.
+ */
+template <size_t N, typename T>

[reed1, 2013/04/26 16:06:52]

dox: N is the number of elements or the number of bytes?

[bungeman-skia, 2013/04/26 16:26:16]

The number of elements. Will doc.

+class SkSTDArray : public SkTDArray<T> {
+private:
+    typedef SkTDArray<T> INHERITED;
+
+public:
+    SkSTDArray() : INHERITED(&fStorage) {
+    }
+
+    SkSTDArray(const T* src, int count) : INHERITED(src, count, &fStorage) {
+    }
+
+    SkSTDArray(const SkSTDArray& src) : INHERITED(src, &fStorage) {

[reed1, 2013/04/26 16:06:52]

Do we need to support copying from another S version instead of just SkTDArray&
src?

[bungeman-skia, 2013/04/26 16:26:16]

I modeled this after SkTArray/SkSTArray, which is to say have the 'S' version
have matching constructors to the 'T' version plus and explicit copy from
INHERITED. I think all other cases can be handled just as well by the (src,
count) constructor.

+    }
+
+    explicit SkSTDArray(const INHERITED& src) : INHERITED(src, &fStorage) {
+    }
+
+    SkSTDArray& operator= (const SkSTDArray& that) {
+        return *this = *(const INHERITED*)&that;
+    }
+
+    SkSTDArray& operator= (const INHERITED& that) {
+        INHERITED::operator=(that);
+        return *this;
+    }
+
+private:
+    SkAlignedSTStorage<N, T> fStorage;
+};
+
 #endif