reflow comments in wtf

third_party/WebKit/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 17 matching lines @@
 #include "wtf/NotFound.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/VectorTraits.h"
 #include "wtf/allocator/PartitionAllocator.h"
 #include <algorithm>
 #include <initializer_list>
 #include <iterator>
 #include <string.h>
 #include <utility>
 
-// For ASAN builds, disable inline buffers completely as they cause various issues.
+// For ASAN builds, disable inline buffers completely as they cause various
+// issues.
 #ifdef ANNOTATE_CONTIGUOUS_CONTAINER
 #define INLINE_CAPACITY 0
 #else
 #define INLINE_CAPACITY inlineCapacity
 #endif
 
 namespace WTF {
 
 #if defined(MEMORY_SANITIZER_INITIAL_SIZE)
 static const size_t kInitialVectorSize = 1;
@@ skipping 407 matching lines @@
       return true;
     }
     return false;
   }
 
   void resetBufferPointer() {
     m_buffer = nullptr;
     m_capacity = 0;
   }
 
-  // See the other specialization for the meaning of |thisHole| and |otherHole|. They are irrelevant in this case.
+  // See the other specialization for the meaning of |thisHole| and |otherHole|.
+  // They are irrelevant in this case.
   void swapVectorBuffer(VectorBuffer<T, 0, Allocator>& other,
                         OffsetRange thisHole,
                         OffsetRange otherHole) {
     std::swap(m_buffer, other.m_buffer);
     std::swap(m_capacity, other.m_capacity);
     std::swap(m_size, other.m_size);
   }
 
   using Base::allocateBuffer;
   using Base::allocationSize;
@@ skipping 98 matching lines @@
     else
       resetBufferPointer();
   }
 
   size_t allocationSize(size_t capacity) const {
     if (capacity <= inlineCapacity)
       return m_inlineBufferSize;
     return Base::allocationSize(capacity);
   }
 
-  // Swap two vector buffers, both of which have the same non-zero inline capacity.
+  // Swap two vector buffers, both of which have the same non-zero inline
+  // capacity.
   //
-  // If the data is in an out-of-line buffer, we can just pass the pointers across the two buffers.
-  // If the data is in an inline buffer, we need to either swap or move each element, depending on whether each
-  // slot is occupied or not.
+  // If the data is in an out-of-line buffer, we can just pass the pointers
+  // across the two buffers.  If the data is in an inline buffer, we need to
+  // either swap or move each element, depending on whether each slot is
+  // occupied or not.
   //
