Ticket #3032: boost-01.patch

boost/circular_buffer/base.hpp

@@ -1006 +1006 @@
         \par Complexity
              Constant.
     */
-    explicit circular_buffer(capacity_type capacity, const allocator_type& alloc = allocator_type())
+    explicit circular_buffer(capacity_type in_capacity, const allocator_type& alloc = allocator_type())
     : m_size(0), m_alloc(alloc) {
-        initialize_buffer(capacity);
+        initialize_buffer(in_capacity);
         m_first = m_last = m_buff;
     }
 
@@ -1046 +1046 @@
         \par Complexity
              Linear (in the <code>n</code>).
     */
-    circular_buffer(capacity_type capacity, size_type n, param_value_type item,
+    circular_buffer(capacity_type in_capacity, size_type n, param_value_type item,
         const allocator_type& alloc = allocator_type())
     : m_size(n), m_alloc(alloc) {
-        BOOST_CB_ASSERT(capacity >= size()); // check for capacity lower than size
-        initialize_buffer(capacity, item);
+        BOOST_CB_ASSERT(in_capacity >= size()); // check for capacity lower than size
+        initialize_buffer(in_capacity, item);
         m_first = m_buff;
-        m_last = capacity == n ? m_buff : m_buff + n;
+        m_last = in_capacity == n ? m_buff : m_buff + n;
     }
 
     //! The copy constructor.
@@ -1145 +1145 @@
              <a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">RandomAccessIterator</a>).
     */
     template <class InputIterator>
-    circular_buffer(capacity_type capacity, InputIterator first, InputIterator last,
+    circular_buffer(capacity_type in_capacity, InputIterator first, InputIterator last,
         const allocator_type& alloc = allocator_type())
     : m_alloc(alloc) {
-        initialize(capacity, first, last, is_integral<InputIterator>());
+        initialize(in_capacity, first, last, is_integral<InputIterator>());
     }
 
 #endif // #if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
@@ -1260 +1260 @@
             assign(size_type, const_reference)\endlink</code>, <code>assign(InputIterator, InputIterator)</code>,
             <code>assign(capacity_type, InputIterator, InputIterator)</code>
     */
-    void assign(capacity_type capacity, size_type n, param_value_type item) {
-        BOOST_CB_ASSERT(capacity >= n); // check for new capacity lower than n
-        assign_n(capacity, n, cb_details::assign_n<param_value_type, allocator_type>(n, item, m_alloc));
+    void assign(capacity_type in_capacity, size_type n, param_value_type item) {
+        BOOST_CB_ASSERT(in_capacity >= n); // check for new capacity lower than n
+        assign_n(in_capacity, n, cb_details::assign_n<param_value_type, allocator_type>(n, item, m_alloc));
     }
 
     //! Assign a copy of the range into the <code>circular_buffer</code>.
@@ -1333 +1333 @@
             <code>assign(InputIterator, InputIterator)</code>
     */
     template <class InputIterator>
-    void assign(capacity_type capacity, InputIterator first, InputIterator last) {
-        assign(capacity, first, last, is_integral<InputIterator>());
+    void assign(capacity_type in_capacity, InputIterator first, InputIterator last) {
+        assign(in_capacity, first, last, is_integral<InputIterator>());
     }
 
     //! Swap the contents of two <code>circular_buffer</code>s.
@@ -2079 +2079 @@
     }
 
     //! Initialize the internal buffer.
-    void initialize_buffer(capacity_type capacity) {
-        m_buff = allocate(capacity);
-        m_end = m_buff + capacity;
+    void initialize_buffer(capacity_type in_capacity) {
+        m_buff = allocate(in_capacity);
+        m_end = m_buff + in_capacity;
     }
 
     //! Initialize the internal buffer.
-    void initialize_buffer(capacity_type capacity, param_value_type item) {
-        initialize_buffer(capacity);
+    void initialize_buffer(capacity_type in_capacity, param_value_type item) {
+        initialize_buffer(in_capacity);
         BOOST_TRY {
             cb_details::uninitialized_fill_n_with_alloc(m_buff, size(), item, m_alloc);
         } BOOST_CATCH(...) {
@@ -2135 +2135 @@
 
     //! Specialized initialize method.
     template <class IntegralType>
-    void initialize(capacity_type capacity, IntegralType n, IntegralType item, const true_type&) {
-        BOOST_CB_ASSERT(capacity >= static_cast<size_type>(n)); // check for capacity lower than n
+    void initialize(capacity_type in_capacity, IntegralType n, IntegralType item, const true_type&) {
+        BOOST_CB_ASSERT(in_capacity >= static_cast<size_type>(n)); // check for capacity lower than n
         m_size = static_cast<size_type>(n);
-        initialize_buffer(capacity, item);
+        initialize_buffer(in_capacity, item);
         m_first = m_buff;
-        m_last = capacity == size() ? m_buff : m_buff + size();
+        m_last = in_capacity == size() ? m_buff : m_buff + size();
     }
 
     //! Specialized initialize method.
     template <class Iterator>
-    void initialize(capacity_type capacity, Iterator first, Iterator last, const false_type&) {
+    void initialize(capacity_type in_capacity, Iterator first, Iterator last, const false_type&) {
         BOOST_CB_IS_CONVERTIBLE(Iterator, value_type); // check for invalid iterator type
 #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581))
-        initialize(capacity, first, last, BOOST_ITERATOR_CATEGORY<Iterator>::type());
+        initialize(in_capacity, first, last, BOOST_ITERATOR_CATEGORY<Iterator>::type());
 #else
-        initialize(capacity, first, last, BOOST_DEDUCED_TYPENAME BOOST_ITERATOR_CATEGORY<Iterator>::type());
+        initialize(in_capacity, first, last, BOOST_DEDUCED_TYPENAME BOOST_ITERATOR_CATEGORY<Iterator>::type());
 #endif
     }
 
     //! Specialized initialize method.
     template <class InputIterator>
-    void initialize(capacity_type capacity,
+    void initialize(capacity_type in_capacity,
         InputIterator first,
         InputIterator last,
         const std::input_iterator_tag&) {
-        initialize_buffer(capacity);
+        initialize_buffer(in_capacity);
         m_first = m_last = m_buff;
         m_size = 0;
-        if (capacity == 0)
+        if (in_capacity == 0)
             return;
         while (first != last && !full()) {
             m_alloc.construct(m_last, *first++);
@@ -2179 +2179 @@
 
     //! Specialized initialize method.
     template <class ForwardIterator>
-    void initialize(capacity_type capacity,
+    void initialize(capacity_type in_capacity,
         ForwardIterator first,
         ForwardIterator last,
         const std::forward_iterator_tag&) {
         BOOST_CB_ASSERT(std::distance(first, last) >= 0); // check for wrong range
-        initialize(capacity, first, last, std::distance(first, last));
+        initialize(in_capacity, first, last, std::distance(first, last));
     }
 
     //! Initialize the circular buffer.
     template <class ForwardIterator>
-    void initialize(capacity_type capacity,
+    void initialize(capacity_type in_capacity,
         ForwardIterator first,
         ForwardIterator last,
         size_type distance) {
-        initialize_buffer(capacity);
+        initialize_buffer(in_capacity);
         m_first = m_buff;
-        if (distance > capacity) {
-            std::advance(first, distance - capacity);
-            m_size = capacity;
+        if (distance > in_capacity) {
+            std::advance(first, distance - in_capacity);
+            m_size = in_capacity;
         } else {
             m_size = distance;
         }
         BOOST_TRY {
             m_last = cb_details::uninitialized_copy_with_alloc(first, last, m_buff, m_alloc);
         } BOOST_CATCH(...) {
-            deallocate(m_buff, capacity);
+            deallocate(m_buff, in_capacity);
             BOOST_RETHROW
         }
         BOOST_CATCH_END

boost/circular_buffer/details.hpp

@@ -146 +146 @@
 public:
 
     //! Constructor.
-    capacity_control(Size capacity, Size min_capacity = 0)
-    : m_capacity(capacity), m_min_capacity(min_capacity) {
-        BOOST_CB_ASSERT(capacity >= min_capacity); // check for capacity lower than min_capacity
+    capacity_control(Size in_capacity, Size in_min_capacity = 0)
+    : m_capacity(in_capacity), m_min_capacity(in_min_capacity) {
+        BOOST_CB_ASSERT(in_capacity >= in_min_capacity); // check for capacity lower than min_capacity
     }
 
     // Default copy constructor.

boost/circular_buffer/space_optimized.hpp

@@ -1229 +1229 @@
     }
 
     //! Ensure the reserve for possible growth up.
-    size_type ensure_reserve(size_type new_capacity, size_type size) const {
-        if (size + new_capacity / 5 >= new_capacity)
+    size_type ensure_reserve(size_type new_capacity, size_type in_size) const {
+        if (in_size + new_capacity / 5 >= new_capacity)
             new_capacity *= 2; // ensure at least 20% reserve
         if (new_capacity > m_capacity_ctrl)
             return m_capacity_ctrl;