Fix trailing whitespace in .cpp, .h, and .idl files (ex. Source/core)

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 28 matching lines @@
 
     template<typename T>
     struct VectorDestructor<false, T>
     {
         static void destruct(T*, T*) {}
     };
 
     template<typename T>
     struct VectorDestructor<true, T>
     {
-        static void destruct(T* begin, T* end) 
+        static void destruct(T* begin, T* end)
         {
             for (T* cur = begin; cur != end; ++cur)
                 cur->~T();
         }
     };
 
     template <bool needsInitialization, bool canInitializeWithMemset, typename T>
     struct VectorInitializer;
 
     template<bool ignore, typename T>
     struct VectorInitializer<false, ignore, T>
     {
         static void initialize(T*, T*) {}
     };
 
     template<typename T>
     struct VectorInitializer<true, false, T>
     {
-        static void initialize(T* begin, T* end) 
+        static void initialize(T* begin, T* end)
         {
             for (T* cur = begin; cur != end; ++cur)
                 new (NotNull, cur) T;
         }
     };
 
     template<typename T>
     struct VectorInitializer<true, true, T>
     {
-        static void initialize(T* begin, T* end) 
+        static void initialize(T* begin, T* end)
         {
             memset(begin, 0, reinterpret_cast<char*>(end) - reinterpret_cast<char*>(begin));
         }
     };
 
     template <bool canMoveWithMemcpy, typename T>
     struct VectorMover;
 
     template<typename T>
     struct VectorMover<false, T>
