Vector::insert and Vector::append may use memcpy for POD types

Source/wtf/Vector.h

 /*
  *  Copyright (C) 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Library General Public
  *  License as published by the Free Software Foundation; either
  *  version 2 of the License, or (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 144 matching lines @@
             memmove(dst, src, reinterpret_cast<const char*>(srcEnd) - reinterpret_cast<const char*>(src));
         }
     };
 
     template <bool canCopyWithMemcpy, typename T>
     struct VectorCopier;
 
     template<typename T>
     struct VectorCopier<false, T>
     {
-        static void uninitializedCopy(const T* src, const T* srcEnd, T* dst)
+        template<typename U>
+        static void uninitializedCopy(const T* src, const T* srcEnd, U* dst)

[Mikhail, 2014/02/25 14:11:32]

I'd change it to

template<typename U>
static void uninitializedCopy(const U* src, const U* srcEnd, T* dst)

because the type 'T' is usually used as a native vector type and the type 'U' -
as something else, otherwise it is a bit misleading imho.

[w.bielawski, 2014/02/26 16:40:44]

Done.

         {
             while (src != srcEnd) {
-                new (NotNull, dst) T(*src);
+                new (NotNull, dst) U(*src);
                 ++dst;
                 ++src;
             }
         }
     };
 
     template<typename T>
     struct VectorCopier<true, T>
     {
         static void uninitializedCopy(const T* src, const T* srcEnd, T* dst)
         {
             memcpy(dst, src, reinterpret_cast<const char*>(srcEnd) - reinterpret_cast<const char*>(src));
         }
+        template<typename U>
+        static void uninitializedCopy(const T* src, const T* srcEnd, U* dst)
+        {
+            VectorCopier<false, T>::uninitializedCopy(src, srcEnd, dst);
+        }
     };
 
     template <bool canFillWithMemset, typename T>
     struct VectorFiller;
 
     template<typename T>
     struct VectorFiller<false, T>
     {
         static void uninitializedFill(T* dst, T* dstEnd, const T& val)
         {
@@ skipping 764 matching lines @@
     template<typename T, size_t inlineCapacity, typename Allocator> template<typename U>
     void Vector<T, inlineCapacity, Allocator>::append(const U* data, size_t dataSize)
     {
         size_t newSize = m_size + dataSize;
         if (newSize > capacity()) {
             data = expandCapacity(newSize, data);
             ASSERT(begin());
         }
         RELEASE_ASSERT(newSize >= m_size);
         T* dest = end();
-        for (size_t i = 0; i < dataSize; ++i)
-            new (NotNull, &dest[i]) T(data[i]);
+        VectorCopier<VectorTraits<T>::canCopyWithMemcpy, U>::uninitializedCopy(data, &data[dataSize], dest);
         m_size = newSize;
     }
 
     template<typename T, size_t inlineCapacity, typename Allocator> template<typename U>
     ALWAYS_INLINE void Vector<T, inlineCapacity, Allocator>::append(const U& val)
     {
         if (LIKELY(size() != capacity())) {
             new (NotNull, end()) T(val);
             ++m_size;
             return;
@@ skipping 38 matching lines @@
     {
         RELEASE_ASSERT(position <= size());
         size_t newSize = m_size + dataSize;
         if (newSize > capacity()) {
             data = expandCapacity(newSize, data);
             ASSERT(begin());
         }
         RELEASE_ASSERT(newSize >= m_size);
         T* spot = begin() + position;
         TypeOperations::moveOverlapping(spot, end(), spot + dataSize);
-        for (size_t i = 0; i < dataSize; ++i)
-            new (NotNull, &spot[i]) T(data[i]);
+        VectorCopier<VectorTraits<T>::canCopyWithMemcpy, U>::uninitializedCopy(data, &data[dataSize], spot);
         m_size = newSize;
     }
 
     template<typename T, size_t inlineCapacity, typename Allocator> template<typename U>
     inline void Vector<T, inlineCapacity, Allocator>::insert(size_t position, const U& val)
     {
         RELEASE_ASSERT(position <= size());
         const U* data = &val;
         if (size() == capacity()) {
             data = expandCapacity(size() + 1, data);
@@ skipping 104 matching lines @@
         }
         if (this->hasOutOfLineBuffer())
             Allocator::markNoTracing(visitor, buffer());
     }
 
 } // namespace WTF
 
 using WTF::Vector;
 
 #endif // WTF_Vector_h