Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r81066 - in branches/release/boost: container container/detail intrusive
From: jeffrey.hellrung_at_[hidden]
Date: 2012-10-25 22:55:59


Author: jeffrey.hellrung
Date: 2012-10-25 22:55:57 EDT (Thu, 25 Oct 2012)
New Revision: 81066
URL: http://svn.boost.org/trac/boost/changeset/81066

Log:
merge trunk to release; fixes #7531 variable shadowing warning in container and intrusive
Properties modified:
   branches/release/boost/container/ (props changed)
   branches/release/boost/intrusive/ (props changed)
Text files modified:
   branches/release/boost/container/detail/flat_tree.hpp | 56 +++++-----
   branches/release/boost/container/detail/multiallocation_chain.hpp | 24 ++--
   branches/release/boost/container/flat_map.hpp | 12 +-
   branches/release/boost/container/flat_set.hpp | 12 +-
   branches/release/boost/container/map.hpp | 4
   branches/release/boost/container/set.hpp | 4
   branches/release/boost/container/stable_vector.hpp | 6
   branches/release/boost/container/string.hpp | 28 ++--
   branches/release/boost/intrusive/avltree.hpp | 12 +-
   branches/release/boost/intrusive/hashtable.hpp | 188 ++++++++++++++++++++-------------------
   branches/release/boost/intrusive/list.hpp | 14 +-
   branches/release/boost/intrusive/sgtree.hpp | 8
   branches/release/boost/intrusive/slist.hpp | 80 ++++++++--------
   branches/release/boost/intrusive/splaytree.hpp | 4
   branches/release/boost/intrusive/treap.hpp | 8
   15 files changed, 231 insertions(+), 229 deletions(-)

Modified: branches/release/boost/container/detail/flat_tree.hpp
==============================================================================
--- branches/release/boost/container/detail/flat_tree.hpp (original)
+++ branches/release/boost/container/detail/flat_tree.hpp 2012-10-25 22:55:57 EDT (Thu, 25 Oct 2012)
@@ -48,7 +48,7 @@
    typedef Value first_argument_type;
    typedef Value second_argument_type;
    typedef bool return_type;
- public:
+ public:
    flat_tree_value_compare()
       : Compare()
    {}
@@ -65,7 +65,7 @@
 
    const Compare &get_comp() const
       { return *this; }
-
+
    Compare &get_comp()
       { return *this; }
 };
@@ -238,7 +238,7 @@
    flat_tree& operator=(BOOST_RV_REF(flat_tree) mx)
    { m_data = boost::move(mx.m_data); return *this; }
 
- public:
+ public:
    // accessors:
    Compare key_comp() const
    { return this->m_data.get_comp(); }