@@ skipping 19 matching lines @@
                     new (NotNull, dstEnd) T(*srcEnd);
                     srcEnd->~T();
                 }
             }
         }
     };
 
     template<typename T>
     struct VectorMover<true, T>
     {
-        static void move(const T* src, const T* srcEnd, T* dst) 
+        static void move(const T* src, const T* srcEnd, T* dst)
         {
             memcpy(dst, src, reinterpret_cast<const char*>(srcEnd) - reinterpret_cast<const char*>(src));
         }
-        static void moveOverlapping(const T* src, const T* srcEnd, T* dst) 
+        static void moveOverlapping(const T* src, const T* srcEnd, T* dst)
         {
             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) 
+        static void uninitializedCopy(const T* src, const T* srcEnd, T* dst)
         {
             while (src != srcEnd) {
                 new (NotNull, dst) T(*src);
                 ++dst;
                 ++src;
             }
         }
     };
 
     template<typename T>
     struct VectorCopier<true, T>
     {
-        static void uninitializedCopy(const T* src, const T* srcEnd, T* dst) 
+        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 <bool canFillWithMemset, typename T>
     struct VectorFiller;
 
     template<typename T>
     struct VectorFiller<false, T>
     {
-        static void uninitializedFill(T* dst, T* dstEnd, const T& val) 
+        static void uninitializedFill(T* dst, T* dstEnd, const T& val)
         {
             while (dst != dstEnd) {
                 new (NotNull, dst) T(val);
                 ++dst;
             }
         }
     };
 
     template<typename T>
     struct VectorFiller<true, T>
     {
-        static void uninitializedFill(T* dst, T* dstEnd, const T& val) 
+        static void uninitializedFill(T* dst, T* dstEnd, const T& val)
         {
             ASSERT(sizeof(T) == sizeof(char));
 #if COMPILER(GCC) && defined(_FORTIFY_SOURCE)
             if (!__builtin_constant_p(dstEnd - dst) || (!(dstEnd - dst)))
 #endif
                 memset(dst, val, dstEnd - dst);
         }
     };
-    
+
     template<bool canCompareWithMemcmp, typename T>
     struct VectorComparer;
-    
+
     template<typename T>
     struct VectorComparer<false, T>
     {
         static bool compare(const T* a, const T* b, size_t size)
         {
             for (size_t i = 0; i < size; ++i)
                 if (!(a[i] == b[i]))
                     return false;
             return true;
         }
     };
 
     template<typename T>
     struct VectorComparer<true, T>
     {
         static bool compare(const T* a, const T* b, size_t size)
         {
             return memcmp(a, b, sizeof(T) * size) == 0;
         }
     };
-    
+
     template<typename T>
     struct VectorTypeOperations
     {
         static void destruct(T* begin, T* end)
         {
             VectorDestructor<VectorTraits<T>::needsDestruction, T>::destruct(begin, end);
         }
 
         static void initialize(T* begin, T* end)
         {
@@ skipping 12 matching lines @@
 
         static void uninitializedCopy(const T* src, const T* srcEnd, T* dst)
         {
             VectorCopier<VectorTraits<T>::canCopyWithMemcpy, T>::uninitializedCopy(src, srcEnd, dst);
         }
 
         static void uninitializedFill(T* dst, T* dstEnd, const T& val)
         {
             VectorFiller<VectorTraits<T>::canFillWithMemset, T>::uninitializedFill(dst, dstEnd, val);
         }
-        
+
         static bool compare(const T* a, const T* b, size_t size)
         {
             return VectorComparer<VectorTraits<T>::canCompareWithMemcmp, T>::compare(a, b, size);
         }
     };
 
     template<typename T>
     class VectorBufferBase {
         WTF_MAKE_NONCOPYABLE(VectorBufferBase);
     public:
@@ skipping 36 matching lines @@
             RELEASE_ASSERT(newCapacity <= std::numeric_limits<unsigned>::max() / sizeof(T));
             size_t sizeToAllocate = fastMallocGoodSize(newCapacity * sizeof(T));
             m_capacity = sizeToAllocate / sizeof(T);
             m_buffer = static_cast<T*>(fastRealloc(m_buffer, sizeToAllocate));
         }
 
         void deallocateBuffer(T* bufferToDeallocate)
         {
             if (!bufferToDeallocate)
                 return;
-            
+
             if (m_buffer == bufferToDeallocate) {
                 m_buffer = 0;
                 m_capacity = 0;
             }
 
             fastFree(bufferToDeallocate);
         }
 
         T* buffer() { return m_buffer; }
         const T* buffer() const { return m_buffer; }
@@ skipping 46 matching lines @@
             // Calling malloc(0) might take a lock and may actually do an
             // allocation on some systems.
             if (capacity)
                 allocateBuffer(capacity);
         }
 
         ~VectorBuffer()
         {
             deallocateBuffer(buffer());
         }
-        
+
         void swap(VectorBuffer<T, 0>& other)
         {
             std::swap(m_buffer, other.m_buffer);
             std::swap(m_capacity, other.m_capacity);
         }
-        
+
         void restoreInlineBufferIfNeeded() { }
 
         using Base::allocateBuffer;
         using Base::tryAllocateBuffer;
         using Base::shouldReallocateBuffer;
         using Base::reallocateBuffer;
         using Base::deallocateBuffer;
 
         using Base::buffer;
         using Base::capacity;
@@ skipping 124 matching lines @@
         typedef VectorTypeOperations<T> TypeOperations;
 
     public:
         typedef T ValueType;
 
         typedef T* iterator;
         typedef const T* const_iterator;
         typedef std::reverse_iterator<iterator> reverse_iterator;
         typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
 
-        Vector() 
+        Vector()
             : m_size(0)
         {
         }
-        
-        explicit Vector(size_t size) 
+
+        explicit Vector(size_t size)
             : Base(size)
             , m_size(size)
         {
             if (begin())
                 TypeOperations::initialize(begin(), end());
         }
 
         ~Vector()
         {
             if (m_size)
                 shrink(0);
         }
 
         Vector(const Vector&);
-        template<size_t otherCapacity> 
+        template<size_t otherCapacity>
         Vector(const Vector<T, otherCapacity>&);
 
         Vector& operator=(const Vector&);
-        template<size_t otherCapacity> 
+        template<size_t otherCapacity>
         Vector& operator=(const Vector<T, otherCapacity>&);
 
 #if COMPILER_SUPPORTS(CXX_RVALUE_REFERENCES)
         Vector(Vector&&);
         Vector& operator=(Vector&&);
 #endif
 
         size_t size() const { return m_size; }
         size_t capacity() const { return Base::capacity(); }
         bool isEmpty() const { return !size(); }
 
-        T& at(size_t i) 
-        { 
+        T& at(size_t i)
+        {
             RELEASE_ASSERT(i < size());
             return Base::buffer()[i];
         }
-        const T& at(size_t i) const 
+        const T& at(size_t i) const
         {
             RELEASE_ASSERT(i < size());
             return Base::buffer()[i];
         }
 
         T& operator[](size_t i) { return at(i); }
         const T& operator[](size_t i) const { return at(i); }
 
         T* data() { return Base::buffer(); }
         const T* data() const { return Base::buffer(); }
@@ skipping 39 matching lines @@
         template<typename U> void insert(size_t position, const U&);
         template<typename U, size_t c> void insert(size_t position, const Vector<U, c>&);
 
         template<typename U> void prepend(const U*, size_t);
         template<typename U> void prepend(const U&);
         template<typename U, size_t c> void prepend(const Vector<U, c>&);
 
         void remove(size_t position);
         void remove(size_t position, size_t length);
 
-        void removeLast() 
+        void removeLast()
         {
             ASSERT(!isEmpty());
-            shrink(size() - 1); 
+            shrink(size() - 1);
         }
 
         Vector(size_t size, const T& val)
             : Base(size)
             , m_size(size)
         {
             if (begin())
                 TypeOperations::uninitializedFill(begin(), end(), val);
         }
 
@@ skipping 12 matching lines @@
 
         void reverse();
 
         void checkConsistency();
 
     private:
         void expandCapacity(size_t newMinCapacity);
         const T* expandCapacity(size_t newMinCapacity, const T*);
         bool tryExpandCapacity(size_t newMinCapacity);
         const T* tryExpandCapacity(size_t newMinCapacity, const T*);
-        template<typename U> U* expandCapacity(size_t newMinCapacity, U*); 
+        template<typename U> U* expandCapacity(size_t newMinCapacity, U*);
         template<typename U> void appendSlowCase(const U&);
 
         unsigned m_size;
 
         using Base::buffer;
         using Base::capacity;
         using Base::swap;
         using Base::allocateBuffer;
         using Base::deallocateBuffer;
         using Base::tryAllocateBuffer;
         using Base::shouldReallocateBuffer;
         using Base::reallocateBuffer;
         using Base::restoreInlineBufferIfNeeded;
         using Base::releaseBuffer;
     };
 
     template<typename T, size_t inlineCapacity>
     Vector<T, inlineCapacity>::Vector(const Vector& other)
         : Base(other.capacity())
         , m_size(other.size())
     {
         if (begin())
             TypeOperations::uninitializedCopy(other.begin(), other.end(), begin());
     }
 
     template<typename T, size_t inlineCapacity>
-    template<size_t otherCapacity> 
+    template<size_t otherCapacity>
     Vector<T, inlineCapacity>::Vector(const Vector<T, otherCapacity>& other)
         : Base(other.capacity())
         , m_size(other.size())
     {
         if (begin())
             TypeOperations::uninitializedCopy(other.begin(), other.end(), begin());
     }
 
     template<typename T, size_t inlineCapacity>
     Vector<T, inlineCapacity>& Vector<T, inlineCapacity>::operator=(const Vector<T, inlineCapacity>& other)
     {
         if (&other == this)
             return *this;
-        
+
         if (size() > other.size())
             shrink(other.size());
         else if (other.size() > capacity()) {
             clear();
             reserveCapacity(other.size());
             if (!begin())
                 return *this;
         }
-        
+
 // Works around an assert in VS2010. See https://connect.microsoft.com/VisualStudio/feedback/details/558044/std-copy-should-not-check-dest-when-first-last
 #if COMPILER(MSVC) && defined(_ITERATOR_DEBUG_LEVEL) && _ITERATOR_DEBUG_LEVEL
         if (!begin())
             return *this;
 #endif
 
         std::copy(other.begin(), other.begin() + size(), begin());
         TypeOperations::uninitializedCopy(other.begin() + size(), other.end(), end());
         m_size = other.size();
 
         return *this;
     }
 
     inline bool typelessPointersAreEqual(const void* a, const void* b) { return a == b; }
 
     template<typename T, size_t inlineCapacity>
-    template<size_t otherCapacity> 
+    template<size_t otherCapacity>
     Vector<T, inlineCapacity>& Vector<T, inlineCapacity>::operator=(const Vector<T, otherCapacity>& other)
     {
         // If the inline capacities match, we should call the more specific
         // template.  If the inline capacities don't match, the two objects
         // shouldn't be allocated the same address.
         ASSERT(!typelessPointersAreEqual(&other, this));
 
         if (size() > other.size())
             shrink(other.size());
         else if (other.size() > capacity()) {
             clear();
             reserveCapacity(other.size());
             if (!begin())
                 return *this;
         }
-        
+
 // Works around an assert in VS2010. See https://connect.microsoft.com/VisualStudio/feedback/details/558044/std-copy-should-not-check-dest-when-first-last
 #if COMPILER(MSVC) && defined(_ITERATOR_DEBUG_LEVEL) && _ITERATOR_DEBUG_LEVEL
         if (!begin())
             return *this;
 #endif
 
         std::copy(other.begin(), other.begin() + size(), begin());
         TypeOperations::uninitializedCopy(other.begin() + size(), other.end(), end());
         m_size = other.size();
 
@@ skipping 17 matching lines @@
         return *this;
     }
 #endif
 
     template<typename T, size_t inlineCapacity>
     template<typename U>
     bool Vector<T, inlineCapacity>::contains(const U& value) const
     {
         return find(value) != notFound;
     }
- 
+
     template<typename T, size_t inlineCapacity>
     template<typename U>
     size_t Vector<T, inlineCapacity>::find(const U& value) const
     {
         const T* b = begin();
         const T* e = end();
         for (const T* iter = b; iter < e; ++iter) {
             if (*iter == value)
                 return iter - b;
         }
@@ skipping 18 matching lines @@
     void Vector<T, inlineCapacity>::fill(const T& val, size_t newSize)
     {
         if (size() > newSize)
             shrink(newSize);
         else if (newSize > capacity()) {
             clear();
             reserveCapacity(newSize);
             if (!begin())
                 return;
         }
-        
+
         std::fill(begin(), end(), val);
         TypeOperations::uninitializedFill(end(), begin() + newSize, val);
         m_size = newSize;
     }
 
     template<typename T, size_t inlineCapacity>
     template<typename Iterator>
     void Vector<T, inlineCapacity>::appendRange(Iterator start, Iterator end)
     {
         for (Iterator it = start; it != end; ++it)
             append(*it);
     }
 
     template<typename T, size_t inlineCapacity>
     void Vector<T, inlineCapacity>::expandCapacity(size_t newMinCapacity)
     {
         reserveCapacity(std::max(newMinCapacity, std::max(static_cast<size_t>(16), capacity() + capacity() / 4 + 1)));
     }
-    
+
     template<typename T, size_t inlineCapacity>
     const T* Vector<T, inlineCapacity>::expandCapacity(size_t newMinCapacity, const T* ptr)
     {
         if (ptr < begin() || ptr >= end()) {
             expandCapacity(newMinCapacity);
             return ptr;
         }
         size_t index = ptr - begin();
         expandCapacity(newMinCapacity);
         return begin() + index;
     }
 
     template<typename T, size_t inlineCapacity>
     bool Vector<T, inlineCapacity>::tryExpandCapacity(size_t newMinCapacity)
     {
         return tryReserveCapacity(std::max(newMinCapacity, std::max(static_cast<size_t>(16), capacity() + capacity() / 4 + 1)));
     }
-    
+
     template<typename T, size_t inlineCapacity>
     const T* Vector<T, inlineCapacity>::tryExpandCapacity(size_t newMinCapacity, const T* ptr)
     {
         if (ptr < begin() || ptr >= end()) {
             if (!tryExpandCapacity(newMinCapacity))
                 return 0;
             return ptr;
         }
         size_t index = ptr - begin();
         if (!tryExpandCapacity(newMinCapacity))
@@ skipping 12 matching lines @@
     inline void Vector<T, inlineCapacity>::resize(size_t size)
     {
         if (size <= m_size)
             TypeOperations::destruct(begin() + size, end());
         else {
             if (size > capacity())
                 expandCapacity(size);
             if (begin())
                 TypeOperations::initialize(end(), begin() + size);
         }
-        
+
         m_size = size;
     }
 
     template<typename T, size_t inlineCapacity>
     void Vector<T, inlineCapacity>::shrink(size_t size)
     {
         ASSERT(size <= m_size);
         TypeOperations::destruct(begin() + size, end());
         m_size = size;
     }
@@ skipping 14 matching lines @@
     {
         if (newCapacity <= capacity())
             return;
         T* oldBuffer = begin();
         T* oldEnd = end();
         Base::allocateBuffer(newCapacity);
         if (begin())
             TypeOperations::move(oldBuffer, oldEnd, begin());
         Base::deallocateBuffer(oldBuffer);
     }
-    
+
     template<typename T, size_t inlineCapacity>
     bool Vector<T, inlineCapacity>::tryReserveCapacity(size_t newCapacity)
     {
         if (newCapacity <= capacity())
             return true;
         T* oldBuffer = begin();
         T* oldEnd = end();
         if (!Base::tryAllocateBuffer(newCapacity))
             return false;
         ASSERT(begin());
         TypeOperations::move(oldBuffer, oldEnd, begin());
         Base::deallocateBuffer(oldBuffer);
         return true;
     }
-    
+
     template<typename T, size_t inlineCapacity>
     inline void Vector<T, inlineCapacity>::reserveInitialCapacity(size_t initialCapacity)
     {
         ASSERT(!m_size);
         ASSERT(capacity() == inlineCapacity);
         if (initialCapacity > inlineCapacity)
             Base::allocateBuffer(initialCapacity);
     }
-    
+
     template<typename T, size_t inlineCapacity>
     void Vector<T, inlineCapacity>::shrinkCapacity(size_t newCapacity)
     {
         if (newCapacity >= capacity())
             return;
 
-        if (newCapacity < size()) 
+        if (newCapacity < size())
             shrink(newCapacity);
 
         T* oldBuffer = begin();
         if (newCapacity > 0) {
             if (Base::shouldReallocateBuffer(newCapacity)) {
                 Base::reallocateBuffer(newCapacity);
                 return;
             }
 
             T* oldEnd = end();
@@ skipping 108 matching lines @@
             if (!begin())
                 return;
         }
         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]);
         m_size = newSize;
     }
-     
+
     template<typename T, size_t inlineCapacity> template<typename U>
     inline void Vector<T, inlineCapacity>::insert(size_t position, const U& val)
     {
         RELEASE_ASSERT(position <= size());
         const U* data = &val;
         if (size() == capacity()) {
             data = expandCapacity(size() + 1, data);
             if (!begin())
                 return;
         }
         T* spot = begin() + position;
         TypeOperations::moveOverlapping(spot, end(), spot + 1);
         new (NotNull, spot) T(*data);
         ++m_size;
     }
-   
+
     template<typename T, size_t inlineCapacity> template<typename U, size_t c>
     inline void Vector<T, inlineCapacity>::insert(size_t position, const Vector<U, c>& val)
     {
         insert(position, val.begin(), val.size());
     }
 
     template<typename T, size_t inlineCapacity> template<typename U>
     void Vector<T, inlineCapacity>::prepend(const U* data, size_t dataSize)
     {
         insert(0, data, dataSize);
     }
 
     template<typename T, size_t inlineCapacity> template<typename U>
     inline void Vector<T, inlineCapacity>::prepend(const U& val)
     {
         insert(0, val);
     }
-   
+
     template<typename T, size_t inlineCapacity> template<typename U, size_t c>
     inline void Vector<T, inlineCapacity>::prepend(const Vector<U, c>& val)
     {
         insert(0, val.begin(), val.size());
     }
-    
+
     template<typename T, size_t inlineCapacity>
     inline void Vector<T, inlineCapacity>::remove(size_t position)
     {
         RELEASE_ASSERT(position < size());
         T* spot = begin() + position;
         spot->~T();
         TypeOperations::moveOverlapping(spot + 1, end(), spot);
         --m_size;
     }
 
     template<typename T, size_t inlineCapacity>
     inline void Vector<T, inlineCapacity>::remove(size_t position, size_t length)
     {
         ASSERT_WITH_SECURITY_IMPLICATION(position <= size());
         RELEASE_ASSERT(position + length <= size());
         T* beginSpot = begin() + position;
         T* endSpot = beginSpot + length;
-        TypeOperations::destruct(beginSpot, endSpot); 
+        TypeOperations::destruct(beginSpot, endSpot);
         TypeOperations::moveOverlapping(endSpot, end(), beginSpot);
         m_size -= length;
     }
 
     template<typename T, size_t inlineCapacity>
     inline void Vector<T, inlineCapacity>::reverse()
     {
         for (size_t i = 0; i < m_size / 2; ++i)
             std::swap(at(i), at(m_size - 1 - i));
     }
@@ skipping 42 matching lines @@
     inline bool operator!=(const Vector<T, inlineCapacity>& a, const Vector<T, inlineCapacity>& b)
     {
         return !(a == b);
     }
 
 } // namespace WTF
 
 using WTF::Vector;
 
 #endif // WTF_Vector_h