-  // Further complication comes from the fact that VectorBuffer is also used as the backing store of a Deque.
-  // Deque allocates the objects like a ring buffer, so there may be a "hole" (unallocated region) in the middle
-  // of the buffer. This function assumes elements in a range [m_buffer, m_buffer + m_size) are all allocated
-  // except for elements within |thisHole|. The same applies for |other.m_buffer| and |otherHole|.
+  // Further complication comes from the fact that VectorBuffer is also used as
+  // the backing store of a Deque.  Deque allocates the objects like a ring
+  // buffer, so there may be a "hole" (unallocated region) in the middle of the
+  // buffer. This function assumes elements in a range [m_buffer, m_buffer +
+  // m_size) are all allocated except for elements within |thisHole|. The same
+  // applies for |other.m_buffer| and |otherHole|.
   void swapVectorBuffer(VectorBuffer<T, inlineCapacity, Allocator>& other,
                         OffsetRange thisHole,
                         OffsetRange otherHole) {
     using TypeOperations = VectorTypeOperations<T>;
 
     if (buffer() != inlineBuffer() && other.buffer() != other.inlineBuffer()) {
-      // The easiest case: both buffers are non-inline. We just need to swap the pointers.
+      // The easiest case: both buffers are non-inline. We just need to swap the
+      // pointers.
       std::swap(m_buffer, other.m_buffer);
       std::swap(m_capacity, other.m_capacity);
       std::swap(m_size, other.m_size);
       return;
     }
 
     Allocator::enterGCForbiddenScope();
 
-    // Otherwise, we at least need to move some elements from one inline buffer to another.
+    // Otherwise, we at least need to move some elements from one inline buffer
+    // to another.
     //
-    // Terminology: "source" is a place from which elements are copied, and "destination" is a place to which
-    // elements are copied. thisSource or otherSource can be empty (represented by nullptr) when this range or
+    // Terminology: "source" is a place from which elements are copied, and
+    // "destination" is a place to which elements are copied. thisSource or
+    // otherSource can be empty (represented by nullptr) when this range or
     // other range is in an out-of-line buffer.
     //
-    // We first record which range needs to get moved and where elements in such a range will go. Elements in
-    // an inline buffer will go to the other buffer's inline buffer. Elements in an out-of-line buffer won't move,
+    // We first record which range needs to get moved and where elements in such
+    // a range will go. Elements in an inline buffer will go to the other
+    // buffer's inline buffer. Elements in an out-of-line buffer won't move,
     // because we can just swap pointers of out-of-line buffers.
     T* thisSourceBegin = nullptr;
     size_t thisSourceSize = 0;
     T* thisDestinationBegin = nullptr;
     if (buffer() == inlineBuffer()) {
       thisSourceBegin = buffer();
       thisSourceSize = m_size;
       thisDestinationBegin = other.inlineBuffer();
       if (!thisHole.empty()) {  // Sanity check.
         ASSERT(thisHole.begin < thisHole.end);
@@ skipping 11 matching lines @@
       otherSourceSize = other.m_size;
       otherDestinationBegin = inlineBuffer();
       if (!otherHole.empty()) {
         ASSERT(otherHole.begin < otherHole.end);
         ASSERT(otherHole.end <= otherSourceSize);
       }
     } else {
       otherHole.begin = otherHole.end = 0;
     }
 
-    // Next, we mutate members and do other bookkeeping. We do pointer swapping (for out-of-line buffers) here if
-    // we can. From now on, don't assume buffer() or capacity() maintains their original values.
+    // Next, we mutate members and do other bookkeeping. We do pointer swapping
+    // (for out-of-line buffers) here if we can. From now on, don't assume
+    // buffer() or capacity() maintains their original values.
     std::swap(m_capacity, other.m_capacity);
     if (thisSourceBegin &&
         !otherSourceBegin) {  // Our buffer is inline, theirs is not.
       ASSERT(buffer() == inlineBuffer());
       ASSERT(other.buffer() != other.inlineBuffer());
       ANNOTATE_DELETE_BUFFER(m_buffer, inlineCapacity, m_size);
       m_buffer = other.buffer();
       other.m_buffer = other.inlineBuffer();
       std::swap(m_size, other.m_size);
       ANNOTATE_NEW_BUFFER(other.m_buffer, inlineCapacity, other.m_size);
     } else if (!thisSourceBegin &&
                otherSourceBegin) {  // Their buffer is inline, ours is not.
       ASSERT(buffer() != inlineBuffer());
       ASSERT(other.buffer() == other.inlineBuffer());
       ANNOTATE_DELETE_BUFFER(other.m_buffer, inlineCapacity, other.m_size);
       other.m_buffer = buffer();
       m_buffer = inlineBuffer();
       std::swap(m_size, other.m_size);
       ANNOTATE_NEW_BUFFER(m_buffer, inlineCapacity, m_size);
     } else {  // Both buffers are inline.
       ASSERT(thisSourceBegin && otherSourceBegin);
       ASSERT(buffer() == inlineBuffer());
       ASSERT(other.buffer() == other.inlineBuffer());
       ANNOTATE_CHANGE_SIZE(m_buffer, inlineCapacity, m_size, other.m_size);
       ANNOTATE_CHANGE_SIZE(other.m_buffer, inlineCapacity, other.m_size,
                            m_size);
       std::swap(m_size, other.m_size);
     }
 
-    // We are ready to move elements. We determine an action for each "section", which is a contiguous range such
-    // that all elements in the range are treated similarly.
+    // We are ready to move elements. We determine an action for each "section",
+    // which is a contiguous range such that all elements in the range are
+    // treated similarly.
     size_t sectionBegin = 0;
     while (sectionBegin < inlineCapacity) {
-      // To determine the end of this section, we list up all the boundaries where the "occupiedness" may change.
+      // To determine the end of this section, we list up all the boundaries
+      // where the "occupiedness" may change.
       size_t sectionEnd = inlineCapacity;
       if (thisSourceBegin && sectionBegin < thisSourceSize)
         sectionEnd = std::min(sectionEnd, thisSourceSize);
       if (!thisHole.empty() && sectionBegin < thisHole.begin)
         sectionEnd = std::min(sectionEnd, thisHole.begin);
       if (!thisHole.empty() && sectionBegin < thisHole.end)
         sectionEnd = std::min(sectionEnd, thisHole.end);
       if (otherSourceBegin && sectionBegin < otherSourceSize)
         sectionEnd = std::min(sectionEnd, otherSourceSize);
       if (!otherHole.empty() && sectionBegin < otherHole.begin)
@@ skipping 12 matching lines @@
           thisOccupied = true;
       }
       bool otherOccupied = false;
       if (otherSourceBegin && sectionBegin < otherSourceSize) {
         if (otherHole.empty() || sectionBegin < otherHole.begin ||
             sectionBegin >= otherHole.end)
           otherOccupied = true;
       }
 
       if (thisOccupied && otherOccupied) {
-        // Both occupied; swap them. In this case, one's destination must be the other's source (i.e. both
-        // ranges are in inline buffers).
+        // Both occupied; swap them. In this case, one's destination must be the
+        // other's source (i.e. both ranges are in inline buffers).
         ASSERT(thisDestinationBegin == otherSourceBegin);
         ASSERT(otherDestinationBegin == thisSourceBegin);
         TypeOperations::swap(thisSourceBegin + sectionBegin,
                              thisSourceBegin + sectionEnd,
                              otherSourceBegin + sectionBegin);
       } else if (thisOccupied) {
         // Move from ours to theirs.
         TypeOperations::move(thisSourceBegin + sectionBegin,
                              thisSourceBegin + sectionEnd,
                              thisDestinationBegin + sectionBegin);
@@ skipping 33 matching lines @@
   static const size_t m_inlineBufferSize = inlineCapacity * sizeof(T);
   T* inlineBuffer() { return reinterpret_cast_ptr<T*>(m_inlineBuffer.buffer); }
   const T* inlineBuffer() const {
     return reinterpret_cast_ptr<const T*>(m_inlineBuffer.buffer);
   }
 
   AlignedBuffer<m_inlineBufferSize, WTF_ALIGN_OF(T)> m_inlineBuffer;
   template <typename U, size_t inlineBuffer, typename V>
   friend class Deque;
 };
-
-template <
-    typename T,
-    size_t inlineCapacity = 0,
-    typename Allocator =
-        PartitionAllocator>  // Heap-allocated vectors with no inlineCapacity never need a destructor.
+// Heap-allocated vectors with no inlineCapacity never need a destructor.
+template <typename T,
+          size_t inlineCapacity = 0,
+          typename Allocator = PartitionAllocator>
 class Vector
     : private VectorBuffer<T, INLINE_CAPACITY, Allocator>,
       public ConditionalDestructor<Vector<T, INLINE_CAPACITY, Allocator>,
                                    (INLINE_CAPACITY == 0) &&
                                        Allocator::isGarbageCollected> {
   WTF_USE_ALLOCATOR(Vector, Allocator);
   using Base = VectorBuffer<T, INLINE_CAPACITY, Allocator>;
   using TypeOperations = VectorTypeOperations<T>;
   using OffsetRange = typename Base::OffsetRange;
 
@@ skipping 799 matching lines @@
           visitor, *const_cast<T*>(bufferEntry));
     checkUnusedSlots(buffer() + size(), buffer() + capacity());
   }
 }
 
 }  // namespace WTF
 
 using WTF::Vector;
 
 #endif  // WTF_Vector_h