Reviewed by Alice.

        * wtf/Vector.h: Add an append that takes a pointer and length.
        Generalize the existing Vector append to work on vectors with
        any value for inlineCapacity. Change the append algorithm so
        it doesn't check capacity each time through the loop.

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@16533 268f45cc-cd09-0410-ab3c-d52691b4dbfc

diff --git a/JavaScriptCore/ChangeLog b/JavaScriptCore/ChangeLog
index ce37240ee8b90a6da7c859e6529f9eed2d59ea8f..c98eae62e21958be325d10ca679690904f1a5be3 100644 (file)
--- a/JavaScriptCore/ChangeLog
+++ b/JavaScriptCore/ChangeLog
@@ -1,3 +1,12 @@
+2006-09-22  Darin Adler  <darin@apple.com>
+
+        Reviewed by Alice.
+
+        * wtf/Vector.h: Add an append that takes a pointer and length.
+        Generalize the existing Vector append to work on vectors with
+        any value for inlineCapacity. Change the append algorithm so
+        it doesn't check capacity each time through the loop.
+
 2006-09-22  Steve Falkenburg  <sfalken@apple.com>
 
         Fix release build.

diff --git a/JavaScriptCore/wtf/Vector.h b/JavaScriptCore/wtf/Vector.h
index 26e1ca871e1d8b50924817e42090079fc26bf17e..d3d678eee623d2e30046a3c6a6e976f7bd5548e3 100644 (file)
--- a/JavaScriptCore/wtf/Vector.h
+++ b/JavaScriptCore/wtf/Vector.h
@@ -384,9 +384,12 @@ namespace WTF {
 
         void clear() { resize(0); }
 
+        template<typename U> void append(const U*, size_t);
         template<typename U> void append(const U&);
-        template<typename U> void append(const Vector<U>&);
+        template<typename U, size_t c> void append(const Vector<U, c>&);
+
         template<typename U> void insert(size_t position, const U&);
+
         void remove(size_t position);
 
         void removeLast() 
@@ -538,10 +541,22 @@ namespace WTF {
         m_impl.deallocateBuffer(oldBuffer);
     }
 
-    // templatizing these is better than just letting the conversion happen implicitly,
+    // Templatizing these is better than just letting the conversion happen implicitly,
     // because for instance it allows a PassRefPtr to be appended to a RefPtr vector
     // without refcount thrash.
 
+    template<typename T, size_t inlineCapacity> template<typename U>
+    void Vector<T, inlineCapacity>::append(const U* data, size_t dataSize)
+    {
+        size_t newSize = m_size + dataSize;
+        if (newSize > capacity())
+            data = expandCapacity(newSize, data);
+        T* dest = end();
+        for (size_t i = 0; i < dataSize; ++i)
+            new (&dest[i]) T(data[i]);
+        m_size = newSize;
+    }
+
     template<typename T, size_t inlineCapacity> template<typename U>
     inline void Vector<T, inlineCapacity>::append(const U& val)
     {
@@ -552,13 +567,10 @@ namespace WTF {
         ++m_size;
     }
 
-    template<typename T, size_t inlineCapacity> template<typename U>
-    inline void Vector<T, inlineCapacity>::append(const Vector<U>& val)
+    template<typename T, size_t inlineCapacity> template<typename U, size_t c>
+    inline void Vector<T, inlineCapacity>::append(const Vector<U, c>& val)
     {
-        if (size() + val.size() >= capacity())
-            expandCapacity(size() + val.size());
-        for (unsigned i = 0; i < val.size(); i++)
-            append(val[i]);
+        append(val.begin(), val.size());
     }
     
     template<typename T, size_t inlineCapacity> template<typename U>