GrTArray->SkTArray & docs

Review URL: http://codereview.appspot.com/5005045/



git-svn-id: http://skia.googlecode.com/svn/trunk@2265 2bbb7eff-a529-9590-31e7-b0007b416f81

4 files changed, 6 insertions, 373 deletions

diff --git a/gpu/include/GrAllocator.h b/gpu/include/GrAllocator.h
index ae46938e1b..7652be3be5 100755
--- a/gpu/include/GrAllocator.h
+++ b/gpu/include/GrAllocator.h
@@ -12,7 +12,7 @@
 #define GrAllocator_DEFINED
 
 #include "GrConfig.h"
-#include "GrTArray.h"
+#include "SkTArray.h"
 
 class GrAllocator {
 public:
@@ -128,7 +128,7 @@ public:
 private:
     static const int NUM_INIT_BLOCK_PTRS = 8;
     
-    GrTArray<void*> fBlocks;
+    SkTArray<void*> fBlocks;
     size_t          fBlockSize;
     char            fBlockInitialStorage[NUM_INIT_BLOCK_PTRS*sizeof(void*)];
     size_t          fItemSize;
@@ -163,7 +163,7 @@ public:
      *                          and the size of subsequent blocks.
      */
     template <int N>
-    GrTAllocator(GrAlignedSTStorage<N,T>* initialBlock)
+    GrTAllocator(SkAlignedSTStorage<N,T>* initialBlock)
         : fAllocator(sizeof(T), N, initialBlock->get()) {}
     
     /**
diff --git a/gpu/include/GrClip.h b/gpu/include/GrClip.h
index 4abd8dae0e..9e235bfe91 100644
--- a/gpu/include/GrClip.h
+++ b/gpu/include/GrClip.h
@@ -14,9 +14,9 @@
 #include "GrClipIterator.h"
 #include "GrRect.h"
 #include "GrPath.h"
-#include "GrTArray.h"
 #include "GrTemplates.h"
 
+#include "SkTArray.h"
 
 class GrClip {
 public:
@@ -135,8 +135,8 @@ private:
     enum {
         kPreAllocElements = 4,
     };
-    GrAlignedSTStorage<kPreAllocElements, Element>  fListStorage;
-    GrTArray<Element>   fList;
+    SkAlignedSTStorage<kPreAllocElements, Element>  fListStorage;
+    SkTArray<Element>   fList;
 };
 #endif
 
diff --git a/gpu/include/GrTArray.h b/gpu/include/GrTArray.h
deleted file mode 100644
index 5477d25775..0000000000
--- a/gpu/include/GrTArray.h
+++ /dev/null
@@ -1,335 +0,0 @@
-
-/*
- * Copyright 2010 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-
-
-#ifndef GrTArray_DEFINED
-#define GrTArray_DEFINED
-
-#include <new>
-#include "GrTypes.h"
-#include "GrTemplates.h"
-
-// DATA_TYPE indicates that T has a trivial cons, destructor
-// and can be shallow-copied
-template <typename T, bool DATA_TYPE = false> class GrTArray {
-public:
-    GrTArray() {
-        fCount = 0;
-        fReserveCount = MIN_ALLOC_COUNT;
-        fAllocCount = 0;
-        fMemArray = NULL;
-        fPreAllocMemArray = NULL;
-    }
-
-    explicit GrTArray(int reserveCount) {
-        GrAssert(reserveCount >= 0);
-        fCount = 0;
-        fReserveCount = reserveCount > MIN_ALLOC_COUNT ? reserveCount :
-                                                         MIN_ALLOC_COUNT;
-        fAllocCount = fReserveCount;
-        fMemArray = GrMalloc(sizeof(T) * fReserveCount);
-        fPreAllocMemArray = NULL;
-    }
-
-    template <int N>
-    GrTArray(GrAlignedSTStorage<N,T>* storage) {
-        GrAssert(N > 0);
-        fCount              = 0;
-        fReserveCount       = N;
-        fAllocCount         = N;
-        fMemArray           = storage->get();
-        fPreAllocMemArray   = storage->get();
-    }
-
-    GrTArray(void* preAllocStorage, int preAllocCount) {
-        GrAssert(preAllocCount >= 0);
-        // we allow NULL,0 args and revert to the default cons. behavior
-        // this makes it possible for a owner-object to use same constructor
-        // to get either prealloc or nonprealloc behavior based using same line
-        GrAssert((NULL == preAllocStorage) == !preAllocCount);
-
-        fCount              = 0;
-        fReserveCount       = preAllocCount > 0 ? preAllocCount :
-                                                  MIN_ALLOC_COUNT;
-        fAllocCount         = preAllocCount;
-        fMemArray           = preAllocStorage;
-        fPreAllocMemArray   = preAllocStorage;
-    }
-
-    explicit GrTArray(const GrTArray& array) {
-        fCount              = array.count();
-        fReserveCount       = MIN_ALLOC_COUNT;
-        fAllocCount         = GrMax(fReserveCount, fCount);
-        fMemArray           = GrMalloc(sizeof(T) * fAllocCount);
-        fPreAllocMemArray   = NULL;
-
-        if (DATA_TYPE) {
-            memcpy(fMemArray, array.fMemArray, sizeof(T) * fCount);
-        } else {
-            for (int i = 0; i < fCount; ++i) {
-                new (fItemArray + i) T(array[i]);
-            }
-        }
-    }
-
-    GrTArray(const T* array, int count) {
-        GrAssert(count >= 0);
-        fCount              = count;
-        fReserveCount       = MIN_ALLOC_COUNT;
-        fAllocCount         = GrMax(fReserveCount, fCount);
-        fMemArray           = GrMalloc(sizeof(T) * fAllocCount);
-        fPreAllocMemArray   = NULL;
-        if (DATA_TYPE) {
-            memcpy(fMemArray, array, sizeof(T) * fCount);
-        } else {
-            for (int i = 0; i < fCount; ++i) {
-                new (fItemArray + i) T(array[i]);
-            }
-        }
-    }
-
-    GrTArray(const GrTArray& array,
-             void* preAllocStorage, int preAllocCount) {
-
-        GrAssert(preAllocCount >= 0);
-
-        // for same reason as non-copying cons we allow NULL, 0 for prealloc
-        GrAssert((NULL == preAllocStorage) == !preAllocCount);
-
-        fCount              = array.count();
-        fReserveCount       = preAllocCount > 0 ? preAllocCount :
-                                                  MIN_ALLOC_COUNT;
-        fPreAllocMemArray   = preAllocStorage;
-
-        if (fReserveCount >= fCount && preAllocCount) {
-            fAllocCount = fReserveCount;
-            fMemArray = preAllocStorage;
-        } else {
-            fAllocCount = GrMax(fCount, fReserveCount);
-            fMemArray = GrMalloc(fAllocCount * sizeof(T));
-        }
-
-        if (DATA_TYPE) {
-            memcpy(fMemArray, array.fMemArray, sizeof(T) * fCount);
-        } else {
-            for (int i = 0; i < fCount; ++i) {
-                new (fItemArray + i) T(array[i]);
-            }
-        }
-    }
-
-    GrTArray(const T* array, int count,
-             void* preAllocStorage, int preAllocCount) {
-
-        GrAssert(count >= 0);
-        GrAssert(preAllocCount >= 0);
-
-        // for same reason as non-copying cons we allow NULL, 0 for prealloc
-        GrAssert((NULL == preAllocStorage) == !preAllocCount);
-
-        fCount              = count;
-        fReserveCount       = (preAllocCount > 0) ? preAllocCount :
-                                                    MIN_ALLOC_COUNT;
-        fPreAllocMemArray   = preAllocStorage;
-
-        if (fReserveCount >= fCount && preAllocCount) {
-            fAllocCount = fReserveCount;
-            fMemArray = preAllocStorage;
-        } else {
-            fAllocCount = GrMax(fCount, fReserveCount);
-            fMemArray = GrMalloc(fAllocCount * sizeof(T));
-        }
-
-        if (DATA_TYPE) {
-            memcpy(fMemArray, array, sizeof(T) * fCount);
-        } else {
-            for (int i = 0; i < fCount; ++i) {
-                new (fItemArray + i) T(array[i]);
-            }
-        }
-    }
-
-    GrTArray& operator =(const GrTArray& array) {
-        for (int i = 0; i < fCount; ++i) {
-            fItemArray[i].~T();
-        }
-        fCount = 0;
-        checkRealloc((int)array.count());
-        fCount = array.count();
-        if (DATA_TYPE) {
-            memcpy(fMemArray, array.fMemArray, sizeof(T) * fCount);
-        } else {
-            for (int i = 0; i < fCount; ++i) {
-                new (fItemArray + i) T(array[i]);
-            }
-        }
-        return *this;
-    }
-
-    ~GrTArray() {
-        for (int i = 0; i < fCount; ++i) {
-            fItemArray[i].~T();
-        }
-        if (fMemArray != fPreAllocMemArray) {
-            GrFree(fMemArray);
-        }
-    }
-
-    void reset() { this->pop_back_n(fCount); }
-
-    int count() const { return fCount; }
-
-    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() {
-        checkRealloc(1);
-        new ((char*)fMemArray+sizeof(T)*fCount) T;
-        ++fCount;
-        return fItemArray[fCount-1];
-    }
-
-    /**
-     * 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) {
-        GrAssert(n >= 0);
-        checkRealloc(n);
-        for (int i = 0; i < n; ++i) {
-            new (fItemArray + fCount + i) T;
-        }
-        fCount += n;
-        return fItemArray + fCount - n;
-    }
-
-    void pop_back() {
-        GrAssert(fCount > 0);
-        --fCount;
-        fItemArray[fCount].~T();
-        checkRealloc(0);
-    }
-
-    void pop_back_n(int n) {
-        GrAssert(n >= 0);
-        GrAssert(fCount >= n);
-        fCount -= n;
-        for (int i = 0; i < n; ++i) {
-            fItemArray[i].~T();
-        }
-        checkRealloc(0);
-    }
-
-    // pushes or pops from the back to resize
-    void resize_back(int newCount) {
-        GrAssert(newCount >= 0);
-
-        if (newCount > fCount) {
-            push_back_n(newCount - fCount);
-        } else if (newCount < fCount) {
-            pop_back_n(fCount - newCount);
-        }
-    }
-
-    T& operator[] (int i) {
-        GrAssert(i < fCount);
-        GrAssert(i >= 0);
-        return fItemArray[i];
-    }
-
-    const T& operator[] (int i) const {
-        GrAssert(i < fCount);
-        GrAssert(i >= 0);
-        return fItemArray[i];
-    }
-
-    T& front() { GrAssert(fCount > 0); return fItemArray[0];}
-
-    const T& front() const { GrAssert(fCount > 0); return fItemArray[0];}
-
-    T& back() { GrAssert(fCount); return fItemArray[fCount - 1];}
-
-    const T& back() const { GrAssert(fCount > 0); return fItemArray[fCount - 1];}
-
-    T& fromBack(int i) {
-        GrAssert(i >= 0);
-        GrAssert(i < fCount);
-        return fItemArray[fCount - i - 1];
-    }
-
-    const T& fromBack(int i) const {
-        GrAssert(i >= 0);
-        GrAssert(i < fCount);
-        return fItemArray[fCount - i - 1];
-    }
-
-private:
-
-    static const int MIN_ALLOC_COUNT = 8;
-
-    inline void checkRealloc(int delta) {
-        GrAssert(fCount >= 0);
-        GrAssert(fAllocCount >= 0);
-
-        GrAssert(-delta <= fCount);
-
-        int newCount = fCount + delta;
-        int fNewAllocCount = fAllocCount;
-
-        if (newCount > fAllocCount) {
-            fNewAllocCount = GrMax(newCount + ((newCount + 1) >> 1),
-                                   fReserveCount);
-        } else if (newCount < fAllocCount / 3) {
-            fNewAllocCount = GrMax(fAllocCount / 2, fReserveCount);
-        }
-
-        if (fNewAllocCount != fAllocCount) {
-
-            fAllocCount = fNewAllocCount;
-            char* fNewMemArray;
-
-            if (fAllocCount == fReserveCount && NULL != fPreAllocMemArray) {
-                fNewMemArray = (char*) fPreAllocMemArray;
-            } else {
-                fNewMemArray = (char*) GrMalloc(fAllocCount*sizeof(T));
-            }
-
-            if (DATA_TYPE) {
-                memcpy(fNewMemArray, fMemArray, fCount * sizeof(T));
-            } else {
-                for (int i = 0; i < fCount; ++i) {
-                    new (fNewMemArray + sizeof(T) * i) T(fItemArray[i]);
-                    fItemArray[i].~T();
-                }
-            }
-
-            if (fMemArray != fPreAllocMemArray) {
-                GrFree(fMemArray);
-            }
-            fMemArray = fNewMemArray;
-        }
-    }
-
-    int fReserveCount;
-    int fCount;
-    int fAllocCount;
-    void*    fPreAllocMemArray;
-    union {
-        T*       fItemArray;
-        void*    fMemArray;
-    };
-};
-
-#endif
-
diff --git a/gpu/include/GrTemplates.h b/gpu/include/GrTemplates.h
index 9ffa51b4fb..63e43eed01 100644
--- a/gpu/include/GrTemplates.h
+++ b/gpu/include/GrTemplates.h
@@ -25,38 +25,6 @@ template <typename Dst, typename Src> Dst GrTCast(Src src) {
 }
 
 /**
- * Reserves memory that is aligned on double and pointer boundaries.
- * Hopefully this is sufficient for all practical purposes.
- */
-template <size_t N> class GrAlignedSStorage : GrNoncopyable {
-public:
-    void* get() { return fData; }
-private:
-    union {
-        void*   fPtr;
-        double  fDouble;
-        char    fData[N];
-    };
-};
-
-/**
- * Reserves memory that is aligned on double and pointer boundaries.
- * Hopefully this is sufficient for all practical purposes. Otherwise,
- * we have to do some arcane trickery to determine alignment of non-POD
- * types. Lifetime of the memory is the lifetime of the object.
- */
-template <int N, typename T> class GrAlignedSTStorage : GrNoncopyable {
-public:
-    /**
-     * Returns void* because this object does not initialize the
-     * memory. Use placement new for types that require a cons.
-     */
-    void* get() { return fStorage.get(); }
-private:
-    GrAlignedSStorage<sizeof(T)*N> fStorage;
-};
-
-/**
  * saves value of T* in and restores in destructor
  * e.g.:
  * {