@@ -446,11 +446,11 @@
       //Loop in burst sizes
       while(len){
          const size_type burst = len < BurstSize ? len : BurstSize;
- const const_iterator cend(this->cend());
+ const const_iterator cend_(this->cend());
          len -= burst;
          for(size_type i = 0; i != burst; ++i){
             //Get the insertion position for each key
- pos = const_cast<const flat_tree&>(*this).priv_upper_bound(pos, cend, KeyOfValue()(*first));
+ pos = const_cast<const flat_tree&>(*this).priv_upper_bound(pos, cend_, KeyOfValue()(*first));
             positions[i] = static_cast<size_type>(pos - beg);
             ++first;
          }
@@ -497,14 +497,14 @@
       while(len){
          const size_type burst = len < BurstSize ? len : BurstSize;
          size_type unique_burst = 0u;
- const const_iterator cend(this->cend());
+ const const_iterator cend_(this->cend());
          while(unique_burst < burst && len > 0){
             //Get the insertion position for each key
             const value_type & val = *first++;
             --len;
- pos = const_cast<const flat_tree&>(*this).priv_lower_bound(pos, cend, KeyOfValue()(val));
+ pos = const_cast<const flat_tree&>(*this).priv_lower_bound(pos, cend_, KeyOfValue()(val));
             //Check if already present
- if(pos != cend && !value_comp(val, *pos)){
+ if(pos != cend_ && !value_comp(val, *pos)){
                if(unique_burst > 0){
                   ++skips[unique_burst-1];
                }
@@ -692,22 +692,22 @@
    // set operations:
    iterator find(const key_type& k)
    {
- const Compare &key_comp = this->m_data.get_comp();
+ const Compare &key_comp_ = this->m_data.get_comp();
       iterator i = this->lower_bound(k);
 
- if (i != this->end() && key_comp(k, KeyOfValue()(*i))){
- i = this->end();
+ if (i != this->end() && key_comp_(k, KeyOfValue()(*i))){
+ i = this->end();
       }
       return i;
    }
 
    const_iterator find(const key_type& k) const
    {
- const Compare &key_comp = this->m_data.get_comp();
+ const Compare &key_comp_ = this->m_data.get_comp();
       const_iterator i = this->lower_bound(k);
 
- if (i != this->end() && key_comp(k, KeyOfValue()(*i))){
- i = this->end();
+ if (i != this->end() && key_comp_(k, KeyOfValue()(*i))){
+ i = this->end();
       }
       return i;
    }
@@ -737,11 +737,11 @@
    std::pair<const_iterator, const_iterator> equal_range(const key_type& k) const
    { return this->priv_equal_range(this->begin(), this->end(), k); }
 
- size_type capacity() const
+ size_type capacity() const
    { return this->m_data.m_vect.capacity(); }
 
- void reserve(size_type count)
- { this->m_data.m_vect.reserve(count); }
+ void reserve(size_type count_)
+ { this->m_data.m_vect.reserve(count_); }
 
    private:
    struct insert_commit_data
@@ -780,13 +780,13 @@
    }
 
    std::pair<iterator,bool> priv_insert_unique_prepare
- (const_iterator beg, const_iterator end, const value_type& val, insert_commit_data &commit_data)
+ (const_iterator beg, const_iterator end_, const value_type& val, insert_commit_data &commit_data)
    {
       const value_compare &value_comp = this->m_data;
- commit_data.position = this->priv_lower_bound(beg, end, KeyOfValue()(val));
+ commit_data.position = this->priv_lower_bound(beg, end_, KeyOfValue()(val));
       return std::pair<iterator,bool>
          ( *reinterpret_cast<iterator*>(&commit_data.position)
- , commit_data.position == end || value_comp(val, *commit_data.position));
+ , commit_data.position == end_ || value_comp(val, *commit_data.position));
    }
 
    std::pair<iterator,bool> priv_insert_unique_prepare
@@ -854,7 +854,7 @@
    RanIt priv_lower_bound(RanIt first, RanIt last,
                           const key_type & key) const
    {
- const Compare &key_comp = this->m_data.get_comp();
+ const Compare &key_comp_ = this->m_data.get_comp();
       KeyOfValue key_extract;
       difference_type len = last - first, half;
       RanIt middle;
@@ -864,7 +864,7 @@
          middle = first;
          middle += half;
 
- if (key_comp(key_extract(*middle), key)) {
+ if (key_comp_(key_extract(*middle), key)) {
             ++middle;
             first = middle;
             len = len - half - 1;
@@ -879,7 +879,7 @@
    RanIt priv_upper_bound(RanIt first, RanIt last,
                           const key_type & key) const
    {
- const Compare &key_comp = this->m_data.get_comp();
+ const Compare &key_comp_ = this->m_data.get_comp();
       KeyOfValue key_extract;
       difference_type len = last - first, half;
       RanIt middle;
@@ -889,12 +889,12 @@
          middle = first;
          middle += half;
 
- if (key_comp(key, key_extract(*middle))) {
+ if (key_comp_(key, key_extract(*middle))) {
             len = half;
          }
          else{
             first = ++middle;
- len = len - half - 1;
+ len = len - half - 1;
          }
       }
       return first;
@@ -904,7 +904,7 @@
    std::pair<RanIt, RanIt>
       priv_equal_range(RanIt first, RanIt last, const key_type& key) const
    {
- const Compare &key_comp = this->m_data.get_comp();
+ const Compare &key_comp_ = this->m_data.get_comp();
       KeyOfValue key_extract;
       difference_type len = last - first, half;
       RanIt middle, left, right;
@@ -914,12 +914,12 @@
          middle = first;
          middle += half;
 
- if (key_comp(key_extract(*middle), key)){
+ if (key_comp_(key_extract(*middle), key)){
             first = middle;
             ++first;
             len = len - half - 1;
          }
- else if (key_comp(key, key_extract(*middle))){
+ else if (key_comp_(key, key_extract(*middle))){
             len = half;
          }
          else {

Modified: branches/release/boost/container/detail/multiallocation_chain.hpp
==============================================================================
--- branches/release/boost/container/detail/multiallocation_chain.hpp (original)
+++ branches/release/boost/container/detail/multiallocation_chain.hpp 2012-10-25 22:55:57 EDT (Thu, 25 Oct 2012)
@@ -126,22 +126,22 @@
       return ret;
    }
 
- void splice_after(iterator after_this, basic_multiallocation_chain &x, iterator before_begin, iterator before_end)
- { slist_impl_.splice_after(after_this, x.slist_impl_, before_begin, before_end); }
+ void splice_after(iterator after_this, basic_multiallocation_chain &x, iterator before_begin_, iterator before_end)
+ { slist_impl_.splice_after(after_this, x.slist_impl_, before_begin_, before_end); }
 
- void splice_after(iterator after_this, basic_multiallocation_chain &x, iterator before_begin, iterator before_end, size_type n)
- { slist_impl_.splice_after(after_this, x.slist_impl_, before_begin, before_end, n); }
+ void splice_after(iterator after_this, basic_multiallocation_chain &x, iterator before_begin_, iterator before_end, size_type n)
+ { slist_impl_.splice_after(after_this, x.slist_impl_, before_begin_, before_end, n); }
 
    void splice_after(iterator after_this, basic_multiallocation_chain &x)
    { slist_impl_.splice_after(after_this, x.slist_impl_); }
 
- void incorporate_after(iterator after_this, void_pointer begin , iterator before_end)
+ void incorporate_after(iterator after_this, void_pointer begin_ , iterator before_end)
    {
- slist_impl_.incorporate_after(after_this, to_node_ptr(begin), to_node_ptr(before_end));
+ slist_impl_.incorporate_after(after_this, to_node_ptr(begin_), to_node_ptr(before_end));
    }
 
- void incorporate_after(iterator after_this, void_pointer begin, void_pointer before_end, size_type n)
- { slist_impl_.incorporate_after(after_this, to_node_ptr(begin), to_node_ptr(before_end), n); }
+ void incorporate_after(iterator after_this, void_pointer begin_, void_pointer before_end, size_type n)
+ { slist_impl_.incorporate_after(after_this, to_node_ptr(begin_), to_node_ptr(before_end), n); }
 
    void swap(basic_multiallocation_chain &x)
    { slist_impl_.swap(x.slist_impl_); }
@@ -217,11 +217,11 @@
    void swap(transform_multiallocation_chain &other_chain)
    { holder_.swap(other_chain.holder_); }
 
- void splice_after(iterator after_this, transform_multiallocation_chain &x, iterator before_begin, iterator before_end, size_type n)
- { holder_.splice_after(after_this.base(), x.holder_, before_begin.base(), before_end.base(), n); }
+ void splice_after(iterator after_this, transform_multiallocation_chain &x, iterator before_begin_, iterator before_end, size_type n)
+ { holder_.splice_after(after_this.base(), x.holder_, before_begin_.base(), before_end.base(), n); }
 
- void incorporate_after(iterator after_this, pointer begin, pointer before_end, size_type n)
- { holder_.incorporate_after(after_this.base(), begin, before_end, n); }
+ void incorporate_after(iterator after_this, pointer begin_, pointer before_end, size_type n)
+ { holder_.incorporate_after(after_this.base(), begin_, before_end, n); }
 
    pointer pop_front()
    { return cast(holder_.pop_front()); }

Modified: branches/release/boost/container/flat_map.hpp
==============================================================================
--- branches/release/boost/container/flat_map.hpp (original)
+++ branches/release/boost/container/flat_map.hpp 2012-10-25 22:55:57 EDT (Thu, 25 Oct 2012)
@@ -418,7 +418,7 @@
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
- size_type capacity() const
+ size_type capacity() const
       { return m_flat_tree.capacity(); }
 
    //! <b>Effects</b>: If n is less than or equal to capacity(), this call has no
@@ -430,8 +430,8 @@
    //!
    //! <b>Note</b>: If capacity() is less than "count", iterators and references to
    //! to values might be invalidated.
- void reserve(size_type count)
- { m_flat_tree.reserve(count); }
+ void reserve(size_type count_)
+ { m_flat_tree.reserve(count_); }
 
    //! <b>Effects</b>: Tries to deallocate the excess of memory created
    // with previous allocations. The size of the vector is unchanged
@@ -1266,7 +1266,7 @@
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
- size_type capacity() const
+ size_type capacity() const
       { return m_flat_tree.capacity(); }
 
    //! <b>Effects</b>: If n is less than or equal to capacity(), this call has no
@@ -1278,8 +1278,8 @@
    //!
    //! <b>Note</b>: If capacity() is less than "count", iterators and references to
    //! to values might be invalidated.
- void reserve(size_type count)
- { m_flat_tree.reserve(count); }
+ void reserve(size_type count_)
+ { m_flat_tree.reserve(count_); }
 
    //! <b>Effects</b>: Tries to deallocate the excess of memory created
    // with previous allocations. The size of the vector is unchanged

Modified: branches/release/boost/container/flat_set.hpp
==============================================================================
--- branches/release/boost/container/flat_set.hpp (original)
+++ branches/release/boost/container/flat_set.hpp 2012-10-25 22:55:57 EDT (Thu, 25 Oct 2012)
@@ -365,7 +365,7 @@
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
- size_type capacity() const
+ size_type capacity() const
       { return m_flat_tree.capacity(); }
 
    //! <b>Effects</b>: If n is less than or equal to capacity(), this call has no
@@ -377,8 +377,8 @@
    //!
    //! <b>Note</b>: If capacity() is less than "count", iterators and references to
    //! to values might be invalidated.
- void reserve(size_type count)
- { m_flat_tree.reserve(count); }
+ void reserve(size_type count_)
+ { m_flat_tree.reserve(count_); }
 
    //! <b>Effects</b>: Tries to deallocate the excess of memory created
    // with previous allocations. The size of the vector is unchanged
@@ -1045,7 +1045,7 @@
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
- size_type capacity() const
+ size_type capacity() const
       { return m_flat_tree.capacity(); }
 
    //! <b>Effects</b>: If n is less than or equal to capacity(), this call has no
@@ -1057,8 +1057,8 @@
    //!
    //! <b>Note</b>: If capacity() is less than "count", iterators and references to
    //! to values might be invalidated.
- void reserve(size_type count)
- { m_flat_tree.reserve(count); }
+ void reserve(size_type count_)
+ { m_flat_tree.reserve(count_); }
 
    //! <b>Effects</b>: Tries to deallocate the excess of memory created
    // with previous allocations. The size of the vector is unchanged

Modified: branches/release/boost/container/map.hpp
==============================================================================
--- branches/release/boost/container/map.hpp (original)
+++ branches/release/boost/container/map.hpp 2012-10-25 22:55:57 EDT (Thu, 25 Oct 2012)
@@ -951,9 +951,9 @@
    //!
    //! <b>Complexity</b>: Linear in N.
    template <class InputIterator>
- multimap(ordered_range_t ordered_range, InputIterator first, InputIterator last, const Compare& comp = Compare(),
+ multimap(ordered_range_t ordered_range_, InputIterator first, InputIterator last, const Compare& comp = Compare(),
          const allocator_type& a = allocator_type())
- : m_tree(ordered_range, first, last, comp, a)
+ : m_tree(ordered_range_, first, last, comp, a)
    {}
 
    //! <b>Effects</b>: Copy constructs a multimap.

Modified: branches/release/boost/container/set.hpp
==============================================================================
--- branches/release/boost/container/set.hpp (original)
+++ branches/release/boost/container/set.hpp 2012-10-25 22:55:57 EDT (Thu, 25 Oct 2012)
@@ -757,10 +757,10 @@
    //!
    //! <b>Complexity</b>: Linear in N.
    template <class InputIterator>
- multiset( ordered_range_t ordered_range, InputIterator first, InputIterator last
+ multiset( ordered_range_t ordered_range_, InputIterator first, InputIterator last
            , const Compare& comp = Compare()
            , const allocator_type& a = allocator_type())
- : m_tree(ordered_range, first, last, comp, a)
+ : m_tree(ordered_range_, first, last, comp, a)
    {}
 
    //! <b>Effects</b>: Copy constructs a multiset.

Modified: branches/release/boost/container/stable_vector.hpp
==============================================================================
--- branches/release/boost/container/stable_vector.hpp (original)
+++ branches/release/boost/container/stable_vector.hpp 2012-10-25 22:55:57 EDT (Thu, 25 Oct 2012)
@@ -1094,7 +1094,7 @@
       if(n > this->max_size())
          throw std::bad_alloc();
 
- size_type size = this->size();
+ size_type size_ = this->size();
       size_type old_capacity = this->capacity();
       if(n > old_capacity){
          index_traits_type::initialize_end_node(this->index, this->internal_data.end_node, n);
@@ -1106,8 +1106,8 @@
             index_traits_type::fix_up_pointers_from(this->index, this->index.begin());
          }
          //Now fill pool if data is not enough
- if((n - size) > this->internal_data.pool_size){
- this->priv_increase_pool((n - size) - this->internal_data.pool_size);
+ if((n - size_) > this->internal_data.pool_size){
+ this->priv_increase_pool((n - size_) - this->internal_data.pool_size);
          }
       }
    }

Modified: branches/release/boost/container/string.hpp
==============================================================================
--- branches/release/boost/container/string.hpp (original)
+++ branches/release/boost/container/string.hpp 2012-10-25 22:55:57 EDT (Thu, 25 Oct 2012)
@@ -1322,10 +1322,10 @@
    //! <b>Returns</b>: *this
    basic_string& insert(size_type pos, const basic_string& s)
    {
- const size_type size = this->size();
- if (pos > size)
+ const size_type size_ = this->size();
+ if (pos > size_)
          this->throw_out_of_range();
- if (size > this->max_size() - s.size())
+ if (size_ > this->max_size() - s.size())
          this->throw_length_error();
       this->insert(this->priv_addr() + pos, s.begin(), s.end());
       return *this;
@@ -1341,12 +1341,12 @@
    //! <b>Returns</b>: *this
    basic_string& insert(size_type pos1, const basic_string& s, size_type pos2, size_type n)
    {
- const size_type size = this->size();
+ const size_type size_ = this->size();
       const size_type str_size = s.size();
- if (pos1 > size || pos2 > str_size)
+ if (pos1 > size_ || pos2 > str_size)
          this->throw_out_of_range();
       size_type len = container_detail::min_value(n, str_size - pos2);
- if (size > this->max_size() - len)
+ if (size_ > this->max_size() - len)
          this->throw_length_error();
       const CharT *beg_ptr = container_detail::to_raw_pointer(s.begin()) + pos2;
       const CharT *end_ptr = beg_ptr + len;
@@ -1949,12 +1949,12 @@
    //! <b>Returns</b>: find(basic_string<CharT,traits,Allocator>(1,c), pos).
    size_type find(CharT c, size_type pos = 0) const
    {
- const size_type size = this->size();
- if (pos >= size)
+ const size_type size_ = this->size();
+ if (pos >= size_)
          return npos;
       else {
- const pointer addr = this->priv_addr();
- pointer finish = addr + size;
+ const pointer addr = this->priv_addr();
+ pointer finish = addr + size_;
          const const_iterator result =
             std::find_if(addr + pos, finish,
                   std::bind2nd(Eq_traits<Traits>(), c));
@@ -2039,12 +2039,12 @@
    //! <b>Returns</b>: find_first_of(basic_string(s, n), pos).
    size_type find_first_of(const CharT* s, size_type pos, size_type n) const
    {
- const size_type size = this->size();
- if (pos >= size)
+ const size_type size_ = this->size();
+ if (pos >= size_)
          return npos;
       else {
- const pointer addr = this->priv_addr();
- pointer finish = addr + size;
+ const pointer addr = this->priv_addr();
+ pointer finish = addr + size_;
          const_iterator result = std::find_first_of
             (addr + pos, finish, s, s + n, Eq_traits<Traits>());
          return result != finish ? result - this->begin() : npos;

Modified: branches/release/boost/intrusive/avltree.hpp
==============================================================================
--- branches/release/boost/intrusive/avltree.hpp (original)
+++ branches/release/boost/intrusive/avltree.hpp 2012-10-25 22:55:57 EDT (Thu, 25 Oct 2012)
@@ -542,9 +542,9 @@
    template<class Iterator>
    void insert_equal(Iterator b, Iterator e)
    {
- iterator end(this->end());
+ iterator end_(this->end());
       for (; b != e; ++b)
- this->insert_equal(end, *b);
+ this->insert_equal(end_, *b);
    }
 
    //! <b>Requires</b>: value must be an lvalue
@@ -608,9 +608,9 @@
    void insert_unique(Iterator b, Iterator e)
    {
       if(this->empty()){
- iterator end(this->end());
+ iterator end_(this->end());
          for (; b != e; ++b)
- this->insert_unique(end, *b);
+ this->insert_unique(end_, *b);
       }
       else{
          for (; b != e; ++b)
@@ -1249,7 +1249,7 @@
 
    //! <b>Requires</b>: KeyValueCompare is a function object that induces a strict weak
    //! ordering compatible with the strict weak ordering used to create the
- //! the tree.
+ //! the tree.
    //! 'lower_key' must not be greater than 'upper_key' according to 'comp'. If
    //! 'lower_key' == 'upper_key', ('left_closed' || 'right_closed') must be false.
    //!
@@ -1298,7 +1298,7 @@
 
    //! <b>Requires</b>: KeyValueCompare is a function object that induces a strict weak
    //! ordering compatible with the strict weak ordering used to create the
- //! the tree.
+ //! the tree.
    //! 'lower_key' must not be greater than 'upper_key' according to 'comp'. If
    //! 'lower_key' == 'upper_key', ('left_closed' || 'right_closed') must be false.
    //!

Modified: branches/release/boost/intrusive/hashtable.hpp
==============================================================================
--- branches/release/boost/intrusive/hashtable.hpp (original)
+++ branches/release/boost/intrusive/hashtable.hpp 2012-10-25 22:55:57 EDT (Thu, 25 Oct 2012)
@@ -424,20 +424,20 @@
    {
       node_ptr nxt_ptr(node_traits::get_next(to_erase_ptr));
       node_ptr prev_in_group_ptr(group_traits::get_next(to_erase_ptr));
- bool last_in_group = (end_ptr == nxt_ptr) ||
+ bool last_in_group_bool = (end_ptr == nxt_ptr) ||
          (group_traits::get_next(nxt_ptr) != to_erase_ptr);
- bool first_in_group = node_traits::get_next(prev_in_group_ptr) != to_erase_ptr;
+ bool first_in_group_bool = node_traits::get_next(prev_in_group_ptr) != to_erase_ptr;
 
- if(first_in_group && last_in_group){
+ if(first_in_group_bool && last_in_group_bool){
          group_algorithms::init(to_erase_ptr);
       }
- else if(first_in_group){
+ else if(first_in_group_bool){
          group_algorithms::unlink_after(nxt_ptr);
       }
- else if(last_in_group){
- node_ptr first_in_group =
+ else if(last_in_group_bool){
+ node_ptr first_in_group_ptr =
             get_first_in_group_of_last_in_group(to_erase_ptr);
- group_algorithms::unlink_after(first_in_group);
+ group_algorithms::unlink_after(first_in_group_ptr);
       }
       else{
          group_algorithms::unlink_after(nxt_ptr);
@@ -896,12 +896,12 @@
    {
       this->priv_initialize_buckets();
       this->priv_size_traits().set_size(size_type(0));
- size_type bucket_size = this->priv_bucket_count();
- BOOST_INTRUSIVE_INVARIANT_ASSERT(bucket_size != 0);
+ size_type bucket_size_ = this->priv_bucket_count();
+ BOOST_INTRUSIVE_INVARIANT_ASSERT(bucket_size_ != 0);
       //Check power of two bucket array if the option is activated
       BOOST_INTRUSIVE_INVARIANT_ASSERT
- (!power_2_buckets || (0 == (bucket_size & (bucket_size-1))));
- this->priv_split_traits().set_size(bucket_size>>1);
+ (!power_2_buckets || (0 == (bucket_size_ & (bucket_size_-1))));
+ this->priv_split_traits().set_size(bucket_size_>>1);
    }
 
    //! <b>Effects</b>: to-do
@@ -1026,9 +1026,9 @@
          return this->begin() == this->end();
       }
       else{
- size_type bucket_count = this->priv_bucket_count();
+ size_type bucket_count_ = this->priv_bucket_count();
          const bucket_type *b = boost::intrusive::detail::to_raw_pointer(this->priv_bucket_pointer());
- for (size_type n = 0; n < bucket_count; ++n, ++b){
+ for (size_type n = 0; n < bucket_count_; ++n, ++b){
             if(!b->empty()){
                return false;
             }
@@ -1049,9 +1049,9 @@
          return this->priv_size_traits().get_size();
       else{
          size_type len = 0;
- size_type bucket_count = this->priv_bucket_count();
+ size_type bucket_count_ = this->priv_bucket_count();
          const bucket_type *b = boost::intrusive::detail::to_raw_pointer(this->priv_bucket_pointer());
- for (size_type n = 0; n < bucket_count; ++n, ++b){
+ for (size_type n = 0; n < bucket_count_; ++n, ++b){
             len += b->size();
          }
          return len;
@@ -1468,9 +1468,9 @@
          siterator first_local_it(b.slist_it());
          size_type first_bucket_num = this->priv_get_bucket_num(first_local_it);
 
- const bucket_ptr bucket_pointer = this->priv_bucket_pointer();
+ const bucket_ptr bucket_pointer_ = this->priv_bucket_pointer();
          siterator before_first_local_it
- = this->priv_get_previous(bucket_pointer[first_bucket_num], first_local_it);
+ = this->priv_get_previous(bucket_pointer_[first_bucket_num], first_local_it);
          size_type last_bucket_num;
          siterator last_local_it;
 
@@ -1478,7 +1478,7 @@
          //of the last bucket
          if(e == this->end()){
             last_bucket_num = this->bucket_count() - 1;
- last_local_it = bucket_pointer[last_bucket_num].end();
+ last_local_it = bucket_pointer_[last_bucket_num].end();
          }
          else{
             last_local_it = e.slist_it();
@@ -1533,7 +1533,7 @@
       siterator it =
          this->priv_find(key, hash_func, equal_func, bucket_num, h, prev);
       bool success = it != this->priv_invalid_local_it();
- size_type count(0);
+ size_type count_(0);
       if(!success){
          return 0;
       }
@@ -1541,12 +1541,12 @@
          siterator last = bucket_type::s_iterator_to
             (*node_traits::get_next(group_functions_t::get_last_in_group
                (hashtable_impl::dcast_bucket_ptr(it.pointed_node()), optimize_multikey_t())));
- this->priv_erase_range_impl(bucket_num, prev, last, disposer, count);
+ this->priv_erase_range_impl(bucket_num, prev, last, disposer, count_);
       }
       else{
          //If found erase all equal values
          bucket_type &b = this->priv_bucket_pointer()[bucket_num];
- for(siterator end = b.end(); it != end; ++count, ++it){
+ for(siterator end_ = b.end(); it != end_; ++count_, ++it){
             slist_node_ptr n(it.pointed_node());
             const value_type &v = this->priv_value_from_slist_node(n);
             if(compare_hash){
@@ -1563,7 +1563,7 @@
          b.erase_after_and_dispose(prev, it, make_node_disposer(disposer));
       }
       this->priv_erasure_update_cache();
- return count;
+ return count_;
    }
 
    //! <b>Effects</b>: Erases all of the elements.
@@ -1630,9 +1630,9 @@
    template<class KeyType, class KeyHasher, class KeyValueEqual>
    size_type count(const KeyType &key, const KeyHasher &hash_func, const KeyValueEqual &equal_func) const
    {
- size_type bucket_n1, bucket_n2, count;
- this->priv_equal_range(key, hash_func, equal_func, bucket_n1, bucket_n2, count);
- return count;
+ size_type bucket_n1, bucket_n2, count_;
+ this->priv_equal_range(key, hash_func, equal_func, bucket_n1, bucket_n2, count_);
+ return count_;
    }
 
    //! <b>Effects</b>: Finds an iterator to the first element is equal to
@@ -1746,9 +1746,9 @@
    std::pair<iterator,iterator> equal_range
       (const KeyType &key, KeyHasher hash_func, KeyValueEqual equal_func)
    {
- size_type bucket_n1, bucket_n2, count;
+ size_type bucket_n1, bucket_n2, count_;
       std::pair<siterator, siterator> ret = this->priv_equal_range
- (key, hash_func, equal_func, bucket_n1, bucket_n2, count);
+ (key, hash_func, equal_func, bucket_n1, bucket_n2, count_);
       return std::pair<iterator, iterator>
          (iterator(ret.first, this), iterator(ret.second, this));
    }
@@ -1788,9 +1788,9 @@
    std::pair<const_iterator,const_iterator> equal_range
       (const KeyType &key, KeyHasher hash_func, KeyValueEqual equal_func) const
    {
- size_type bucket_n1, bucket_n2, count;
+ size_type bucket_n1, bucket_n2, count_;
       std::pair<siterator, siterator> ret =
- this->priv_equal_range(key, hash_func, equal_func, bucket_n1, bucket_n2, count);
+ this->priv_equal_range(key, hash_func, equal_func, bucket_n1, bucket_n2, count_);
       return std::pair<const_iterator, const_iterator>
          (const_iterator(ret.first, this), const_iterator(ret.second, this));
    }
@@ -2102,9 +2102,9 @@
 
          if(!fast_shrink){
             siterator before_i(old_bucket.before_begin());
- siterator end(old_bucket.end());
+ siterator end_(old_bucket.end());
             siterator i(old_bucket.begin());
- for(;i != end; ++i){
+ for(;i != end_; ++i){
                const value_type &v = this->priv_value_from_slist_node(i.pointed_node());
                const std::size_t hash_value = this->priv_stored_or_compute_hash(v, store_hash_t());
                const size_type new_n = this->priv_hash_to_bucket(hash_value, new_bucket_count, new_bucket_count);
@@ -2159,19 +2159,19 @@
    {
       //This function is only available for containers with incremental hashing
       BOOST_STATIC_ASSERT(( incremental && power_2_buckets ));
- const size_type split_idx = this->priv_split_traits().get_size();
- const size_type bucket_count = this->priv_bucket_count();
- const bucket_ptr bucket_pointer = this->priv_bucket_pointer();
+ const size_type split_idx = this->priv_split_traits().get_size();
+ const size_type bucket_count_ = this->priv_bucket_count();
+ const bucket_ptr bucket_pointer_ = this->priv_bucket_pointer();
 
       if(grow){
          //Test if the split variable can be changed
- if(split_idx >= bucket_count)
+ if(split_idx >= bucket_count_)
             return false;
 
- const size_type bucket_to_rehash = split_idx - bucket_count/2;
- bucket_type &old_bucket = bucket_pointer[bucket_to_rehash];
+ const size_type bucket_to_rehash = split_idx - bucket_count_/2;
+ bucket_type &old_bucket = bucket_pointer_[bucket_to_rehash];
          siterator before_i(old_bucket.before_begin());
- const siterator end(old_bucket.end());
+ const siterator end_(old_bucket.end());
          siterator i(old_bucket.begin());
          this->priv_split_traits().increment();
 
@@ -2179,8 +2179,8 @@
          //moving elements from old_bucket to the target bucket, all moved
          //elements are moved back to the original one.
          detail::incremental_rehash_rollback<bucket_type, split_traits> rollback
- ( bucket_pointer[split_idx], old_bucket, this->priv_split_traits());
- for(;i != end; ++i){
+ ( bucket_pointer_[split_idx], old_bucket, this->priv_split_traits());
+ for(;i != end_; ++i){
             const value_type &v = this->priv_value_from_slist_node(i.pointed_node());
             const std::size_t hash_value = this->priv_stored_or_compute_hash(v, store_hash_t());
             const size_type new_n = this->priv_hash_to_bucket(hash_value);
@@ -2191,7 +2191,7 @@
                before_i = last;
             }
             else{
- bucket_type &new_b = bucket_pointer[new_n];
+ bucket_type &new_b = bucket_pointer_[new_n];
                new_b.splice_after(new_b.before_begin(), old_bucket, before_i, last);
             }
             i = before_i;
@@ -2202,11 +2202,11 @@
       }
       else{
          //Test if the split variable can be changed
- if(split_idx <= bucket_count/2)
+ if(split_idx <= bucket_count_/2)
             return false;
- const size_type target_bucket_num = split_idx - 1 - bucket_count/2;
- bucket_type &target_bucket = bucket_pointer[target_bucket_num];
- bucket_type &source_bucket = bucket_pointer[split_idx-1];
+ const size_type target_bucket_num = split_idx - 1 - bucket_count_/2;
+ bucket_type &target_bucket = bucket_pointer_[target_bucket_num];
+ bucket_type &source_bucket = bucket_pointer_[split_idx-1];
          target_bucket.splice_after(target_bucket.cbefore_begin(), source_bucket);
          this->priv_split_traits().decrement();
          this->priv_insertion_update_cache(target_bucket_num);
@@ -2324,12 +2324,12 @@
    std::size_t priv_hash_to_bucket(std::size_t hash_value) const
    { return this->priv_hash_to_bucket(hash_value, this->priv_real_bucket_traits().bucket_count(), this->priv_split_traits().get_size()); }
 
- std::size_t priv_hash_to_bucket(std::size_t hash_value, std::size_t bucket_count, std::size_t split) const
+ std::size_t priv_hash_to_bucket(std::size_t hash_value, std::size_t bucket_count_, std::size_t split) const
    {
- std::size_t bucket_number = hashtable_impl::priv_hash_to_bucket_impl(hash_value, bucket_count, power_2_buckets_t());
+ std::size_t bucket_number = hashtable_impl::priv_hash_to_bucket_impl(hash_value, bucket_count_, power_2_buckets_t());
       if(incremental)
          if(bucket_number >= split)
- bucket_number -= bucket_count/2;
+ bucket_number -= bucket_count_/2;
       return bucket_number;
    }
 
@@ -2413,20 +2413,20 @@
 
    template<class Disposer>
    void priv_erase_range_impl
- (size_type bucket_num, siterator before_first_it, siterator end, Disposer disposer, size_type &num_erased)
+ (size_type bucket_num, siterator before_first_it, siterator end_, Disposer disposer, size_type &num_erased)
    {
       const bucket_ptr buckets = this->priv_bucket_pointer();
       bucket_type &b = buckets[bucket_num];
 
- if(before_first_it == b.before_begin() && end == b.end()){
+ if(before_first_it == b.before_begin() && end_ == b.end()){
          this->priv_erase_range_impl(bucket_num, 1, disposer, num_erased);
       }
       else{
          num_erased = 0;
          siterator to_erase(before_first_it);
          ++to_erase;
- slist_node_ptr end_ptr = end.pointed_node();
- while(to_erase != end){
+ slist_node_ptr end_ptr = end_.pointed_node();
+ while(to_erase != end_){
             group_functions_t::erase_from_group(end_ptr, hashtable_impl::dcast_bucket_ptr(to_erase.pointed_node()), optimize_multikey_t());
             to_erase = b.erase_after_and_dispose(before_first_it, make_node_disposer(disposer));
             ++num_erased;
@@ -2447,8 +2447,8 @@
          siterator b_begin(b.before_begin());
          siterator nxt(b_begin);
          ++nxt;
- siterator end(b.end());
- while(nxt != end){
+ siterator end_(b.end());
+ while(nxt != end_){
             group_functions_t::init_group(hashtable_impl::dcast_bucket_ptr(nxt.pointed_node()), optimize_multikey_t());
             nxt = b.erase_after_and_dispose
                (b_begin, make_node_disposer(disposer));
@@ -2648,8 +2648,8 @@
    siterator priv_begin(detail::false_) const
    {
       size_type n = 0;
- size_type bucket_count = this->priv_bucket_count();
- for (n = 0; n < bucket_count; ++n){
+ size_type bucket_count_ = this->priv_bucket_count();
+ for (n = 0; n < bucket_count_; ++n){
          bucket_type &b = this->priv_bucket_pointer()[n];
          if(!b.empty()){
             return b.begin();
@@ -2772,9 +2772,9 @@
    void priv_initialize_buckets()
    { this->priv_clear_buckets(this->priv_bucket_pointer(), this->priv_bucket_count()); }
 
- void priv_clear_buckets(bucket_ptr buckets_ptr, size_type bucket_count)
+ void priv_clear_buckets(bucket_ptr buckets_ptr, size_type bucket_count_)
    {
- for(; bucket_count--; ++buckets_ptr){
+ for(; bucket_count_--; ++buckets_ptr){
          if(safemode_or_autounlink){
             hashtable_impl::priv_clear_group_nodes(*buckets_ptr, optimize_multikey_t());
             buckets_ptr->clear_and_dispose(detail::init_disposer<node_algorithms>());
@@ -2877,10 +2877,10 @@
       , KeyValueEqual equal_func
       , size_type &bucket_number_first
       , size_type &bucket_number_second
- , size_type &count) const
+ , size_type &count_) const
    {
       std::size_t h;
- count = 0;
+ count_ = 0;
       siterator prev;
       //Let's see if the element is present
       std::pair<siterator, siterator> to_return
@@ -2892,39 +2892,41 @@
       }
       //If it's present, find the first that it's not equal in
       //the same bucket
- bucket_type &b = this->priv_bucket_pointer()[bucket_number_first];
- siterator it = to_return.first;
- if(optimize_multikey){
- to_return.second = bucket_type::s_iterator_to
- (*node_traits::get_next(group_functions_t::get_last_in_group
- (hashtable_impl::dcast_bucket_ptr(it.pointed_node()), optimize_multikey_t())));
- count = std::distance(it, to_return.second);
- if(to_return.second != b.end()){
- bucket_number_second = bucket_number_first;
- return to_return;
- }
- }
- else{
- ++count;
- ++it;
- while(it != b.end()){
- const value_type &v = this->priv_value_from_slist_node(it.pointed_node());
- if(compare_hash){
- std::size_t hv = this->priv_stored_or_compute_hash(v, store_hash_t());
- if(hv != h || !equal_func(key, v)){
- to_return.second = it;
- bucket_number_second = bucket_number_first;
- return to_return;
- }
- }
- else if(!equal_func(key, v)){
- to_return.second = it;
- bucket_number_second = bucket_number_first;
- return to_return;
- }
- ++it;
- ++count;
- }
+ {
+ bucket_type &b = this->priv_bucket_pointer()[bucket_number_first];
+ siterator it = to_return.first;
+ if(optimize_multikey){
+ to_return.second = bucket_type::s_iterator_to
+ (*node_traits::get_next(group_functions_t::get_last_in_group
+ (hashtable_impl::dcast_bucket_ptr(it.pointed_node()), optimize_multikey_t())));
+ count_ = std::distance(it, to_return.second);
+ if(to_return.second != b.end()){
+ bucket_number_second = bucket_number_first;
+ return to_return;
+ }
+ }
+ else{
+ ++count_;
+ ++it;
+ while(it != b.end()){
+ const value_type &v = this->priv_value_from_slist_node(it.pointed_node());
+ if(compare_hash){
+ std::size_t hv = this->priv_stored_or_compute_hash(v, store_hash_t());
+ if(hv != h || !equal_func(key, v)){
+ to_return.second = it;
+ bucket_number_second = bucket_number_first;
+ return to_return;
+ }
+ }
+ else if(!equal_func(key, v)){
+ to_return.second = it;
+ bucket_number_second = bucket_number_first;
+ return to_return;
+ }
+ ++it;
+ ++count_;
+ }
+ }
       }
 
       //If we reached the end, find the first, non-empty bucket

Modified: branches/release/boost/intrusive/list.hpp
==============================================================================
--- branches/release/boost/intrusive/list.hpp (original)
+++ branches/release/boost/intrusive/list.hpp 2012-10-25 22:55:57 EDT (Thu, 25 Oct 2012)
@@ -928,12 +928,12 @@
    //!
    //! <b>Note</b>: Iterators of values obtained from list x now point to elements of this
    //! list. Iterators of this list and all the references are not invalidated.
- void splice(const_iterator p, list_impl&x, const_iterator start, const_iterator end)
+ void splice(const_iterator p, list_impl&x, const_iterator start, const_iterator end_)
    {
       if(constant_time_size)
- this->splice(p, x, start, end, std::distance(start, end));
+ this->splice(p, x, start, end_, std::distance(start, end_));
       else
- this->splice(p, x, start, end, 1);//distance is a dummy value
+ this->splice(p, x, start, end_, 1);//distance is a dummy value
    }
 
    //! <b>Requires</b>: p must be a valid iterator of *this.
@@ -949,19 +949,19 @@
    //!
    //! <b>Note</b>: Iterators of values obtained from list x now point to elements of this
    //! list. Iterators of this list and all the references are not invalidated.
- void splice(const_iterator p, list_impl&x, const_iterator start, const_iterator end, difference_type n)
+ void splice(const_iterator p, list_impl&x, const_iterator start, const_iterator end_, difference_type n)
    {
       if(n){
          if(constant_time_size){
             size_traits &thist = this->priv_size_traits();
             size_traits &xt = x.priv_size_traits();
- BOOST_INTRUSIVE_INVARIANT_ASSERT(n == std::distance(start, end));
- node_algorithms::transfer(p.pointed_node(), start.pointed_node(), end.pointed_node());
+ BOOST_INTRUSIVE_INVARIANT_ASSERT(n == std::distance(start, end_));
+ node_algorithms::transfer(p.pointed_node(), start.pointed_node(), end_.pointed_node());
             thist.set_size(thist.get_size() + n);
             xt.set_size(xt.get_size() - n);
          }
          else{
- node_algorithms::transfer(p.pointed_node(), start.pointed_node(), end.pointed_node());
+ node_algorithms::transfer(p.pointed_node(), start.pointed_node(), end_.pointed_node());
          }
       }
    }

Modified: branches/release/boost/intrusive/sgtree.hpp
==============================================================================
--- branches/release/boost/intrusive/sgtree.hpp (original)
+++ branches/release/boost/intrusive/sgtree.hpp 2012-10-25 22:55:57 EDT (Thu, 25 Oct 2012)
@@ -701,9 +701,9 @@
    template<class Iterator>
    void insert_equal(Iterator b, Iterator e)
    {
- iterator end(this->end());
+ iterator end_(this->end());
       for (; b != e; ++b)
- this->insert_equal(end, *b);
+ this->insert_equal(end_, *b);
    }
 
    //! <b>Requires</b>: value must be an lvalue
@@ -767,9 +767,9 @@
    void insert_unique(Iterator b, Iterator e)
    {
       if(this->empty()){
- iterator end(this->end());
+ iterator end_(this->end());
          for (; b != e; ++b)
- this->insert_unique(end, *b);
+ this->insert_unique(end_, *b);
       }
       else{
          for (; b != e; ++b)

Modified: branches/release/boost/intrusive/slist.hpp
==============================================================================
--- branches/release/boost/intrusive/slist.hpp (original)
+++ branches/release/boost/intrusive/slist.hpp 2012-10-25 22:55:57 EDT (Thu, 25 Oct 2012)
@@ -758,9 +758,9 @@
    //!
    //! <b>Note</b>: Does not affect the validity of iterators and references.
    template<class Iterator>
- void insert_after(const_iterator prev_p, Iterator first, Iterator last)
+ void insert_after(const_iterator prev_p, Iterator first, Iterator last_)
    {
- for (; first != last; ++first)
+ for (; first != last_; ++first)
          prev_p = this->insert_after(prev_p, *first);
    }
 
@@ -825,21 +825,21 @@
    //!
    //! <b>Note</b>: Invalidates the iterators (but not the references) to the
    //! erased element.
- iterator erase_after(const_iterator before_first, const_iterator last)
+ iterator erase_after(const_iterator before_first, const_iterator last_)
    {
       if(safemode_or_autounlink || constant_time_size){
- return this->erase_after_and_dispose(before_first, last, detail::null_disposer());
+ return this->erase_after_and_dispose(before_first, last_, detail::null_disposer());
       }
       else{
          node_ptr bfp = before_first.pointed_node();
- node_ptr lp = last.pointed_node();
+ node_ptr lp = last_.pointed_node();
          if(cache_last){
             if(lp == this->get_end_node()){
                this->set_last_node(bfp);
             }
          }
          node_algorithms::unlink_after(bfp, lp);
- return last.unconst();
+ return last_.unconst();
       }
    }
 
@@ -857,15 +857,15 @@
    //!
    //! <b>Note</b>: Invalidates the iterators (but not the references) to the
    //! erased element.
- iterator erase_after(const_iterator before_first, const_iterator last, difference_type n)
+ iterator erase_after(const_iterator before_first, const_iterator last_, difference_type n)
    {
- BOOST_INTRUSIVE_INVARIANT_ASSERT(std::distance(++const_iterator(before_first), last) == difference_type(n));
+ BOOST_INTRUSIVE_INVARIANT_ASSERT(std::distance(++const_iterator(before_first), last_) == difference_type(n));
       if(safemode_or_autounlink){
- return this->erase_after(before_first, last);
+ return this->erase_after(before_first, last_);
       }
       else{
          node_ptr bfp = before_first.pointed_node();
- node_ptr lp = last.pointed_node();
+ node_ptr lp = last_.pointed_node();
          if(cache_last){
             if((lp == this->get_end_node())){
                this->set_last_node(bfp);
@@ -875,7 +875,7 @@
          if(constant_time_size){
             this->priv_size_traits().set_size(this->priv_size_traits().get_size() - n);
          }
- return last.unconst();
+ return last_.unconst();
       }
    }
 
@@ -908,8 +908,8 @@
    //!
    //! <b>Note</b>: Invalidates the iterators (but not the references) to the
    //! erased elements.
- iterator erase(const_iterator first, const_iterator last)
- { return this->erase_after(this->previous(first), last); }
+ iterator erase(const_iterator first, const_iterator last_)
+ { return this->erase_after(this->previous(first), last_); }
 
    //! <b>Effects</b>: Erases the range [first, last) from
    //! the list. n must be std::distance(first, last).
@@ -925,8 +925,8 @@
    //!
    //! <b>Note</b>: Invalidates the iterators (but not the references) to the
    //! erased element.
- iterator erase(const_iterator first, const_iterator last, difference_type n)
- { return this->erase_after(this->previous(first), last, n); }
+ iterator erase(const_iterator first, const_iterator last_, difference_type n)
+ { return this->erase_after(this->previous(first), last_, n); }
 
    //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
    //!
@@ -999,9 +999,9 @@
    //!
    //! <b>Note</b>: Invalidates the iterators to the erased element.
    template<class Disposer>
- iterator erase_after_and_dispose(const_iterator before_first, const_iterator last, Disposer disposer)
+ iterator erase_after_and_dispose(const_iterator before_first, const_iterator last_, Disposer disposer)
    {
- node_ptr bfp(before_first.pointed_node()), lp(last.pointed_node());
+ node_ptr bfp(before_first.pointed_node()), lp(last_.pointed_node());
       node_ptr fp(node_traits::get_next(bfp));
       node_algorithms::unlink_after(bfp, lp);
       while(fp != lp){
@@ -1015,7 +1015,7 @@
       if(cache_last && (node_traits::get_next(bfp) == this->get_end_node())){
          this->set_last_node(bfp);
       }
- return last.unconst();
+ return last_.unconst();
    }
 
    //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
@@ -1061,8 +1061,8 @@
    //! <b>Note</b>: Invalidates the iterators (but not the references) to the
    //! erased elements.
    template<class Disposer>
- iterator erase_and_dispose(const_iterator first, const_iterator last, Disposer disposer)
- { return this->erase_after_and_dispose(this->previous(first), last, disposer); }
+ iterator erase_and_dispose(const_iterator first, const_iterator last_, Disposer disposer)
+ { return this->erase_after_and_dispose(this->previous(first), last_, disposer); }
 
    //! <b>Requires</b>: Dereferencing iterator must yield
    //! an lvalue of type value_type.
@@ -1130,14 +1130,14 @@
    //! assigned to the last spliced element or prev if x is empty.
    //! This iterator can be used as new "prev" iterator for a new splice_after call.
    //! that will splice new values after the previously spliced values.
- void splice_after(const_iterator prev, slist_impl &x, const_iterator *last = 0)
+ void splice_after(const_iterator prev, slist_impl &x, const_iterator *last_ = 0)
    {
       if(x.empty()){
- if(last) *last = prev;
+ if(last_) *last_ = prev;
       }
       else if(linear && this->empty()){
          this->swap(x);
- if(last) *last = this->previous(this->cend());
+ if(last_) *last_ = this->previous(this->cend());
       }
       else{
          const_iterator last_x(x.previous(x.end())); //<- constant time if cache_last is active
@@ -1152,7 +1152,7 @@
          node_algorithms::transfer_after( prev_n, x.before_begin().pointed_node(), last_x_n);
          this->priv_size_traits().set_size(this->priv_size_traits().get_size() + x.priv_size_traits().get_size());
          x.priv_size_traits().set_size(size_type(0));
- if(last) *last = last_x;
+ if(last_) *last_ = last_x;
       }
    }
 
@@ -1247,8 +1247,8 @@
    //! assigned to the last spliced element or prev if x is empty.
    //! This iterator can be used as new "prev" iterator for a new splice_after call.
    //! that will splice new values after the previously spliced values.
- void splice(const_iterator it, slist_impl &x, const_iterator *last = 0)
- { this->splice_after(this->previous(it), x, last); }
+ void splice(const_iterator it, slist_impl &x, const_iterator *last_ = 0)
+ { this->splice_after(this->previous(it), x, last_); }
 
    //! <b>Requires</b>: it p must be a valid iterator of *this.
    //! elem must point to an element contained in list
@@ -1284,8 +1284,8 @@
    //!
    //! <b>Note</b>: Iterators of values obtained from list x now point to elements of this
    //! list. Iterators of this list and all the references are not invalidated.
- void splice(const_iterator pos, slist_impl &x, const_iterator first, const_iterator last)
- { return this->splice_after(this->previous(pos), x, x.previous(first), x.previous(last)); }
+ void splice(const_iterator pos, slist_impl &x, const_iterator first, const_iterator last_)
+ { return this->splice_after(this->previous(pos), x, x.previous(first), x.previous(last_)); }
 
    //! <b>Requires</b>: pos must be a dereferenceable iterator in *this
    //! and first and last belong to x and first and last a valid range on x.
@@ -1303,8 +1303,8 @@
    //!
    //! <b>Note</b>: Iterators of values obtained from list x now point to elements of this
    //! list. Iterators of this list and all the references are not invalidated.
- void splice(const_iterator pos, slist_impl &x, const_iterator first, const_iterator last, difference_type n)
- { return this->splice_after(this->previous(pos), x, x.previous(first), x.previous(last), n); }
+ void splice(const_iterator pos, slist_impl &x, const_iterator first, const_iterator last_, difference_type n)
+ { return this->splice_after(this->previous(pos), x, x.previous(first), x.previous(last_), n); }
 
    //! <b>Effects</b>: This function sorts the list *this according to std::less<value_type>.
    //! The sort is stable, that is, the relative order of equivalent elements is preserved.
@@ -1405,11 +1405,11 @@
    //! <b>Additional note</b>: If optional "last" argument is passed, it is assigned
    //! to an iterator to the last transferred value or end() is x is empty.
    template<class Predicate>
- void merge(slist_impl& x, Predicate p, const_iterator *last = 0)
+ void merge(slist_impl& x, Predicate p, const_iterator *last_ = 0)
    {
       const_iterator e(this->cend()), ex(x.cend()), bb(this->cbefore_begin()),
                      bb_next;
- if(last) *last = e.unconst();
+ if(last_) *last_ = e.unconst();
       while(!x.empty()){
          const_iterator ibx_next(x.cbefore_begin()), ibx(ibx_next++);
          while (++(bb_next = bb) != e && !p(*ibx_next, *bb_next)){
@@ -1417,7 +1417,7 @@
          }
          if(bb_next == e){
             //Now transfer the rest to the end of the container
- this->splice_after(bb, x, last);
+ this->splice_after(bb, x, last_);
             break;
          }
          else{
@@ -1426,7 +1426,7 @@
                ibx = ibx_next; ++n;
             } while(++(ibx_next = ibx) != ex && p(*ibx_next, *bb_next));
             this->splice_after(bb, x, x.before_begin(), ibx, n);
- if(last) *last = ibx;
+ if(last_) *last_ = ibx;
          }
       }
    }
@@ -1816,9 +1816,9 @@
 
    void priv_shift_backwards(size_type n, detail::bool_<false>)
    {
- node_ptr last = node_algorithms::move_forward(this->get_root_node(), (std::size_t)n);
- if(cache_last && last){
- this->set_last_node(last);
+ node_ptr last_ = node_algorithms::move_forward(this->get_root_node(), (std::size_t)n);
+ if(cache_last && last_){
+ this->set_last_node(last_);
       }
    }
 
@@ -1837,9 +1837,9 @@
 
    void priv_shift_forward(size_type n, detail::bool_<false>)
    {
- node_ptr last = node_algorithms::move_backwards(this->get_root_node(), (std::size_t)n);
- if(cache_last && last){
- this->set_last_node(last);
+ node_ptr last_ = node_algorithms::move_backwards(this->get_root_node(), (std::size_t)n);
+ if(cache_last && last_){
+ this->set_last_node(last_);
       }
    }
 

Modified: branches/release/boost/intrusive/splaytree.hpp
==============================================================================
--- branches/release/boost/intrusive/splaytree.hpp (original)
+++ branches/release/boost/intrusive/splaytree.hpp 2012-10-25 22:55:57 EDT (Thu, 25 Oct 2012)
@@ -540,9 +540,9 @@
    void insert_equal(Iterator b, Iterator e)
    {
       if(this->empty()){
- iterator end(this->end());
+ iterator end_(this->end());
          for (; b != e; ++b)
- this->insert_equal(end, *b);
+ this->insert_equal(end_, *b);
       }
    }
 

Modified: branches/release/boost/intrusive/treap.hpp
==============================================================================
--- branches/release/boost/intrusive/treap.hpp (original)
+++ branches/release/boost/intrusive/treap.hpp 2012-10-25 22:55:57 EDT (Thu, 25 Oct 2012)
@@ -627,9 +627,9 @@
    template<class Iterator>
    void insert_equal(Iterator b, Iterator e)
    {
- iterator end(this->end());
+ iterator end_(this->end());
       for (; b != e; ++b)
- this->insert_equal(end, *b);
+ this->insert_equal(end_, *b);
    }
 
    //! <b>Requires</b>: value must be an lvalue
@@ -696,9 +696,9 @@
    void insert_unique(Iterator b, Iterator e)
    {
       if(this->empty()){
- iterator end(this->end());
+ iterator end_(this->end());
          for (; b != e; ++b)
- this->insert_unique(end, *b);
+ this->insert_unique(end_, *b);
       }
       else{
          for (; b != e; ++b)


Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk