Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r76179 - in branches/release/boost: container container/allocator container/detail intrusive intrusive/detail move
From: igaztanaga_at_[hidden]
Date: 2011-12-26 12:10:32

Next message: igaztanaga_at_[hidden]: "[Boost-commit] svn:boost r76180 - in branches/release/libs/container: . doc doc/html doc/html/images example proj proj/vc7ide test"
Previous message: john_at_[hidden]: "[Boost-commit] svn:boost r76178 - in branches/release/libs: math/doc/sf_and_dist/graphs regex/doc"

Author: igaztanaga
Date: 2011-12-26 12:10:27 EST (Mon, 26 Dec 2011)
New Revision: 76179
URL: http://svn.boost.org/trac/boost/changeset/76179

Log:
Changes for 1.49
Added:
   branches/release/boost/container/allocator/
      - copied from r76178, /trunk/boost/container/allocator/
   branches/release/boost/container/container_fwd.hpp
      - copied unchanged from r76178, /trunk/boost/container/container_fwd.hpp
   branches/release/boost/container/deque.hpp
      - copied unchanged from r76178, /trunk/boost/container/deque.hpp
   branches/release/boost/container/detail/ (props changed)
      - copied from r76178, /trunk/boost/container/detail/
   branches/release/boost/container/flat_map.hpp
      - copied unchanged from r76178, /trunk/boost/container/flat_map.hpp
   branches/release/boost/container/flat_set.hpp
      - copied unchanged from r76178, /trunk/boost/container/flat_set.hpp
   branches/release/boost/container/list.hpp
      - copied unchanged from r76178, /trunk/boost/container/list.hpp
   branches/release/boost/container/map.hpp
      - copied unchanged from r76178, /trunk/boost/container/map.hpp
   branches/release/boost/container/set.hpp
      - copied unchanged from r76178, /trunk/boost/container/set.hpp
   branches/release/boost/container/slist.hpp
      - copied unchanged from r76178, /trunk/boost/container/slist.hpp
   branches/release/boost/container/stable_vector.hpp
      - copied unchanged from r76178, /trunk/boost/container/stable_vector.hpp
   branches/release/boost/container/string.hpp
      - copied unchanged from r76178, /trunk/boost/container/string.hpp
   branches/release/boost/container/vector.hpp
      - copied unchanged from r76178, /trunk/boost/container/vector.hpp
   branches/release/boost/intrusive/detail/has_member_function_callable_with.hpp
      - copied unchanged from r76178, /trunk/boost/intrusive/detail/has_member_function_callable_with.hpp
   branches/release/boost/intrusive/detail/memory_util.hpp
      - copied unchanged from r76178, /trunk/boost/intrusive/detail/memory_util.hpp
   branches/release/boost/intrusive/detail/preprocessor.hpp
      - copied unchanged from r76178, /trunk/boost/intrusive/detail/preprocessor.hpp
   branches/release/boost/intrusive/pointer_traits.hpp
      - copied unchanged from r76178, /trunk/boost/intrusive/pointer_traits.hpp
Removed:
   branches/release/boost/intrusive/detail/pointer_to_other.hpp
Properties modified:
   branches/release/boost/intrusive/ (props changed)
Text files modified:
   branches/release/boost/intrusive/any_hook.hpp | 10
   branches/release/boost/intrusive/avltree.hpp | 118 ++++++------
   branches/release/boost/intrusive/avltree_algorithms.hpp | 104 +++++-----
   branches/release/boost/intrusive/circular_list_algorithms.hpp | 56 +++--
   branches/release/boost/intrusive/circular_slist_algorithms.hpp | 44 ++--
   branches/release/boost/intrusive/derivation_value_traits.hpp | 10
   branches/release/boost/intrusive/detail/any_node_and_algorithms.hpp | 145 +++++++--------
   branches/release/boost/intrusive/detail/avltree_node.hpp | 68 ++++---
   branches/release/boost/intrusive/detail/common_slist_algorithms.hpp | 24 +-
   branches/release/boost/intrusive/detail/function_detector.hpp | 1
   branches/release/boost/intrusive/detail/generic_hook.hpp | 22 +
   branches/release/boost/intrusive/detail/hashtable_node.hpp | 51 +++--
   branches/release/boost/intrusive/detail/list_node.hpp | 38 ++--
   branches/release/boost/intrusive/detail/rbtree_node.hpp | 62 +++---
   branches/release/boost/intrusive/detail/slist_node.hpp | 28 +-
   branches/release/boost/intrusive/detail/tree_algorithms.hpp | 230 +++++++++++++------------
   branches/release/boost/intrusive/detail/tree_node.hpp | 38 ++--
   branches/release/boost/intrusive/detail/utilities.hpp | 280 +++++++++++++++++++++++-------
   branches/release/boost/intrusive/detail/workaround.hpp | 18 -
   branches/release/boost/intrusive/hashtable.hpp | 356 +++++++++++++++++++++++++--------------
   branches/release/boost/intrusive/linear_slist_algorithms.hpp | 48 ++--
   branches/release/boost/intrusive/list.hpp | 28 +-
   branches/release/boost/intrusive/member_value_traits.hpp | 31 ++-
   branches/release/boost/intrusive/rbtree.hpp | 105 +++++-----
   branches/release/boost/intrusive/rbtree_algorithms.hpp | 107 ++++++-----
   branches/release/boost/intrusive/sgtree.hpp | 107 ++++++-----
   branches/release/boost/intrusive/sgtree_algorithms.hpp | 89 ++++-----
   branches/release/boost/intrusive/slist.hpp | 58 +++---
   branches/release/boost/intrusive/splaytree.hpp | 108 ++++++-----
   branches/release/boost/intrusive/splaytree_algorithms.hpp | 147 ++++++++--------
   branches/release/boost/intrusive/treap.hpp | 118 ++++++------
   branches/release/boost/intrusive/treap_algorithms.hpp | 99 +++++-----
   branches/release/boost/intrusive/trivial_value_traits.hpp | 11
   branches/release/boost/intrusive/unordered_set_hook.hpp | 59 +++---
   branches/release/boost/move/move.hpp | 113 ++++++++++++
   35 files changed, 1656 insertions(+), 1275 deletions(-)

Modified: branches/release/boost/intrusive/any_hook.hpp
==============================================================================
--- branches/release/boost/intrusive/any_hook.hpp (original)
+++ branches/release/boost/intrusive/any_hook.hpp 2011-12-26 12:10:27 EST (Mon, 26 Dec 2011)
@@ -19,7 +19,7 @@
#include <boost/intrusive/detail/any_node_and_algorithms.hpp>
#include <boost/intrusive/options.hpp>
#include <boost/intrusive/detail/generic_hook.hpp>
-#include <boost/intrusive/detail/pointer_to_other.hpp>
+#include <boost/intrusive/pointer_traits.hpp>

namespace boost {
namespace intrusive {
@@ -244,15 +244,15 @@
template<class ValueTraits>
struct any_to_get_base_pointer_type
{
- typedef typename pointer_to_other
- <typename ValueTraits::boost_intrusive_tags::node_traits::node_ptr, void>::type type;
+ typedef typename pointer_traits<typename ValueTraits::boost_intrusive_tags::node_traits::node_ptr>::template
+ rebind_pointer<void>::type type;
};

template<class ValueTraits>
struct any_to_get_member_pointer_type
{
- typedef typename pointer_to_other
- <typename ValueTraits::node_ptr, void>::type type;
+ typedef typename pointer_traits
+ <typename ValueTraits::node_ptr>::template rebind_pointer<void>::type type;
};

//!This option setter specifies that the container

Modified: branches/release/boost/intrusive/avltree.hpp
==============================================================================
--- branches/release/boost/intrusive/avltree.hpp (original)
+++ branches/release/boost/intrusive/avltree.hpp 2011-12-26 12:10:27 EST (Mon, 26 Dec 2011)
@@ -27,9 +27,11 @@
#include <boost/intrusive/detail/tree_node.hpp>
#include <boost/intrusive/detail/ebo_functor_holder.hpp>
#include <boost/intrusive/detail/mpl.hpp>
-#include <boost/intrusive/detail/pointer_to_other.hpp>
+#include <boost/intrusive/pointer_traits.hpp>
+#include <boost/intrusive/pointer_traits.hpp>
#include <boost/intrusive/detail/clear_on_destructor_base.hpp>
#include <boost/intrusive/options.hpp>
+#include <boost/intrusive/detail/utilities.hpp>
#include <boost/intrusive/avltree_algorithms.hpp>
#include <boost/intrusive/link_mode.hpp>
#include <boost/move/move.hpp>
@@ -96,24 +98,30 @@
 /// @endcond
 typedef typename real_value_traits::pointer pointer;
 typedef typename real_value_traits::const_pointer const_pointer;
- typedef typename std::iterator_traits<pointer>::value_type value_type;
+ typedef typename boost::intrusive::
+ pointer_traits<pointer>::element_type value_type;
 typedef value_type key_type;
- typedef typename std::iterator_traits<pointer>::reference reference;
- typedef typename std::iterator_traits<const_pointer>::reference const_reference;
- typedef typename std::iterator_traits<pointer>::difference_type difference_type;
+ typedef typename boost::intrusive::
+ pointer_traits<pointer>::reference reference;
+ typedef typename boost::intrusive::
+ pointer_traits<const_pointer>::reference const_reference;
+ typedef typename boost::intrusive::
+ pointer_traits<pointer>::difference_type difference_type;
 typedef typename Config::size_type size_type;
 typedef typename Config::compare value_compare;
 typedef value_compare key_compare;
- typedef tree_iterator<avltree_impl, false> iterator;
- typedef tree_iterator<avltree_impl, true> const_iterator;
- typedef std::reverse_iterator<iterator> reverse_iterator;
- typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+ typedef tree_iterator<avltree_impl, false> iterator;
+ typedef tree_iterator<avltree_impl, true> const_iterator;
+ typedef boost::intrusive::detail::reverse_iterator<iterator> reverse_iterator;
+ typedef boost::intrusive::detail::reverse_iterator<const_iterator>const_reverse_iterator;
 typedef typename real_value_traits::node_traits node_traits;
 typedef typename node_traits::node node;
- typedef typename boost::pointer_to_other
- <pointer, node>::type node_ptr;
- typedef typename boost::pointer_to_other
- <node_ptr, const node>::type const_node_ptr;
+ typedef typename pointer_traits
+ <pointer>::template rebind_pointer
+ <node>::type node_ptr;
+ typedef typename pointer_traits
+ <pointer>::template rebind_pointer
+ <const node>::type const_node_ptr;
 typedef avltree_algorithms<node_traits> node_algorithms;

 static const bool constant_time_size = Config::constant_time_size;
@@ -165,16 +173,14 @@
 value_traits &priv_value_traits()
 { return data_; }

- const node &priv_header() const
- { return data_.node_plus_pred_.header_plus_size_.header_; }
+ node_ptr priv_header_ptr()
+ { return pointer_traits<node_ptr>::pointer_to(data_.node_plus_pred_.header_plus_size_.header_); }

- node &priv_header()
- { return data_.node_plus_pred_.header_plus_size_.header_; }
+ const_node_ptr priv_header_ptr() const
+ { return pointer_traits<const_node_ptr>::pointer_to(data_.node_plus_pred_.header_plus_size_.header_); }

- static node_ptr uncast(const_node_ptr ptr)
- {
- return node_ptr(const_cast<node*>(detail::boost_intrusive_get_pointer(ptr)));
- }
+ static node_ptr uncast(const const_node_ptr & ptr)
+ { return pointer_traits<node_ptr>::const_cast_from(ptr); }

 size_traits &priv_size_traits()
 { return data_.node_plus_pred_.header_plus_size_; }
@@ -217,7 +223,7 @@
 , const value_traits &v_traits = value_traits())
 : data_(cmp, v_traits)
 {
- node_algorithms::init_header(&priv_header());
+ node_algorithms::init_header(this->priv_header_ptr());
 this->priv_size_traits().set_size(size_type(0));
 }

@@ -239,7 +245,7 @@
 , const value_traits &v_traits = value_traits())
 : data_(cmp, v_traits)
 {
- node_algorithms::init_header(&priv_header());
+ node_algorithms::init_header(this->priv_header_ptr());
 this->priv_size_traits().set_size(size_type(0));
 if(unique)
 this->insert_unique(b, e);
@@ -252,7 +258,7 @@
 avltree_impl(BOOST_RV_REF(avltree_impl) x)
 : data_(::boost::move(x.priv_comp()), ::boost::move(x.priv_value_traits()))
 {
- node_algorithms::init_header(&priv_header());
+ node_algorithms::init_header(this->priv_header_ptr());
 this->priv_size_traits().set_size(size_type(0));
 this->swap(x);
 }
@@ -278,7 +284,7 @@
 //!
 //! Throws: Nothing.
 iterator begin()
- { return iterator (node_traits::get_left(node_ptr(&priv_header())), this); }
+ { return iterator (node_traits::get_left(this->priv_header_ptr()), this); }

 //! Effects: Returns a const_iterator pointing to the beginning of the tree.
 //!
@@ -294,7 +300,7 @@
 //!
 //! Throws: Nothing.
 const_iterator cbegin() const
- { return const_iterator (node_traits::get_left(const_node_ptr(&priv_header())), this); }
+ { return const_iterator (node_traits::get_left(this->priv_header_ptr()), this); }

 //! Effects: Returns an iterator pointing to the end of the tree.
 //!
@@ -302,7 +308,7 @@
 //!
 //! Throws: Nothing.
 iterator end()
- { return iterator (node_ptr(&priv_header()), this); }
+ { return iterator (this->priv_header_ptr(), this); }

 //! Effects: Returns a const_iterator pointing to the end of the tree.
 //!
@@ -318,7 +324,7 @@
 //!
 //! Throws: Nothing.
 const_iterator cend() const
- { return const_iterator (uncast(const_node_ptr(&priv_header())), this); }
+ { return const_iterator (uncast(this->priv_header_ptr()), this); }

 //! Effects: Returns a reverse_iterator pointing to the beginning of the
 //! reversed tree.
@@ -432,7 +438,7 @@
 //!
 //! Throws: Nothing.
 bool empty() const
- { return node_algorithms::unique(const_node_ptr(&priv_header())); }
+ { return node_algorithms::unique(this->priv_header_ptr()); }

 //! Effects: Returns the number of elements stored in the tree.
 //!
@@ -445,7 +451,7 @@
 if(constant_time_size)
 return this->priv_size_traits().get_size();
 else{
- return (size_type)node_algorithms::size(const_node_ptr(&priv_header()));
+ return (size_type)node_algorithms::size(this->priv_header_ptr());
 }
 }

@@ -460,7 +466,7 @@
 using std::swap;
 swap(priv_comp(), priv_comp());
 //These can't throw
- node_algorithms::swap_tree(node_ptr(&priv_header()), node_ptr(&other.priv_header()));
+ node_algorithms::swap_tree(this->priv_header_ptr(), other.priv_header_ptr());
 if(constant_time_size){
 size_type backup = this->priv_size_traits().get_size();
 this->priv_size_traits().set_size(other.priv_size_traits().get_size());
@@ -487,7 +493,7 @@
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
 iterator ret(node_algorithms::insert_equal_upper_bound
- (node_ptr(&priv_header()), to_insert, key_node_comp), this);
+ (this->priv_header_ptr(), to_insert, key_node_comp), this);
 this->priv_size_traits().increment();
 return ret;
 }
@@ -514,7 +520,7 @@
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
 iterator ret(node_algorithms::insert_equal
- (node_ptr(&priv_header()), hint.pointed_node(), to_insert, key_node_comp), this);
+ (this->priv_header_ptr(), hint.pointed_node(), to_insert, key_node_comp), this);
 this->priv_size_traits().increment();
 return ret;
 }
@@ -650,7 +656,7 @@
 comp(key_value_comp, this);
 std::pair<node_ptr, bool> ret =
 (node_algorithms::insert_unique_check
- (node_ptr(&priv_header()), key, comp, commit_data));
+ (this->priv_header_ptr(), key, comp, commit_data));
 return std::pair<iterator, bool>(iterator(ret.first, this), ret.second);
 }

@@ -695,7 +701,7 @@
 comp(key_value_comp, this);
 std::pair<node_ptr, bool> ret =
 (node_algorithms::insert_unique_check
- (node_ptr(&priv_header()), hint.pointed_node(), key, comp, commit_data));
+ (this->priv_header_ptr(), hint.pointed_node(), key, comp, commit_data));
 return std::pair<iterator, bool>(iterator(ret.first, this), ret.second);
 }

@@ -722,7 +728,7 @@
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
 node_algorithms::insert_unique_commit
- (node_ptr(&priv_header()), to_insert, commit_data);
+ (this->priv_header_ptr(), to_insert, commit_data);
 this->priv_size_traits().increment();
 return iterator(to_insert, this);
 }
@@ -747,7 +753,7 @@
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
 iterator ret(node_algorithms::insert_before
- (node_ptr(&priv_header()), pos.pointed_node(), to_insert), this);
+ (this->priv_header_ptr(), pos.pointed_node(), to_insert), this);
 this->priv_size_traits().increment();
 return ret;
 }
@@ -771,7 +777,7 @@
 node_ptr to_insert(get_real_value_traits().to_node_ptr(value));
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
- node_algorithms::push_back(node_ptr(&priv_header()), to_insert);
+ node_algorithms::push_back(this->priv_header_ptr(), to_insert);
 this->priv_size_traits().increment();
 }

@@ -794,7 +800,7 @@
 node_ptr to_insert(get_real_value_traits().to_node_ptr(value));
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
- node_algorithms::push_front(node_ptr(&priv_header()), to_insert);
+ node_algorithms::push_front(this->priv_header_ptr(), to_insert);
 this->priv_size_traits().increment();
 }

@@ -813,7 +819,7 @@
 node_ptr to_erase(i.pointed_node());
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!node_algorithms::unique(to_erase));
- node_algorithms::erase(&priv_header(), to_erase);
+ node_algorithms::erase(this->priv_header_ptr(), to_erase);
 this->priv_size_traits().decrement();
 if(safemode_or_autounlink)
 node_algorithms::init(to_erase);
@@ -975,7 +981,7 @@
 this->clear_and_dispose(detail::null_disposer());
 }
 else{
- node_algorithms::init_header(&priv_header());
+ node_algorithms::init_header(this->priv_header_ptr());
 this->priv_size_traits().set_size(0);
 }
 }
@@ -992,9 +998,9 @@
 template<class Disposer>
 void clear_and_dispose(Disposer disposer)
 {
- node_algorithms::clear_and_dispose(node_ptr(&priv_header())
+ node_algorithms::clear_and_dispose(this->priv_header_ptr()
 , detail::node_disposer<Disposer, avltree_impl>(disposer, this));
- node_algorithms::init_header(&priv_header());
+ node_algorithms::init_header(this->priv_header_ptr());
 this->priv_size_traits().set_size(0);
 }

@@ -1050,7 +1056,7 @@
 detail::key_nodeptr_comp<KeyValueCompare, avltree_impl>
 key_node_comp(comp, this);
 return iterator(node_algorithms::lower_bound
- (const_node_ptr(&priv_header()), key, key_node_comp), this);
+ (this->priv_header_ptr(), key, key_node_comp), this);
 }

 //! Effects: Returns a const iterator to the first element whose
@@ -1065,7 +1071,7 @@
 detail::key_nodeptr_comp<KeyValueCompare, avltree_impl>
 key_node_comp(comp, this);
 return const_iterator(node_algorithms::lower_bound
- (const_node_ptr(&priv_header()), key, key_node_comp), this);
+ (this->priv_header_ptr(), key, key_node_comp), this);
 }

 //! Effects: Returns an iterator to the first element whose
@@ -1090,7 +1096,7 @@
 detail::key_nodeptr_comp<KeyValueCompare, avltree_impl>
 key_node_comp(comp, this);
 return iterator(node_algorithms::upper_bound
- (const_node_ptr(&priv_header()), key, key_node_comp), this);
+ (this->priv_header_ptr(), key, key_node_comp), this);
 }

 //! Effects: Returns an iterator to the first element whose
@@ -1115,7 +1121,7 @@
 detail::key_nodeptr_comp<KeyValueCompare, avltree_impl>
 key_node_comp(comp, this);
 return const_iterator(node_algorithms::upper_bound
- (const_node_ptr(&priv_header()), key, key_node_comp), this);
+ (this->priv_header_ptr(), key, key_node_comp), this);
 }

 //! Effects: Finds an iterator to the first element whose key is
@@ -1139,7 +1145,7 @@
 detail::key_nodeptr_comp<KeyValueCompare, avltree_impl>
 key_node_comp(comp, this);
 return iterator
- (node_algorithms::find(const_node_ptr(&priv_header()), key, key_node_comp), this);
+ (node_algorithms::find(this->priv_header_ptr(), key, key_node_comp), this);
 }

 //! Effects: Finds a const_iterator to the first element whose key is
@@ -1163,7 +1169,7 @@
 detail::key_nodeptr_comp<KeyValueCompare, avltree_impl>
 key_node_comp(comp, this);
 return const_iterator
- (node_algorithms::find(const_node_ptr(&priv_header()), key, key_node_comp), this);
+ (node_algorithms::find(this->priv_header_ptr(), key, key_node_comp), this);
 }

 //! Effects: Finds a range containing all elements whose key is k or
@@ -1189,7 +1195,7 @@
 detail::key_nodeptr_comp<KeyValueCompare, avltree_impl>
 key_node_comp(comp, this);
 std::pair<node_ptr, node_ptr> ret
- (node_algorithms::equal_range(const_node_ptr(&priv_header()), key, key_node_comp));
+ (node_algorithms::equal_range(this->priv_header_ptr(), key, key_node_comp));
 return std::pair<iterator, iterator>(iterator(ret.first, this), iterator(ret.second, this));
 }

@@ -1218,7 +1224,7 @@
 detail::key_nodeptr_comp<KeyValueCompare, avltree_impl>
 key_node_comp(comp, this);
 std::pair<node_ptr, node_ptr> ret
- (node_algorithms::equal_range(const_node_ptr(&priv_header()), key, key_node_comp));
+ (node_algorithms::equal_range(this->priv_header_ptr(), key, key_node_comp));
 return std::pair<const_iterator, const_iterator>(const_iterator(ret.first, this), const_iterator(ret.second, this));
 }

@@ -1244,8 +1250,8 @@
 detail::exception_disposer<avltree_impl, Disposer>
 rollback(*this, disposer);
 node_algorithms::clone
- (const_node_ptr(&src.priv_header())
- ,node_ptr(&this->priv_header())
+ (src.priv_header_ptr()
+ ,this->priv_header_ptr()
 ,detail::node_cloner<Cloner, avltree_impl>(cloner, this)
 ,detail::node_disposer<Disposer, avltree_impl>(disposer, this));
 this->priv_size_traits().set_size(src.priv_size_traits().get_size());
@@ -1267,7 +1273,7 @@
 pointer unlink_leftmost_without_rebalance()
 {
 node_ptr to_be_disposed(node_algorithms::unlink_leftmost_without_rebalance
- (node_ptr(&priv_header())));
+ (this->priv_header_ptr()));
 if(!to_be_disposed)
 return 0;
 this->priv_size_traits().decrement();
@@ -1293,7 +1299,7 @@
 void replace_node(iterator replace_this, reference with_this)
 {
 node_algorithms::replace_node( get_real_value_traits().to_node_ptr(*replace_this)
- , node_ptr(&priv_header())
+ , this->priv_header_ptr()
 , get_real_value_traits().to_node_ptr(with_this));
 if(safemode_or_autounlink)
 node_algorithms::init(replace_this.pointed_node());
@@ -1424,7 +1430,7 @@
 static avltree_impl &priv_container_from_end_iterator(const const_iterator &end_iterator)
 {
 header_plus_size *r = detail::parent_from_member<header_plus_size, node>
- ( detail::boost_intrusive_get_pointer(end_iterator.pointed_node()), &header_plus_size::header_);
+ ( boost::intrusive::detail::to_raw_pointer(end_iterator.pointed_node()), &header_plus_size::header_);
 node_plus_pred_t *n = detail::parent_from_member
 <node_plus_pred_t, header_plus_size>(r, &node_plus_pred_t::header_plus_size_);
 data_t *d = detail::parent_from_member<data_t, node_plus_pred_t>(n, &data_t::node_plus_pred_);

Modified: branches/release/boost/intrusive/avltree_algorithms.hpp
==============================================================================
--- branches/release/boost/intrusive/avltree_algorithms.hpp (original)
+++ branches/release/boost/intrusive/avltree_algorithms.hpp 2011-12-26 12:10:27 EST (Mon, 26 Dec 2011)
@@ -22,6 +22,7 @@
#include <boost/intrusive/detail/assert.hpp>
#include <boost/intrusive/detail/utilities.hpp>
#include <boost/intrusive/detail/tree_algorithms.hpp>
+#include <boost/intrusive/pointer_traits.hpp>

namespace boost {
@@ -88,7 +89,7 @@
 : base_t(f)
 {}

- node_ptr operator()(node_ptr p)
+ node_ptr operator()(const node_ptr &p)
 {
 node_ptr n = base_t::get()(p);
 NodeTraits::set_balance(n, NodeTraits::get_balance(p));
@@ -98,21 +99,19 @@

 struct avltree_erase_fixup
 {
- void operator()(node_ptr to_erase, node_ptr successor)
+ void operator()(const node_ptr &to_erase, const node_ptr &successor)
 { NodeTraits::set_balance(successor, NodeTraits::get_balance(to_erase)); }
 };

- static node_ptr uncast(const_node_ptr ptr)
- {
- return node_ptr(const_cast<node*>(::boost::intrusive::detail::boost_intrusive_get_pointer(ptr)));
- }
+ static node_ptr uncast(const const_node_ptr & ptr)
+ { return pointer_traits<node_ptr>::const_cast_from(ptr); }
 /// @endcond

 public:
- static node_ptr begin_node(const_node_ptr header)
+ static node_ptr begin_node(const const_node_ptr & header)
 { return tree_algorithms::begin_node(header); }

- static node_ptr end_node(const_node_ptr header)
+ static node_ptr end_node(const const_node_ptr & header)
 { return tree_algorithms::end_node(header); }

 //! This type is the information that will be
@@ -128,7 +127,7 @@
 //! Complexity: Constant.
 //!
 //! Throws: Nothing.
- static void swap_tree(node_ptr header1, node_ptr header2)
+ static void swap_tree(const node_ptr & header1, const node_ptr & header2)
 { return tree_algorithms::swap_tree(header1, header2); }

 //! Requires: node1 and node2 can't be header nodes
@@ -146,7 +145,7 @@
 //! node1 and node2 are not equivalent according to the ordering rules.
 //!
 //!Experimental function
- static void swap_nodes(node_ptr node1, node_ptr node2)
+ static void swap_nodes(const node_ptr & node1, const node_ptr & node2)
 {
 if(node1 == node2)
 return;
@@ -170,7 +169,7 @@
 //! node1 and node2 are not equivalent according to the ordering rules.
 //!
 //!Experimental function
- static void swap_nodes(node_ptr node1, node_ptr header1, node_ptr node2, node_ptr header2)
+ static void swap_nodes(const node_ptr & node1, const node_ptr & header1, const node_ptr & node2, const node_ptr & header2)
 {
 if(node1 == node2) return;

@@ -197,7 +196,7 @@
 //! the node, since no rebalancing and comparison is needed.
 //!
 //!Experimental function
- static void replace_node(node_ptr node_to_be_replaced, node_ptr new_node)
+ static void replace_node(const node_ptr & node_to_be_replaced, const node_ptr & new_node)
 {
 if(node_to_be_replaced == new_node)
 return;
@@ -220,7 +219,7 @@
 //! the node, since no rebalancing or comparison is needed.
 //!
 //!Experimental function
- static void replace_node(node_ptr node_to_be_replaced, node_ptr header, node_ptr new_node)
+ static void replace_node(const node_ptr & node_to_be_replaced, const node_ptr & header, const node_ptr & new_node)
 {
 tree_algorithms::replace_node(node_to_be_replaced, header, new_node);
 NodeTraits::set_balance(new_node, NodeTraits::get_balance(node_to_be_replaced));
@@ -233,7 +232,7 @@
 //! Complexity: Average complexity is constant time.
 //!
 //! Throws: Nothing.
- static void unlink(node_ptr node)
+ static void unlink(const node_ptr & node)
 {
 node_ptr x = NodeTraits::get_parent(node);
 if(x){
@@ -256,7 +255,7 @@
 //! only be used for more unlink_leftmost_without_rebalance calls.
 //! This function is normally used to achieve a step by step
 //! controlled destruction of the tree.
- static node_ptr unlink_leftmost_without_rebalance(node_ptr header)
+ static node_ptr unlink_leftmost_without_rebalance(const node_ptr & header)
 { return tree_algorithms::unlink_leftmost_without_rebalance(header); }

 //! Requires: node is a node of the tree or an node initialized
@@ -267,7 +266,7 @@
 //! Complexity: Constant time.
 //!
 //! Throws: Nothing.
- static bool unique(const_node_ptr node)
+ static bool unique(const const_node_ptr & node)
 { return tree_algorithms::unique(node); }

 //! Requires: node is a node of the tree but it's not the header.
@@ -277,7 +276,7 @@
 //! Complexity: Linear time.
 //!
 //! Throws: Nothing.
- static std::size_t count(const_node_ptr node)
+ static std::size_t count(const const_node_ptr & node)
 { return tree_algorithms::count(node); }

 //! Requires: header is the header node of the tree.
@@ -287,7 +286,7 @@
 //! Complexity: Linear time.
 //!
 //! Throws: Nothing.
- static std::size_t size(const_node_ptr header)
+ static std::size_t size(const const_node_ptr & header)
 { return tree_algorithms::size(header); }

 //! Requires: p is a node from the tree except the header.
@@ -297,7 +296,7 @@
 //! Complexity: Average constant time.
 //!
 //! Throws: Nothing.
- static node_ptr next_node(node_ptr p)
+ static node_ptr next_node(const node_ptr & p)
 { return tree_algorithms::next_node(p); }

 //! Requires: p is a node from the tree except the leftmost node.
@@ -307,7 +306,7 @@
 //! Complexity: Average constant time.
 //!
 //! Throws: Nothing.
- static node_ptr prev_node(node_ptr p)
+ static node_ptr prev_node(const node_ptr & p)
 { return tree_algorithms::prev_node(p); }

 //! Requires: node must not be part of any tree.
@@ -319,7 +318,7 @@
 //! Throws: Nothing.
 //!
 //! Nodes: If node is inserted in a tree, this function corrupts the tree.
- static void init(node_ptr node)
+ static void init(const node_ptr & node)
 { tree_algorithms::init(node); }

 //! Requires: node must not be part of any tree.
@@ -332,7 +331,7 @@
 //! Throws: Nothing.
 //!
 //! Nodes: If node is inserted in a tree, this function corrupts the tree.
- static void init_header(node_ptr header)
+ static void init_header(const node_ptr & header)
 {
 tree_algorithms::init_header(header);
 NodeTraits::set_balance(header, NodeTraits::zero());
@@ -346,7 +345,7 @@
 //! Complexity: Amortized constant time.
 //!
 //! Throws: Nothing.
- static node_ptr erase(node_ptr header, node_ptr z)
+ static node_ptr erase(const node_ptr & header, const node_ptr & z)
 {
 typename tree_algorithms::data_for_rebalance info;
 tree_algorithms::erase(header, z, avltree_erase_fixup(), info);
@@ -363,13 +362,13 @@
 //! take a node_ptr and shouldn't throw.
 //!
 //! Effects: First empties target tree calling
- //! <tt>void disposer::operator()(node_ptr)</tt> for every node of the tree
+ //! <tt>void disposer::operator()(const node_ptr &)</tt> for every node of the tree
 //! except the header.
 //!
 //! Then, duplicates the entire tree pointed by "source_header" cloning each
- //! source node with <tt>node_ptr Cloner::operator()(node_ptr)</tt> to obtain
+ //! source node with <tt>node_ptr Cloner::operator()(const node_ptr &)</tt> to obtain
 //! the nodes of the target tree. If "cloner" throws, the cloned target nodes
- //! are disposed using <tt>void disposer(node_ptr)</tt>.
+ //! are disposed using <tt>void disposer(const node_ptr &)</tt>.
 //!
 //! Complexity: Linear to the number of element of the source tree plus the.
 //! number of elements of tree target tree when calling this function.
@@ -377,7 +376,7 @@
 //! Throws: If cloner functor throws. If this happens target nodes are disposed.
 template <class Cloner, class Disposer>
 static void clone
- (const_node_ptr source_header, node_ptr target_header, Cloner cloner, Disposer disposer)
+ (const const_node_ptr & source_header, const node_ptr & target_header, Cloner cloner, Disposer disposer)
 {
 avltree_node_cloner<Cloner> new_cloner(cloner);
 tree_algorithms::clone(source_header, target_header, new_cloner, disposer);
@@ -387,7 +386,7 @@
 //! taking a node_ptr parameter and shouldn't throw.
 //!
 //! Effects: Empties the target tree calling
- //! <tt>void disposer::operator()(node_ptr)</tt> for every node of the tree
+ //! <tt>void disposer::operator()(const node_ptr &)</tt> for every node of the tree
 //! except the header.
 //!
 //! Complexity: Linear to the number of element of the source tree plus the.
@@ -395,7 +394,7 @@
 //!
 //! Throws: If cloner functor throws. If this happens target nodes are disposed.
 template<class Disposer>
- static void clear_and_dispose(node_ptr header, Disposer disposer)
+ static void clear_and_dispose(const node_ptr & header, Disposer disposer)
 { tree_algorithms::clear_and_dispose(header, disposer); }

 //! Requires: "header" must be the header node of a tree.
@@ -412,7 +411,7 @@
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static node_ptr lower_bound
- (const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp)
+ (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp)
 { return tree_algorithms::lower_bound(header, key, comp); }

 //! Requires: "header" must be the header node of a tree.
@@ -428,7 +427,7 @@
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static node_ptr upper_bound
- (const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp)
+ (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp)
 { return tree_algorithms::upper_bound(header, key, comp); }

 //! Requires: "header" must be the header node of a tree.
@@ -444,7 +443,7 @@
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static node_ptr find
- (const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp)
+ (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp)
 { return tree_algorithms::find(header, key, comp); }

 //! Requires: "header" must be the header node of a tree.
@@ -462,7 +461,7 @@
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static std::pair<node_ptr, node_ptr> equal_range
- (const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp)
+ (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp)
 { return tree_algorithms::equal_range(header, key, comp); }

 //! Requires: "h" must be the header node of a tree.
@@ -479,7 +478,7 @@
 //! Throws: If "comp" throws.
 template<class NodePtrCompare>
 static node_ptr insert_equal_upper_bound
- (node_ptr h, node_ptr new_node, NodePtrCompare comp)
+ (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp)
 {
 tree_algorithms::insert_equal_upper_bound(h, new_node, comp);
 rebalance_after_insertion(h, new_node);
@@ -500,7 +499,7 @@
 //! Throws: If "comp" throws.
 template<class NodePtrCompare>
 static node_ptr insert_equal_lower_bound
- (node_ptr h, node_ptr new_node, NodePtrCompare comp)
+ (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp)
 {
 tree_algorithms::insert_equal_lower_bound(h, new_node, comp);
 rebalance_after_insertion(h, new_node);
@@ -523,7 +522,7 @@
 //! Throws: If "comp" throws.
 template<class NodePtrCompare>
 static node_ptr insert_equal
- (node_ptr header, node_ptr hint, node_ptr new_node, NodePtrCompare comp)
+ (const node_ptr & header, const node_ptr & hint, const node_ptr & new_node, NodePtrCompare comp)
 {
 tree_algorithms::insert_equal(header, hint, new_node, comp);
 rebalance_after_insertion(header, new_node);
@@ -545,7 +544,7 @@
 //! Note: If "pos" is not the successor of the newly inserted "new_node"
 //! tree invariants might be broken.
 static node_ptr insert_before
- (node_ptr header, node_ptr pos, node_ptr new_node)
+ (const node_ptr & header, const node_ptr & pos, const node_ptr & new_node)
 {
 tree_algorithms::insert_before(header, pos, new_node);
 rebalance_after_insertion(header, new_node);
@@ -565,7 +564,7 @@
 //! Note: If "new_node" is less than the greatest inserted key
 //! tree invariants are broken. This function is slightly faster than
 //! using "insert_before".
- static void push_back(node_ptr header, node_ptr new_node)
+ static void push_back(const node_ptr & header, const node_ptr & new_node)
 {
 tree_algorithms::push_back(header, new_node);
 rebalance_after_insertion(header, new_node);
@@ -584,7 +583,7 @@
 //! Note: If "new_node" is greater than the lowest inserted key
 //! tree invariants are broken. This function is slightly faster than
 //! using "insert_before".
- static void push_front(node_ptr header, node_ptr new_node)
+ static void push_front(const node_ptr & header, const node_ptr & new_node)
 {
 tree_algorithms::push_front(header, new_node);
 rebalance_after_insertion(header, new_node);
@@ -626,7 +625,7 @@
 //! if no more objects are inserted or erased from the set.
 template<class KeyType, class KeyNodePtrCompare>
 static std::pair<node_ptr, bool> insert_unique_check
- (const_node_ptr header, const KeyType &key
+ (const const_node_ptr & header, const KeyType &key
 ,KeyNodePtrCompare comp, insert_commit_data &commit_data)
 { return tree_algorithms::insert_unique_check(header, key, comp, commit_data); }

@@ -671,7 +670,7 @@
 //! if no more objects are inserted or erased from the set.
 template<class KeyType, class KeyNodePtrCompare>
 static std::pair<node_ptr, bool> insert_unique_check
- (const_node_ptr header, node_ptr hint, const KeyType &key
+ (const const_node_ptr & header, const node_ptr &hint, const KeyType &key
 ,KeyNodePtrCompare comp, insert_commit_data &commit_data)
 { return tree_algorithms::insert_unique_check(header, hint, key, comp, commit_data); }

@@ -693,7 +692,7 @@
 //! previously executed to fill "commit_data". No value should be inserted or
 //! erased between the "insert_check" and "insert_commit" calls.
 static void insert_unique_commit
- (node_ptr header, node_ptr new_value, const insert_commit_data &commit_data)
+ (const node_ptr & header, const node_ptr & new_value, const insert_commit_data &commit_data)
 {
 tree_algorithms::insert_unique_commit(header, new_value, commit_data);
 rebalance_after_insertion(header, new_value);
@@ -706,7 +705,7 @@
 //! Complexity: Logarithmic.
 //!
 //! Throws: Nothing.
- static node_ptr get_header(node_ptr n)
+ static node_ptr get_header(const node_ptr & n)
 { return tree_algorithms::get_header(n); }

 /// @cond
@@ -719,11 +718,12 @@
 //! Complexity: Constant.
 //!
 //! Throws: Nothing.
- static bool is_header(const_node_ptr p)
+ static bool is_header(const const_node_ptr & p)
 { return NodeTraits::get_balance(p) == NodeTraits::zero() && tree_algorithms::is_header(p); }

- static void rebalance_after_erasure(node_ptr header, node_ptr x, node_ptr x_parent)
+ static void rebalance_after_erasure(const node_ptr & header, const node_ptr & xnode, const node_ptr & xnode_parent)
 {
+ node_ptr x(xnode), x_parent(xnode_parent);
 for (node_ptr root = NodeTraits::get_parent(header); x != root; root = NodeTraits::get_parent(header)) {
 const balance x_parent_balance = NodeTraits::get_balance(x_parent);
 if(x_parent_balance == NodeTraits::zero()){
@@ -797,10 +797,10 @@
 }
 }

- static void rebalance_after_insertion(node_ptr header, node_ptr x)
+ static void rebalance_after_insertion(const node_ptr & header, const node_ptr & xnode)
 {
+ node_ptr x(xnode);
 NodeTraits::set_balance(x, NodeTraits::zero());
-
 // Rebalance.
 for(node_ptr root = NodeTraits::get_parent(header); x != root; root = NodeTraits::get_parent(header)){
 const balance x_parent_balance = NodeTraits::get_balance(NodeTraits::get_parent(x));
@@ -843,7 +843,7 @@
 }
 }

- static void left_right_balancing(node_ptr a, node_ptr b, node_ptr c)
+ static void left_right_balancing(const node_ptr & a, const node_ptr & b, const node_ptr & c)
 {
 // balancing...
 const balance c_balance = NodeTraits::get_balance(c);
@@ -866,7 +866,7 @@
 }
 }

- static void rotate_left_right(const node_ptr a, node_ptr hdr)
+ static void rotate_left_right(const node_ptr a, const node_ptr & hdr)
 {
 // | | //
 // a(-2) c //
@@ -883,7 +883,7 @@
 left_right_balancing(a, b, c);
 }

- static void rotate_right_left(const node_ptr a, node_ptr hdr)
+ static void rotate_right_left(const node_ptr a, const node_ptr & hdr)
 {
 // | | //
 // a(pos) c //
@@ -900,7 +900,7 @@
 left_right_balancing(b, a, c);
 }

- static void rotate_left(const node_ptr x, node_ptr hdr)
+ static void rotate_left(const node_ptr x, const node_ptr & hdr)
 {
 const node_ptr y = NodeTraits::get_right(x);
 tree_algorithms::rotate_left(x, hdr);
@@ -916,7 +916,7 @@
 }
 }

- static void rotate_right(const node_ptr x, node_ptr hdr)
+ static void rotate_right(const node_ptr x, const node_ptr & hdr)
 {
 const node_ptr y = NodeTraits::get_left(x);
 tree_algorithms::rotate_right(x, hdr);

Modified: branches/release/boost/intrusive/circular_list_algorithms.hpp
==============================================================================
--- branches/release/boost/intrusive/circular_list_algorithms.hpp (original)
+++ branches/release/boost/intrusive/circular_list_algorithms.hpp 2011-12-26 12:10:27 EST (Mon, 26 Dec 2011)
@@ -61,10 +61,10 @@
 //! Complexity: Constant
 //!
 //! Throws: Nothing.
- static void init(node_ptr this_node)
+ static void init(const node_ptr &this_node)
 {
- NodeTraits::set_next(this_node, node_ptr(0));
- NodeTraits::set_previous(this_node, node_ptr(0));
+ NodeTraits::set_next(this_node, node_ptr());
+ NodeTraits::set_previous(this_node, node_ptr());
 }

 //! Effects: Returns true is "this_node" is in a non-used state
@@ -73,7 +73,7 @@
 //! Complexity: Constant
 //!
 //! Throws: Nothing.
- static bool inited(const_node_ptr this_node)
+ static bool inited(const const_node_ptr &this_node)
 { return !NodeTraits::get_next(this_node); }

 //! Effects: Constructs an empty list, making this_node the only
@@ -84,7 +84,7 @@
 //! Complexity: Constant
 //!
 //! Throws: Nothing.
- static void init_header(node_ptr this_node)
+ static void init_header(const node_ptr &this_node)
 {
 NodeTraits::set_next(this_node, this_node);
 NodeTraits::set_previous(this_node, this_node);
@@ -99,7 +99,7 @@
 //! Complexity: Constant
 //!
 //! Throws: Nothing.
- static bool unique(const_node_ptr this_node)
+ static bool unique(const const_node_ptr &this_node)
 {
 node_ptr next = NodeTraits::get_next(this_node);
 return !next || next == this_node;
@@ -113,7 +113,7 @@
 //! Complexity: Linear
 //!
 //! Throws: Nothing.
- static std::size_t count(const_node_ptr this_node)
+ static std::size_t count(const const_node_ptr &this_node)
 {
 std::size_t result = 0;
 const_node_ptr p = this_node;
@@ -131,10 +131,10 @@
 //! Complexity: Constant
 //!
 //! Throws: Nothing.
- static node_ptr unlink(node_ptr this_node)
+ static node_ptr unlink(const node_ptr &this_node)
 {
- if(NodeTraits::get_next(this_node)){
- node_ptr next(NodeTraits::get_next(this_node));
+ node_ptr next(NodeTraits::get_next(this_node));
+ if(next){
 node_ptr prev(NodeTraits::get_previous(this_node));
 NodeTraits::set_next(prev, next);
 NodeTraits::set_previous(next, prev);
@@ -152,7 +152,7 @@
 //! Complexity: Constant
 //!
 //! Throws: Nothing.
- static void unlink(node_ptr b, node_ptr e)
+ static void unlink(const node_ptr &b, const node_ptr &e)
 {
 if (b != e) {
 node_ptr prevb(NodeTraits::get_previous(b));
@@ -168,13 +168,16 @@
 //! Complexity: Constant
 //!
 //! Throws: Nothing.
- static void link_before(node_ptr nxt_node, node_ptr this_node)
+ static void link_before(const node_ptr &nxt_node, const node_ptr &this_node)
 {
 node_ptr prev(NodeTraits::get_previous(nxt_node));
 NodeTraits::set_previous(this_node, prev);
- NodeTraits::set_next(prev, this_node);
- NodeTraits::set_previous(nxt_node, this_node);
 NodeTraits::set_next(this_node, nxt_node);
+ //nxt_node might be an alias for prev->next_
+ //so use it before update it before NodeTraits::set_next(prev, ...)
+ //is called and the reference changes it's value
+ NodeTraits::set_previous(nxt_node, this_node);
+ NodeTraits::set_next(prev, this_node);
 }

 //! Requires: prev_node must be a node of a circular list.
@@ -184,13 +187,16 @@
 //! Complexity: Constant
 //!
 //! Throws: Nothing.
- static void link_after(node_ptr prev_node, node_ptr this_node)
+ static void link_after(const node_ptr &prev_node, const node_ptr &this_node)
 {
 node_ptr next(NodeTraits::get_next(prev_node));
 NodeTraits::set_previous(this_node, prev_node);
 NodeTraits::set_next(this_node, next);
- NodeTraits::set_previous(next, this_node);
+ //prev_node might be an alias for next->next_
+ //so use it before update it before NodeTraits::set_previous(next, ...)
+ //is called and the reference changes it's value
 NodeTraits::set_next(prev_node, this_node);
+ NodeTraits::set_previous(next, this_node);
 }

 //! Requires: this_node and other_node must be nodes inserted
@@ -204,7 +210,7 @@
 //!
 //! Throws: Nothing.
/*
- static void swap_nodes(node_ptr this_node, node_ptr other_node)
+ static void swap_nodes(const node_ptr &this_node, const node_ptr &other_node)
 {

 if (other_node == this_node)
@@ -243,13 +249,13 @@

 //Watanabe version
 private:
- static void swap_prev(node_ptr this_node, node_ptr other_node)
+ static void swap_prev(const node_ptr &this_node, const node_ptr &other_node)
 {
 node_ptr temp(NodeTraits::get_previous(this_node));
 NodeTraits::set_previous(this_node, NodeTraits::get_previous(other_node));
 NodeTraits::set_previous(other_node, temp);
 }
- static void swap_next(node_ptr this_node, node_ptr other_node)
+ static void swap_next(const node_ptr &this_node, const node_ptr &other_node)
 {
 node_ptr temp(NodeTraits::get_next(this_node));
 NodeTraits::set_next(this_node, NodeTraits::get_next(other_node));
@@ -257,7 +263,7 @@
 }

 public:
- static void swap_nodes(node_ptr this_node, node_ptr other_node)
+ static void swap_nodes(const node_ptr &this_node, const node_ptr &other_node)
 {
 if (other_node == this_node)
 return;
@@ -298,7 +304,7 @@
 //! Complexity: Constant
 //!
 //! Throws: Nothing.
- static void transfer(node_ptr p, node_ptr b, node_ptr e)
+ static void transfer(const node_ptr &p, const node_ptr &b, const node_ptr &e)
 {
 if (b != e) {
 node_ptr prev_p(NodeTraits::get_previous(p));
@@ -323,7 +329,7 @@
 //! Complexity: Constant
 //!
 //! Throws: Nothing.
- static void transfer(node_ptr p, node_ptr i)
+ static void transfer(const node_ptr &p, const node_ptr &i)
 {
 node_ptr n(NodeTraits::get_next(i));
 if(n != p && i != p){
@@ -344,7 +350,7 @@
 //! Throws: Nothing.
 //!
 //! Complexity: This function is linear time.
- static void reverse(node_ptr p)
+ static void reverse(const node_ptr &p)
 {
 node_ptr f(NodeTraits::get_next(p));
 node_ptr i(NodeTraits::get_next(f)), e(p);
@@ -362,7 +368,7 @@
 //! Throws: Nothing.
 //!
 //! Complexity: Linear to the number of moved positions.
- static void move_backwards(node_ptr p, std::size_t n)
+ static void move_backwards(const node_ptr &p, std::size_t n)
 {
 //Null shift, nothing to do
 if(!n) return;
@@ -382,7 +388,7 @@
 //! Throws: Nothing.
 //!
 //! Complexity: Linear to the number of moved positions.
- static void move_forward(node_ptr p, std::size_t n)
+ static void move_forward(const node_ptr &p, std::size_t n)
 {
 //Null shift, nothing to do
 if(!n) return;

Modified: branches/release/boost/intrusive/circular_slist_algorithms.hpp
==============================================================================
--- branches/release/boost/intrusive/circular_slist_algorithms.hpp (original)
+++ branches/release/boost/intrusive/circular_slist_algorithms.hpp 2011-12-26 12:10:27 EST (Mon, 26 Dec 2011)
@@ -63,7 +63,7 @@

 //! Effects: Constructs an non-used list element, putting the next
 //! pointer to null:
- //! <tt>NodeTraits::get_next(this_node) == 0</tt>
+ //! <tt>NodeTraits::get_next(this_node) == node_ptr()</tt>
 //!
 //! Complexity: Constant
 //!
@@ -74,9 +74,9 @@
 //!
 //! Effects: Returns true is "this_node" is the only node of a circular list:
 //! or it's a not inserted node:
- //! <tt>return !NodeTraits::get_next(this_node) || NodeTraits::get_next(this_node) == this_node</tt>
+ //! <tt>return false == NodeTraits::get_next(this_node) || NodeTraits::get_next(this_node) == this_node</tt>
 //!
- //! Complexity: Constant
+ //! Complexity: Constant
 //!
 //! Throws: Nothing.
 static bool unique(const_node_ptr this_node);
@@ -137,7 +137,7 @@
 //! Complexity: Constant
 //!
 //! Throws: Nothing.
- static void init_header(node_ptr this_node)
+ static void init_header(const node_ptr &this_node)
 { NodeTraits::set_next(this_node, this_node); }

 //! Requires: this_node and prev_init_node must be in the same circular list.
@@ -149,7 +149,7 @@
 //! Complexity: Linear to the number of elements between prev_init_node and this_node.
 //!
 //! Throws: Nothing.
- static node_ptr get_previous_node(node_ptr prev_init_node, node_ptr this_node)
+ static node_ptr get_previous_node(const node_ptr &prev_init_node, const node_ptr &this_node)
 { return base_t::get_previous_node(prev_init_node, this_node); }

 //! Requires: this_node must be in a circular list or be an empty circular list.
@@ -159,7 +159,7 @@
 //! Complexity: Linear to the number of elements in the circular list.
 //!
 //! Throws: Nothing.
- static node_ptr get_previous_node(node_ptr this_node)
+ static node_ptr get_previous_node(const node_ptr & this_node)
 { return base_t::get_previous_node(this_node, this_node); }

 //! Requires: this_node must be in a circular list or be an empty circular list.
@@ -169,7 +169,7 @@
 //! Complexity: Linear to the number of elements in the circular list.
 //!
 //! Throws: Nothing.
- static node_ptr get_previous_previous_node(node_ptr this_node)
+ static node_ptr get_previous_previous_node(const node_ptr & this_node)
 { return get_previous_previous_node(this_node, this_node); }

 //! Requires: this_node and prev_prev_init_node must be in the same circular list.
@@ -181,7 +181,7 @@
 //! Complexity: Linear to the number of elements in the circular list.
 //!
 //! Throws: Nothing.
- static node_ptr get_previous_previous_node(node_ptr prev_prev_init_node, node_ptr this_node)
+ static node_ptr get_previous_previous_node(const node_ptr & prev_prev_init_node, const node_ptr & this_node)
 {
 node_ptr p = prev_prev_init_node;
 node_ptr p_next = NodeTraits::get_next(p);
@@ -202,7 +202,7 @@
 //! Complexity: Linear
 //!
 //! Throws: Nothing.
- static std::size_t count(const_node_ptr this_node)
+ static std::size_t count(const const_node_ptr & this_node)
 {
 std::size_t result = 0;
 const_node_ptr p = this_node;
@@ -220,7 +220,7 @@
 //! Complexity: Linear to the number of elements in the circular list
 //!
 //! Throws: Nothing.
- static void unlink(node_ptr this_node)
+ static void unlink(const node_ptr & this_node)
 {
 if(NodeTraits::get_next(this_node))
 base_t::unlink_after(get_previous_node(this_node));
@@ -233,7 +233,7 @@
 //! Complexity: Linear to the number of elements in the circular list.
 //!
 //! Throws: Nothing.
- static void link_before (node_ptr nxt_node, node_ptr this_node)
+ static void link_before (const node_ptr & nxt_node, const node_ptr & this_node)
 { base_t::link_after(get_previous_node(nxt_node), this_node); }

 //! Requires: this_node and other_node must be nodes inserted
@@ -246,7 +246,7 @@
 //! Complexity: Linear to number of elements of both lists
 //!
 //! Throws: Nothing.
- static void swap_nodes(node_ptr this_node, node_ptr other_node)
+ static void swap_nodes(const node_ptr & this_node, const node_ptr & other_node)
 {
 if (other_node == this_node)
 return;
@@ -284,7 +284,7 @@
 //! Throws: Nothing.
 //!
 //! Complexity: This function is linear to the contained elements.
- static void reverse(node_ptr p)
+ static void reverse(const node_ptr & p)
 {
 node_ptr i = NodeTraits::get_next(p), e(p);
 for (;;) {
@@ -303,18 +303,18 @@
 //! Throws: Nothing.
 //!
 //! Complexity: Linear to the number of elements plus the number moved positions.
- static node_ptr move_backwards(node_ptr p, std::size_t n)
+ static node_ptr move_backwards(const node_ptr & p, std::size_t n)
 {
 //Null shift, nothing to do
- if(!n) return node_ptr(0);
+ if(!n) return node_ptr();
 node_ptr first = NodeTraits::get_next(p);

 //count() == 1 or 2, nothing to do
 if(NodeTraits::get_next(first) == p)
- return node_ptr(0);
+ return node_ptr();

 bool end_found = false;
- node_ptr new_last(0);
+ node_ptr new_last = node_ptr();

 //Now find the new last node according to the shift count.
 //If we find p before finding the new last node
@@ -327,7 +327,7 @@
 //Shortcut the shift with the modulo of the size of the list
 n %= i;
 if(!n)
- return node_ptr(0);
+ return node_ptr();
 i = 0;
 //Unlink p and continue the new first node search
 first = NodeTraits::get_next(p);
@@ -355,14 +355,14 @@
 //! Throws: Nothing.
 //!
 //! Complexity: Linear to the number of elements plus the number moved positions.
- static node_ptr move_forward(node_ptr p, std::size_t n)
+ static node_ptr move_forward(const node_ptr & p, std::size_t n)
 {
 //Null shift, nothing to do
- if(!n) return node_ptr(0);
+ if(!n) return node_ptr();
 node_ptr first = node_traits::get_next(p);

 //count() == 1 or 2, nothing to do
- if(node_traits::get_next(first) == p) return node_ptr(0);
+ if(node_traits::get_next(first) == p) return node_ptr();

 //Iterate until p is found to know where the current last node is.
 //If the shift count is less than the size of the list, we can also obtain
@@ -381,7 +381,7 @@
 //Shortcut the shift with the modulo of the size of the list
 std::size_t new_before_last_pos = (distance - (n % distance))% distance;
 //If the shift is a multiple of the size there is nothing to do
- if(!new_before_last_pos) return node_ptr(0);
+ if(!new_before_last_pos) return node_ptr();

 for( new_last = p
 ; new_before_last_pos--

Modified: branches/release/boost/intrusive/derivation_value_traits.hpp
==============================================================================
--- branches/release/boost/intrusive/derivation_value_traits.hpp (original)
+++ branches/release/boost/intrusive/derivation_value_traits.hpp 2011-12-26 12:10:27 EST (Mon, 26 Dec 2011)
@@ -34,8 +34,10 @@
 typedef typename node_traits::const_node_ptr const_node_ptr;
 typedef typename boost::pointer_to_other<node_ptr, T>::type pointer;
 typedef typename boost::pointer_to_other<node_ptr, const T>::type const_pointer;
- typedef typename std::iterator_traits<pointer>::reference reference;
- typedef typename std::iterator_traits<const_pointer>::reference const_reference;
+ typedef typename boost::intrusive::
+ pointer_traits<pointer>::reference reference;
+ typedef typename boost::intrusive::
+ pointer_traits<const_pointer>::reference const_reference;
 static const link_mode_type link_mode = LinkMode;

 static node_ptr to_node_ptr(reference value)
@@ -44,7 +46,7 @@
 static const_node_ptr to_node_ptr(const_reference value)
 { return node_ptr(&value); }

- static pointer to_value_ptr(node_ptr n)
+ static pointer to_value_ptr(const node_ptr &n)
 {
// This still fails in gcc < 4.4 so forget about it
// using ::boost::static_pointer_cast;
@@ -52,7 +54,7 @@
 return pointer(&static_cast<value_type&>(*n));
 }

- static const_pointer to_value_ptr(const_node_ptr n)
+ static const_pointer to_value_ptr(const const_node_ptr &n)
 {
// This still fails in gcc < 4.4 so forget about it
// using ::boost::static_pointer_cast;

Modified: branches/release/boost/intrusive/detail/any_node_and_algorithms.hpp
==============================================================================
--- branches/release/boost/intrusive/detail/any_node_and_algorithms.hpp (original)
+++ branches/release/boost/intrusive/detail/any_node_and_algorithms.hpp 2011-12-26 12:10:27 EST (Mon, 26 Dec 2011)
@@ -16,7 +16,7 @@
#include <boost/intrusive/detail/config_begin.hpp>
#include <iterator>
#include <boost/intrusive/detail/assert.hpp>
-#include <boost/intrusive/detail/pointer_to_other.hpp>
+#include <boost/intrusive/pointer_traits.hpp>
#include <cstddef>
#include <boost/intrusive/detail/mpl.hpp>
#include <boost/pointer_cast.hpp>
@@ -27,8 +27,8 @@
template<class VoidPointer>
struct any_node
{
- typedef typename boost::pointer_to_other
- <VoidPointer, any_node>::type node_ptr;
+ typedef typename pointer_traits
+ <VoidPointer>::template rebind_pointer<any_node>::type node_ptr;
 node_ptr node_ptr_1;
 node_ptr node_ptr_2;
 node_ptr node_ptr_3;
@@ -39,21 +39,21 @@
struct any_list_node_traits
{
 typedef any_node<VoidPointer> node;
- typedef typename boost::pointer_to_other
- <VoidPointer, node>::type node_ptr;
- typedef typename boost::pointer_to_other
- <VoidPointer, const node>::type const_node_ptr;
+ typedef typename pointer_traits
+ <VoidPointer>::template rebind_pointer<node>::type node_ptr;
+ typedef typename pointer_traits
+ <VoidPointer>::template rebind_pointer<const node>::type const_node_ptr;

- static node_ptr get_next(const_node_ptr n)
+ static const node_ptr &get_next(const const_node_ptr & n)
 { return n->node_ptr_1; }

- static void set_next(node_ptr n, node_ptr next)
+ static void set_next(const node_ptr & n, const node_ptr & next)
 { n->node_ptr_1 = next; }

- static node_ptr get_previous(const_node_ptr n)
+ static const node_ptr &get_previous(const const_node_ptr & n)
 { return n->node_ptr_2; }

- static void set_previous(node_ptr n, node_ptr prev)
+ static void set_previous(const node_ptr & n, const node_ptr & prev)
 { n->node_ptr_2 = prev; }
};

@@ -62,15 +62,15 @@
struct any_slist_node_traits
{
 typedef any_node<VoidPointer> node;
- typedef typename boost::pointer_to_other
- <VoidPointer, node>::type node_ptr;
- typedef typename boost::pointer_to_other
- <VoidPointer, const node>::type const_node_ptr;
+ typedef typename pointer_traits
+ <VoidPointer>::template rebind_pointer<node>::type node_ptr;
+ typedef typename pointer_traits
+ <VoidPointer>::template rebind_pointer<const node>::type const_node_ptr;

- static node_ptr get_next(const_node_ptr n)
+ static const node_ptr &get_next(const const_node_ptr & n)
 { return n->node_ptr_1; }

- static void set_next(node_ptr n, node_ptr next)
+ static void set_next(const node_ptr & n, const node_ptr & next)
 { n->node_ptr_1 = next; }
};

@@ -87,25 +87,22 @@
 static const bool store_hash = true;
 static const bool optimize_multikey = true;

- static node_ptr get_next(const_node_ptr n)
- {
- using ::boost::static_pointer_cast;
- return static_pointer_cast<node>(n->node_ptr_1);
- }
+ static const node_ptr &get_next(const const_node_ptr & n)
+ { return n->node_ptr_1; }

- static void set_next(node_ptr n, node_ptr next)
+ static void set_next(const node_ptr & n, const node_ptr & next)
 { n->node_ptr_1 = next; }

- static node_ptr get_prev_in_group(const_node_ptr n)
+ static node_ptr get_prev_in_group(const const_node_ptr & n)
 { return n->node_ptr_2; }

- static void set_prev_in_group(node_ptr n, node_ptr prev)
+ static void set_prev_in_group(const node_ptr & n, const node_ptr & prev)
 { n->node_ptr_2 = prev; }

- static std::size_t get_hash(const_node_ptr n)
+ static std::size_t get_hash(const const_node_ptr & n)
 { return n->size_t_1; }

- static void set_hash(node_ptr n, std::size_t h)
+ static void set_hash(const node_ptr & n, std::size_t h)
 { n->size_t_1 = h; }
};

@@ -115,35 +112,35 @@
{
 typedef any_node<VoidPointer> node;

- typedef typename boost::pointer_to_other
- <VoidPointer, node>::type node_ptr;
- typedef typename boost::pointer_to_other
- <VoidPointer, const node>::type const_node_ptr;
+ typedef typename pointer_traits
+ <VoidPointer>::template rebind_pointer<node>::type node_ptr;
+ typedef typename pointer_traits
+ <VoidPointer>::template rebind_pointer<const node>::type const_node_ptr;

 typedef std::size_t color;

- static node_ptr get_parent(const_node_ptr n)
+ static const node_ptr &get_parent(const const_node_ptr & n)
 { return n->node_ptr_1; }

- static void set_parent(node_ptr n, node_ptr p)
+ static void set_parent(const node_ptr & n, const node_ptr & p)
 { n->node_ptr_1 = p; }

- static node_ptr get_left(const_node_ptr n)
+ static const node_ptr &get_left(const const_node_ptr & n)
 { return n->node_ptr_2; }

- static void set_left(node_ptr n, node_ptr l)
+ static void set_left(const node_ptr & n, const node_ptr & l)
 { n->node_ptr_2 = l; }

- static node_ptr get_right(const_node_ptr n)
+ static const node_ptr &get_right(const const_node_ptr & n)
 { return n->node_ptr_3; }

- static void set_right(node_ptr n, node_ptr r)
+ static void set_right(const node_ptr & n, const node_ptr & r)
 { n->node_ptr_3 = r; }

- static color get_color(const_node_ptr n)
+ static color get_color(const const_node_ptr & n)
 { return n->size_t_1; }

- static void set_color(node_ptr n, color c)
+ static void set_color(const node_ptr & n, color c)
 { n->size_t_1 = c; }

 static color black()
@@ -159,34 +156,34 @@
{
 typedef any_node<VoidPointer> node;

- typedef typename boost::pointer_to_other
- <VoidPointer, node>::type node_ptr;
- typedef typename boost::pointer_to_other
- <VoidPointer, const node>::type const_node_ptr;
+ typedef typename pointer_traits
+ <VoidPointer>::template rebind_pointer<node>::type node_ptr;
+ typedef typename pointer_traits
+ <VoidPointer>::template rebind_pointer<const node>::type const_node_ptr;
 typedef std::size_t balance;

- static node_ptr get_parent(const_node_ptr n)
+ static const node_ptr &get_parent(const const_node_ptr & n)
 { return n->node_ptr_1; }

- static void set_parent(node_ptr n, node_ptr p)
+ static void set_parent(const node_ptr & n, const node_ptr & p)
 { n->node_ptr_1 = p; }

- static node_ptr get_left(const_node_ptr n)
+ static const node_ptr &get_left(const const_node_ptr & n)
 { return n->node_ptr_2; }

- static void set_left(node_ptr n, node_ptr l)
+ static void set_left(const node_ptr & n, const node_ptr & l)
 { n->node_ptr_2 = l; }

- static node_ptr get_right(const_node_ptr n)
+ static const node_ptr &get_right(const const_node_ptr & n)
 { return n->node_ptr_3; }

- static void set_right(node_ptr n, node_ptr r)
+ static void set_right(const node_ptr & n, const node_ptr & r)
 { n->node_ptr_3 = r; }

- static balance get_balance(const_node_ptr n)
+ static balance get_balance(const const_node_ptr & n)
 { return n->size_t_1; }

- static void set_balance(node_ptr n, balance b)
+ static void set_balance(const node_ptr & n, balance b)
 { n->size_t_1 = b; }

 static balance negative()
@@ -205,27 +202,27 @@
{
 typedef any_node<VoidPointer> node;

- typedef typename boost::pointer_to_other
- <VoidPointer, node>::type node_ptr;
- typedef typename boost::pointer_to_other
- <VoidPointer, const node>::type const_node_ptr;
+ typedef typename pointer_traits
+ <VoidPointer>::template rebind_pointer<node>::type node_ptr;
+ typedef typename pointer_traits
+ <VoidPointer>::template rebind_pointer<const node>::type const_node_ptr;

- static node_ptr get_parent(const_node_ptr n)
+ static const node_ptr &get_parent(const const_node_ptr & n)
 { return n->node_ptr_1; }

- static void set_parent(node_ptr n, node_ptr p)
+ static void set_parent(const node_ptr & n, const node_ptr & p)
 { n->node_ptr_1 = p; }

- static node_ptr get_left(const_node_ptr n)
+ static const node_ptr &get_left(const const_node_ptr & n)
 { return n->node_ptr_2; }

- static void set_left(node_ptr n, node_ptr l)
+ static void set_left(const node_ptr & n, const node_ptr & l)
 { n->node_ptr_2 = l; }

- static node_ptr get_right(const_node_ptr n)
+ static const node_ptr &get_right(const const_node_ptr & n)
 { return n->node_ptr_3; }

- static void set_right(node_ptr n, node_ptr r)
+ static void set_right(const node_ptr & n, const node_ptr & r)
 { n->node_ptr_3 = r; }
};

@@ -234,10 +231,10 @@
{
 public:
 typedef any_node<VoidPointer> node;
- typedef typename boost::pointer_to_other
- <VoidPointer, node>::type node_ptr;
- typedef typename boost::pointer_to_other
- <VoidPointer, const node>::type const_node_ptr;
+ typedef typename pointer_traits
+ <VoidPointer>::template rebind_pointer<node>::type node_ptr;
+ typedef typename pointer_traits
+ <VoidPointer>::template rebind_pointer<const node>::type const_node_ptr;
};

template<class VoidPointer>
@@ -249,10 +246,10 @@

 public:
 typedef any_node<VoidPointer> node;
- typedef typename boost::pointer_to_other
- <VoidPointer, node>::type node_ptr;
- typedef typename boost::pointer_to_other
- <VoidPointer, const node>::type const_node_ptr;
+ typedef typename pointer_traits
+ <VoidPointer>::template rebind_pointer<node>::type node_ptr;
+ typedef typename pointer_traits
+ <VoidPointer>::template rebind_pointer<const node>::type const_node_ptr;
 typedef any_node_traits<VoidPointer> node_traits;

 //! Requires: node must not be part of any tree.
@@ -264,7 +261,7 @@
 //! Throws: Nothing.
 //!
 //! Nodes: If node is inserted in a tree, this function corrupts the tree.
- static void init(node_ptr node)
+ static void init(const node_ptr & node)
 { node->node_ptr_1 = 0; };

 //! Effects: Returns true if node is in the same state as if called init(node)
@@ -272,19 +269,19 @@
 //! Complexity: Constant.
 //!
 //! Throws: Nothing.
- static bool inited(const_node_ptr node)
+ static bool inited(const const_node_ptr & node)
 { return !node->node_ptr_1; };

- static bool unique(const_node_ptr node)
+ static bool unique(const const_node_ptr & node)
 { return 0 == node->node_ptr_1; }

- static void unlink(node_ptr)
+ static void unlink(const node_ptr &)
 {
 //Auto-unlink hooks and unlink() are not available for any hooks
 any_algorithms<VoidPointer>::template function_not_available_for_any_hooks<node_ptr>();
 }

- static void swap_nodes(node_ptr l, node_ptr r)
+ static void swap_nodes(const node_ptr & l, const node_ptr & r)
 {
 //Any nodes have no swap_nodes capability because they don't know
 //what algorithm they must use to unlink the node from the container

Modified: branches/release/boost/intrusive/detail/avltree_node.hpp
==============================================================================
--- branches/release/boost/intrusive/detail/avltree_node.hpp (original)
+++ branches/release/boost/intrusive/detail/avltree_node.hpp 2011-12-26 12:10:27 EST (Mon, 26 Dec 2011)
@@ -15,7 +15,7 @@

#include <boost/intrusive/detail/config_begin.hpp>
#include <iterator>
-#include <boost/intrusive/detail/pointer_to_other.hpp>
+#include <boost/intrusive/pointer_traits.hpp>
#include <boost/intrusive/avltree_algorithms.hpp>
#include <boost/intrusive/pointer_plus_bits.hpp>
#include <boost/intrusive/detail/mpl.hpp>
@@ -33,9 +33,9 @@
template<class VoidPointer>
struct compact_avltree_node
{
- typedef typename pointer_to_other
- <VoidPointer
- ,compact_avltree_node<VoidPointer> >::type node_ptr;
+ typedef typename pointer_traits
+ <VoidPointer>::template rebind_pointer
+ <compact_avltree_node<VoidPointer> >::type node_ptr;
 enum balance { negative_t, zero_t, positive_t };
 node_ptr parent_, left_, right_;
};
@@ -44,9 +44,9 @@
template<class VoidPointer>
struct avltree_node
{
- typedef typename pointer_to_other
- <VoidPointer
- ,avltree_node<VoidPointer> >::type node_ptr;
+ typedef typename pointer_traits
+ <VoidPointer>::template rebind_pointer
+ <avltree_node<VoidPointer> >::type node_ptr;
 enum balance { negative_t, zero_t, positive_t };
 node_ptr parent_, left_, right_;
 balance balance_;
@@ -59,34 +59,37 @@
{
 typedef avltree_node<VoidPointer> node;

- typedef typename boost::pointer_to_other
- <VoidPointer, node>::type node_ptr;
- typedef typename boost::pointer_to_other
- <VoidPointer, const node>::type const_node_ptr;
+ typedef typename pointer_traits
+ <VoidPointer>::template rebind_pointer
+ <node>::type node_ptr;
+ typedef typename pointer_traits
+ <VoidPointer>::template rebind_pointer
+ <const node>::type const_node_ptr;
+
 typedef typename node::balance balance;

- static node_ptr get_parent(const_node_ptr n)
+ static const node_ptr & get_parent(const const_node_ptr & n)
 { return n->parent_; }

- static void set_parent(node_ptr n, node_ptr p)
+ static void set_parent(const node_ptr & n, const node_ptr & p)
 { n->parent_ = p; }

- static node_ptr get_left(const_node_ptr n)
+ static const node_ptr & get_left(const const_node_ptr & n)
 { return n->left_; }

- static void set_left(node_ptr n, node_ptr l)
+ static void set_left(const node_ptr & n, const node_ptr & l)
 { n->left_ = l; }

- static node_ptr get_right(const_node_ptr n)
+ static const node_ptr & get_right(const const_node_ptr & n)
 { return n->right_; }

- static void set_right(node_ptr n, node_ptr r)
+ static void set_right(const node_ptr & n, const node_ptr & r)
 { n->right_ = r; }

- static balance get_balance(const_node_ptr n)
+ static balance get_balance(const const_node_ptr & n)
 { return n->balance_; }

- static void set_balance(node_ptr n, balance b)
+ static void set_balance(const node_ptr & n, balance b)
 { n->balance_ = b; }

 static balance negative()
@@ -105,36 +108,39 @@
struct compact_avltree_node_traits_impl
{
 typedef compact_avltree_node<VoidPointer> node;
- typedef typename boost::pointer_to_other
- <VoidPointer, node>::type node_ptr;
- typedef typename boost::pointer_to_other
- <VoidPointer, const node>::type const_node_ptr;
+
+ typedef typename pointer_traits
+ <VoidPointer>::template rebind_pointer
+ <node>::type node_ptr;
+ typedef typename pointer_traits
+ <VoidPointer>::template rebind_pointer
+ <const node>::type const_node_ptr;
 typedef typename node::balance balance;

 typedef pointer_plus_bits<node_ptr, 2> ptr_bit;

- static node_ptr get_parent(const_node_ptr n)
+ static node_ptr get_parent(const const_node_ptr & n)
 { return ptr_bit::get_pointer(n->parent_); }

- static void set_parent(node_ptr n, node_ptr p)
+ static void set_parent(const node_ptr & n, const node_ptr & p)
 { ptr_bit::set_pointer(n->parent_, p); }

- static node_ptr get_left(const_node_ptr n)
+ static const node_ptr & get_left(const const_node_ptr & n)
 { return n->left_; }

- static void set_left(node_ptr n, node_ptr l)
+ static void set_left(const node_ptr & n, const node_ptr & l)
 { n->left_ = l; }

- static node_ptr get_right(const_node_ptr n)
+ static const node_ptr & get_right(const const_node_ptr & n)
 { return n->right_; }

- static void set_right(node_ptr n, node_ptr r)
+ static void set_right(const node_ptr & n, const node_ptr & r)
 { n->right_ = r; }

- static balance get_balance(const_node_ptr n)
+ static balance get_balance(const const_node_ptr & n)
 { return (balance)ptr_bit::get_bits(n->parent_); }

- static void set_balance(node_ptr n, balance b)
+ static void set_balance(const node_ptr & n, balance b)
 { ptr_bit::set_bits(n->parent_, (std::size_t)b); }

 static balance negative()

Modified: branches/release/boost/intrusive/detail/common_slist_algorithms.hpp
==============================================================================
--- branches/release/boost/intrusive/detail/common_slist_algorithms.hpp (original)
+++ branches/release/boost/intrusive/detail/common_slist_algorithms.hpp 2011-12-26 12:10:27 EST (Mon, 26 Dec 2011)
@@ -31,7 +31,7 @@
    typedef typename NodeTraits::const_node_ptr const_node_ptr;
    typedef NodeTraits node_traits;

- static node_ptr get_previous_node(node_ptr prev_init_node, node_ptr this_node)
+ static node_ptr get_previous_node(const node_ptr & prev_init_node, const node_ptr & this_node)
    {
       node_ptr p = prev_init_node;
       for( node_ptr p_next
@@ -44,44 +44,44 @@
       return p;
    }

- static void init_header(node_ptr this_node)
+ static void init_header(const node_ptr & this_node)
    { NodeTraits::set_next(this_node, this_node); }

- static void init(node_ptr this_node)
- { NodeTraits::set_next(this_node, node_ptr(0)); }
+ static void init(const node_ptr & this_node)
+ { NodeTraits::set_next(this_node, node_ptr()); }

- static bool unique(const_node_ptr this_node)
+ static bool unique(const const_node_ptr & this_node)
    {
       node_ptr next = NodeTraits::get_next(this_node);
       return !next || next == this_node;
    }

- static bool inited(const_node_ptr this_node)
+ static bool inited(const const_node_ptr & this_node)
    { return !NodeTraits::get_next(this_node); }

- static void unlink_after(node_ptr prev_node)
+ static void unlink_after(const node_ptr & prev_node)
    {
- node_ptr this_node(NodeTraits::get_next(prev_node));
+ const_node_ptr this_node(NodeTraits::get_next(prev_node));
       NodeTraits::set_next(prev_node, NodeTraits::get_next(this_node));
    }

- static void unlink_after(node_ptr prev_node, node_ptr last_node)
+ static void unlink_after(const node_ptr & prev_node, const node_ptr & last_node)
    { NodeTraits::set_next(prev_node, last_node); }

- static void link_after(node_ptr prev_node, node_ptr this_node)
+ static void link_after(const node_ptr & prev_node, const node_ptr & this_node)
    {
       NodeTraits::set_next(this_node, NodeTraits::get_next(prev_node));
       NodeTraits::set_next(prev_node, this_node);
    }

- static void incorporate_after(node_ptr bp, node_ptr b, node_ptr be)
+ static void incorporate_after(const node_ptr & bp, const node_ptr & b, const node_ptr & be)
    {
       node_ptr p(NodeTraits::get_next(bp));
       NodeTraits::set_next(bp, b);
       NodeTraits::set_next(be, p);
    }

- static void transfer_after(node_ptr bp, node_ptr bb, node_ptr be)
+ static void transfer_after(const node_ptr & bp, const node_ptr & bb, const node_ptr & be)
    {
       if (bp != bb && bp != be && bb != be) {
          node_ptr next_b = NodeTraits::get_next(bb);

Modified: branches/release/boost/intrusive/detail/function_detector.hpp
==============================================================================
--- branches/release/boost/intrusive/detail/function_detector.hpp (original)
+++ branches/release/boost/intrusive/detail/function_detector.hpp 2011-12-26 12:10:27 EST (Mon, 26 Dec 2011)
@@ -11,6 +11,7 @@
/////////////////////////////////////////////////////////////////////////////
// This code was modified from the code posted by Alexandre Courpron in his
// article "Interface Detection" in The Code Project:
+// http://www.codeproject.com/KB/architecture/Detector.aspx
///////////////////////////////////////////////////////////////////////////////
// Copyright 2007 Alexandre Courpron
//

Modified: branches/release/boost/intrusive/detail/generic_hook.hpp
==============================================================================
--- branches/release/boost/intrusive/detail/generic_hook.hpp (original)
+++ branches/release/boost/intrusive/detail/generic_hook.hpp 2011-12-26 12:10:27 EST (Mon, 26 Dec 2011)
@@ -15,10 +15,11 @@

#include <boost/intrusive/detail/config_begin.hpp>
#include <boost/intrusive/intrusive_fwd.hpp>
-#include <boost/intrusive/detail/pointer_to_other.hpp>
+#include <boost/intrusive/pointer_traits.hpp>
#include <boost/intrusive/link_mode.hpp>
#include <boost/intrusive/detail/utilities.hpp>
#include <boost/intrusive/detail/mpl.hpp>
+#include <boost/intrusive/pointer_traits.hpp>
#include <boost/static_assert.hpp>

namespace boost {
@@ -146,20 +147,26 @@
 (int)link_mode == (int)auto_unlink || (int)link_mode == (int)safe_link;
 };

+ node_ptr this_ptr()
+ { return pointer_traits<node_ptr>::pointer_to(static_cast<node&>(*this)); }
+
+ const_node_ptr this_ptr() const
+ { return pointer_traits<const_node_ptr>::pointer_to(static_cast<const node&>(*this)); }
+
 public:
 /// @endcond

 generic_hook()
 {
 if(boost_intrusive_tags::safemode_or_autounlink){
- node_algorithms::init(static_cast<node*>(this));
+ node_algorithms::init(this->this_ptr());
 }
 }

 generic_hook(const generic_hook& )
 {
 if(boost_intrusive_tags::safemode_or_autounlink){
- node_algorithms::init(static_cast<node*>(this));
+ node_algorithms::init(this->this_ptr());
 }
 }

@@ -175,22 +182,21 @@
 void swap_nodes(generic_hook &other)
 {
 node_algorithms::swap_nodes
- ( static_cast<node*>(this), static_cast<node*>(&other));
+ (this->this_ptr(), other.this_ptr());
 }

 bool is_linked() const
 {
 //is_linked() can be only used in safe-mode or auto-unlink
 BOOST_STATIC_ASSERT(( boost_intrusive_tags::safemode_or_autounlink ));
- return !node_algorithms::unique
- (static_cast<const node*>(this));
+ return !node_algorithms::unique(this->this_ptr());
 }

 void unlink()
 {
 BOOST_STATIC_ASSERT(( (int)boost_intrusive_tags::link_mode == (int)auto_unlink ));
- node_algorithms::unlink(static_cast<node*>(this));
- node_algorithms::init(static_cast<node*>(this));
+ node_algorithms::unlink(this->this_ptr());
+ node_algorithms::init(this->this_ptr());
 }
};

Modified: branches/release/boost/intrusive/detail/hashtable_node.hpp
==============================================================================
--- branches/release/boost/intrusive/detail/hashtable_node.hpp (original)
+++ branches/release/boost/intrusive/detail/hashtable_node.hpp 2011-12-26 12:10:27 EST (Mon, 26 Dec 2011)
@@ -16,11 +16,12 @@
#include <boost/intrusive/detail/config_begin.hpp>
#include <iterator>
#include <boost/intrusive/detail/assert.hpp>
-#include <boost/intrusive/detail/pointer_to_other.hpp>
+#include <boost/intrusive/pointer_traits.hpp>
#include <boost/intrusive/circular_list_algorithms.hpp>
#include <boost/intrusive/detail/mpl.hpp>
#include <boost/intrusive/detail/utilities.hpp>
-#include <boost/intrusive/detail/slist_node.hpp> //remove-me
+//#include <boost/intrusive/detail/slist_node.hpp> //remove-me
+#include <boost/intrusive/pointer_traits.hpp>
#include <cstddef>
#include <boost/pointer_cast.hpp>
#include <boost/move/move.hpp>
@@ -84,8 +85,10 @@

 public:
 /// @cond
- typedef typename boost::pointer_to_other
- < typename Slist::pointer, bucket_impl<Slist> >::type bucket_ptr;
+
+ typedef typename pointer_traits
+ <typename Slist::pointer>::template rebind_pointer
+ < bucket_impl<Slist> >::type bucket_ptr;
 typedef typename Slist::size_type size_type;
 /// @endcond

@@ -93,14 +96,19 @@
 : buckets_(buckets), buckets_len_(len)
 {}

+ bucket_traits_impl(const bucket_traits_impl &x)
+ : buckets_(x.buckets_), buckets_len_(x.buckets_len_)
+ {}
+
+
 bucket_traits_impl(BOOST_RV_REF(bucket_traits_impl) x)
 : buckets_(x.buckets_), buckets_len_(x.buckets_len_)
- { x.buckets_ = bucket_ptr(0); x.buckets_len_ = 0; }
+ { x.buckets_ = bucket_ptr(); x.buckets_len_ = 0; }

 bucket_traits_impl& operator=(BOOST_RV_REF(bucket_traits_impl) x)
 {
 buckets_ = x.buckets_; buckets_len_ = x.buckets_len_;
- x.buckets_ = bucket_ptr(0); x.buckets_len_ = 0; return *this;
+ x.buckets_ = bucket_ptr(); x.buckets_len_ = 0; return *this;
 }

 bucket_traits_impl& operator=(BOOST_COPY_ASSIGN_REF(bucket_traits_impl) x)
@@ -108,7 +116,7 @@
 buckets_ = x.buckets_; buckets_len_ = x.buckets_len_; return *this;
 }

- bucket_ptr bucket_begin() const
+ const bucket_ptr &bucket_begin() const
 { return buckets_; }

 size_type bucket_count() const
@@ -124,7 +132,7 @@
 : public std::iterator
 < std::forward_iterator_tag
 , typename Container::value_type
- , typename std::iterator_traits<typename Container::value_type*>::difference_type
+ , typename pointer_traits<typename Container::value_type*>::difference_type
 , typename detail::add_const_if_c
 <typename Container::value_type, IsConst>::type *
 , typename detail::add_const_if_c
@@ -135,16 +143,16 @@
 typedef typename Container::siterator siterator;
 typedef typename Container::const_siterator const_siterator;
 typedef typename Container::bucket_type bucket_type;
- typedef typename boost::pointer_to_other
- < typename Container::pointer, const Container>::type const_cont_ptr;
+
+ typedef typename pointer_traits
+ <typename Container::pointer>::template rebind_pointer
+ < const Container >::type const_cont_ptr;
 typedef typename Container::size_type size_type;

 static typename Container::node_ptr downcast_bucket(typename bucket_type::node_ptr p)
 {
-// This still fails in gcc < 4.4 so forget about it
-// using ::boost::static_pointer_cast;
-// return static_pointer_cast<typename Container::node>(p);
- return typename Container::node_ptr(&static_cast<typename Container::node&>(*p));
+ return pointer_traits<typename Container::node_ptr>::
+ pointer_to(static_cast<typename Container::node&>(*p));
 }

 public:
@@ -158,7 +166,7 @@
 {}

 explicit hashtable_iterator(siterator ptr, const Container *cont)
- : slist_it_ (ptr), cont_ (cont)
+ : slist_it_ (ptr), cont_ (cont ? pointer_traits<const_cont_ptr>::pointer_to(*cont) : const_cont_ptr() )
 {}

 hashtable_iterator(const hashtable_iterator<Container, false> &other)
@@ -192,10 +200,13 @@
 { return *this->operator ->(); }

 pointer operator->() const
- { return detail::boost_intrusive_get_pointer(this->get_real_value_traits()->to_value_ptr(downcast_bucket(slist_it_.pointed_node()))); }
+ {
+ return boost::intrusive::detail::to_raw_pointer(this->get_real_value_traits()->to_value_ptr
+ (downcast_bucket(slist_it_.pointed_node())));
+ }

- const Container *get_container() const
- { return detail::boost_intrusive_get_pointer(cont_); }
+ const const_cont_ptr &get_container() const
+ { return cont_; }

 const real_value_traits *get_real_value_traits() const
 { return &this->get_container()->get_real_value_traits(); }
@@ -203,8 +214,8 @@
 private:
 void increment()
 {
- const Container *cont = detail::boost_intrusive_get_pointer(cont_);
- bucket_type* buckets = detail::boost_intrusive_get_pointer(cont->bucket_pointer());
+ const Container *cont = boost::intrusive::detail::to_raw_pointer(cont_);
+ bucket_type* buckets = boost::intrusive::detail::to_raw_pointer(cont->bucket_pointer());
 size_type buckets_len = cont->bucket_count();

 ++slist_it_;

Modified: branches/release/boost/intrusive/detail/list_node.hpp
==============================================================================
--- branches/release/boost/intrusive/detail/list_node.hpp (original)
+++ branches/release/boost/intrusive/detail/list_node.hpp 2011-12-26 12:10:27 EST (Mon, 26 Dec 2011)
@@ -17,7 +17,7 @@
#include <boost/intrusive/detail/config_begin.hpp>
#include <iterator>
#include <boost/intrusive/detail/assert.hpp>
-#include <boost/intrusive/detail/pointer_to_other.hpp>
+#include <boost/intrusive/pointer_traits.hpp>

namespace boost {
namespace intrusive {
@@ -29,8 +29,8 @@
template<class VoidPointer>
struct list_node
{
- typedef typename boost::pointer_to_other
- <VoidPointer, list_node>::type node_ptr;
+ typedef typename pointer_traits
+ <VoidPointer>:: template rebind_pointer<list_node>::type node_ptr;
 node_ptr next_;
 node_ptr prev_;
};
@@ -39,21 +39,21 @@
struct list_node_traits
{
 typedef list_node<VoidPointer> node;
- typedef typename boost::pointer_to_other
- <VoidPointer, node>::type node_ptr;
- typedef typename boost::pointer_to_other
- <VoidPointer, const node>::type const_node_ptr;
+ typedef typename pointer_traits
+ <VoidPointer>:: template rebind_pointer<node>::type node_ptr;
+ typedef typename pointer_traits
+ <VoidPointer>:: template rebind_pointer<const node>::type const_node_ptr;

- static node_ptr get_previous(const_node_ptr n)
+ static const node_ptr &get_previous(const const_node_ptr & n)
 { return n->prev_; }

- static void set_previous(node_ptr n, node_ptr prev)
+ static void set_previous(const node_ptr & n, const node_ptr & prev)
 { n->prev_ = prev; }

- static node_ptr get_next(const_node_ptr n)
+ static const node_ptr &get_next(const const_node_ptr & n)
 { return n->next_; }

- static void set_next(node_ptr n, node_ptr next)
+ static void set_next(const node_ptr & n, const node_ptr & next)
 { n->next_ = next; }
};

@@ -74,8 +74,8 @@
 typedef typename real_value_traits::node_traits node_traits;
 typedef typename node_traits::node node;
 typedef typename node_traits::node_ptr node_ptr;
- typedef typename boost::pointer_to_other
- <node_ptr, void>::type void_pointer;
+ typedef typename pointer_traits<node_ptr>::
+ template rebind_pointer<void>::type void_pointer;
 static const bool store_container_ptr =
 detail::store_cont_ptr_on_it<Container>::value;

@@ -85,10 +85,10 @@
 typedef typename detail::if_c<IsConst,typename Container::const_reference,typename Container::reference>::type reference;

 list_iterator()
- : members_ (node_ptr(0), 0)
+ : members_ (node_ptr(), 0)
 {}

- explicit list_iterator(node_ptr node, const Container *cont_ptr)
+ explicit list_iterator(const node_ptr & node, const Container *cont_ptr)
 : members_ (node, cont_ptr)
 {}

@@ -104,8 +104,10 @@

 public:
 list_iterator& operator++()
- {
- members_.nodeptr_ = node_traits::get_next(members_.nodeptr_);
+ {
+ node_ptr p = node_traits::get_next(members_.nodeptr_);
+ members_.nodeptr_ = p;
+ //members_.nodeptr_ = node_traits::get_next(members_.nodeptr_);
 return static_cast<list_iterator&> (*this);
 }

@@ -139,7 +141,7 @@
 { return *operator->(); }

 pointer operator->() const
- { return detail::boost_intrusive_get_pointer(this->get_real_value_traits()->to_value_ptr(members_.nodeptr_)); }
+ { return this->get_real_value_traits()->to_value_ptr(members_.nodeptr_); }

 const Container *get_container() const
 {

Deleted: branches/release/boost/intrusive/detail/pointer_to_other.hpp
==============================================================================
--- branches/release/boost/intrusive/detail/pointer_to_other.hpp 2011-12-26 12:10:27 EST (Mon, 26 Dec 2011)
+++ (empty file)
@@ -1,65 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-//
-// (C) Copyright Ion Gaztanaga 2006. Distributed under the Boost
-// Software License, Version 1.0. (See accompanying file
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-// See http://www.boost.org/libs/intrusive for documentation.
-//
-/////////////////////////////////////////////////////////////////////////////
-
-#ifndef BOOST_INTRUSIVE_POINTER_TO_OTHER_HPP
-#define BOOST_INTRUSIVE_POINTER_TO_OTHER_HPP
-
-#include <boost/intrusive/detail/config_begin.hpp>
-#include <boost/version.hpp>
-
-#if (BOOST_VERSION < 103400)
-
-#ifndef BOOST_POINTER_TO_OTHER_HPP_INCLUDED
-#define BOOST_POINTER_TO_OTHER_HPP_INCLUDED
-
-namespace boost {
-
-template<class T, class U>
- struct pointer_to_other;
-
-template<class T, class U, template <class> class Sp>
- struct pointer_to_other< Sp<T>, U >
-{
- typedef Sp type;
-};
-
-template<class T, class T2, class U,
- template <class, class> class Sp>
- struct pointer_to_other< Sp<T, T2>, U >
-{
- typedef Sp<U, T2> type;
-};
-
-template<class T, class T2, class T3, class U,
- template <class, class, class> class Sp>
-struct pointer_to_other< Sp<T, T2, T3>, U >
-{
- typedef Sp<U, T2, T3> type;
-};
-
-template<class T, class U>
-struct pointer_to_other< T*, U >
-{
- typedef U* type;
-};
-
-} // namespace boost
-
-#endif
-
-#else
-
-#include <boost/pointer_to_other.hpp>
-
-#endif //#ifndef BOOST_POINTER_TO_OTHER_HPP_INCLUDED
-
-#include <boost/intrusive/detail/config_end.hpp>
-
-#endif //#ifndef BOOST_INTRUSIVE_POINTER_TO_OTHER_HPP

Modified: branches/release/boost/intrusive/detail/rbtree_node.hpp
==============================================================================
--- branches/release/boost/intrusive/detail/rbtree_node.hpp (original)
+++ branches/release/boost/intrusive/detail/rbtree_node.hpp 2011-12-26 12:10:27 EST (Mon, 26 Dec 2011)
@@ -16,7 +16,7 @@

#include <boost/intrusive/detail/config_begin.hpp>
#include <iterator>
-#include <boost/intrusive/detail/pointer_to_other.hpp>
+#include <boost/intrusive/pointer_traits.hpp>
#include <boost/intrusive/rbtree_algorithms.hpp>
#include <boost/intrusive/pointer_plus_bits.hpp>
#include <boost/intrusive/detail/mpl.hpp>
@@ -34,9 +34,9 @@
template<class VoidPointer>
struct compact_rbtree_node
{
- typedef typename pointer_to_other
- <VoidPointer
- ,compact_rbtree_node<VoidPointer> >::type node_ptr;
+ typedef typename pointer_traits
+ <VoidPointer>::template rebind_pointer
+ <compact_rbtree_node<VoidPointer> >::type node_ptr;
 enum color { red_t, black_t };
 node_ptr parent_, left_, right_;
};
@@ -45,9 +45,9 @@
template<class VoidPointer>
struct rbtree_node
{
- typedef typename pointer_to_other
- <VoidPointer
- ,rbtree_node<VoidPointer> >::type node_ptr;
+ typedef typename pointer_traits
+ <VoidPointer>::template rebind_pointer
+ <rbtree_node<VoidPointer> >::type node_ptr;

 enum color { red_t, black_t };
 node_ptr parent_, left_, right_;
@@ -61,35 +61,35 @@
{
 typedef rbtree_node<VoidPointer> node;

- typedef typename boost::pointer_to_other
- <VoidPointer, node>::type node_ptr;
- typedef typename boost::pointer_to_other
- <VoidPointer, const node>::type const_node_ptr;
+ typedef typename pointer_traits
+ <VoidPointer>::template rebind_pointer<node>::type node_ptr;
+ typedef typename pointer_traits
+ <VoidPointer>::template rebind_pointer<const node>::type const_node_ptr;

 typedef typename node::color color;

- static node_ptr get_parent(const_node_ptr n)
+ static const node_ptr & get_parent(const const_node_ptr & n)
 { return n->parent_; }

- static void set_parent(node_ptr n, node_ptr p)
+ static void set_parent(const node_ptr & n, const node_ptr & p)
 { n->parent_ = p; }

- static node_ptr get_left(const_node_ptr n)
+ static const node_ptr & get_left(const const_node_ptr & n)
 { return n->left_; }

- static void set_left(node_ptr n, node_ptr l)
+ static void set_left(const node_ptr & n, const node_ptr & l)
 { n->left_ = l; }

- static node_ptr get_right(const_node_ptr n)
+ static const node_ptr & get_right(const const_node_ptr & n)
 { return n->right_; }

- static void set_right(node_ptr n, node_ptr r)
+ static void set_right(const node_ptr & n, const node_ptr & r)
 { n->right_ = r; }

- static color get_color(const_node_ptr n)
+ static color get_color(const const_node_ptr & n)
 { return n->color_; }

- static void set_color(node_ptr n, color c)
+ static void set_color(const node_ptr & n, color c)
 { n->color_ = c; }

 static color black()
@@ -105,37 +105,37 @@
struct compact_rbtree_node_traits_impl
{
 typedef compact_rbtree_node<VoidPointer> node;
- typedef typename boost::pointer_to_other
- <VoidPointer, node>::type node_ptr;
- typedef typename boost::pointer_to_other
- <VoidPointer, const node>::type const_node_ptr;
+ typedef typename pointer_traits
+ <VoidPointer>::template rebind_pointer<node>::type node_ptr;
+ typedef typename pointer_traits
+ <VoidPointer>::template rebind_pointer<const node>::type const_node_ptr;

 typedef pointer_plus_bits<node_ptr, 1> ptr_bit;

 typedef typename node::color color;

- static node_ptr get_parent(const_node_ptr n)
+ static node_ptr get_parent(const const_node_ptr & n)
 { return ptr_bit::get_pointer(n->parent_); }

- static void set_parent(node_ptr n, node_ptr p)
+ static void set_parent(const node_ptr & n, const node_ptr & p)
 { ptr_bit::set_pointer(n->parent_, p); }

- static node_ptr get_left(const_node_ptr n)
+ static const node_ptr & get_left(const const_node_ptr & n)
 { return n->left_; }

- static void set_left(node_ptr n, node_ptr l)
+ static void set_left(const node_ptr & n, const node_ptr & l)
 { n->left_ = l; }

- static node_ptr get_right(const_node_ptr n)
+ static const node_ptr & get_right(const const_node_ptr & n)
 { return n->right_; }

- static void set_right(node_ptr n, node_ptr r)
+ static void set_right(const node_ptr & n, const node_ptr & r)
 { n->right_ = r; }

- static color get_color(const_node_ptr n)
+ static color get_color(const const_node_ptr & n)
 { return (color)ptr_bit::get_bits(n->parent_); }

- static void set_color(node_ptr n, color c)
+ static void set_color(const node_ptr & n, color c)
 { ptr_bit::set_bits(n->parent_, c != 0); }

 static color black()

Modified: branches/release/boost/intrusive/detail/slist_node.hpp
==============================================================================
--- branches/release/boost/intrusive/detail/slist_node.hpp (original)
+++ branches/release/boost/intrusive/detail/slist_node.hpp 2011-12-26 12:10:27 EST (Mon, 26 Dec 2011)
@@ -17,7 +17,7 @@
#include <boost/intrusive/detail/config_begin.hpp>
#include <iterator>
#include <boost/intrusive/detail/assert.hpp>
-#include <boost/intrusive/detail/pointer_to_other.hpp>
+#include <boost/intrusive/pointer_traits.hpp>

namespace boost {
namespace intrusive {
@@ -25,8 +25,8 @@
template<class VoidPointer>
struct slist_node
{
- typedef typename boost::pointer_to_other
- <VoidPointer, slist_node>::type node_ptr;
+ typedef typename pointer_traits
+ <VoidPointer>::template rebind_pointer<slist_node>::type node_ptr;
 node_ptr next_;
};

@@ -37,15 +37,15 @@
struct slist_node_traits
{
 typedef slist_node<VoidPointer> node;
- typedef typename boost::pointer_to_other
- <VoidPointer, node>::type node_ptr;
- typedef typename boost::pointer_to_other
- <VoidPointer, const node>::type const_node_ptr;
+ typedef typename pointer_traits
+ <VoidPointer>::template rebind_pointer<node>::type node_ptr;
+ typedef typename pointer_traits
+ <VoidPointer>::template rebind_pointer<const node>::type const_node_ptr;

- static node_ptr get_next(const_node_ptr n)
+ static const node_ptr &get_next(const const_node_ptr & n)
 { return n->next_; }

- static void set_next(node_ptr n, node_ptr next)
+ static void set_next(const node_ptr & n, const node_ptr & next)
 { n->next_ = next; }
};

@@ -66,8 +66,8 @@
 typedef typename real_value_traits::node_traits node_traits;
 typedef typename node_traits::node node;
 typedef typename node_traits::node_ptr node_ptr;
- typedef typename boost::pointer_to_other
- <node_ptr, void>::type void_pointer;
+ typedef typename pointer_traits
+ <node_ptr>::template rebind_pointer <void>::type void_pointer;
 static const bool store_container_ptr =
 detail::store_cont_ptr_on_it<Container>::value;

@@ -77,10 +77,10 @@
 typedef typename detail::if_c<IsConst,typename Container::const_reference,typename Container::reference>::type reference;

 slist_iterator()
- : members_ (node_ptr(0), 0)
+ : members_ (node_ptr(), 0)
 {}

- explicit slist_iterator(node_ptr node, const Container *cont_ptr)
+ explicit slist_iterator(const node_ptr & node, const Container *cont_ptr)
 : members_ (node, cont_ptr)
 {}

@@ -118,7 +118,7 @@
 { return *operator->(); }

 pointer operator->() const
- { return detail::boost_intrusive_get_pointer(this->get_real_value_traits()->to_value_ptr(members_.nodeptr_)); }
+ { return this->get_real_value_traits()->to_value_ptr(members_.nodeptr_); }

 const Container *get_container() const
 {

Modified: branches/release/boost/intrusive/detail/tree_algorithms.hpp
==============================================================================
--- branches/release/boost/intrusive/detail/tree_algorithms.hpp (original)
+++ branches/release/boost/intrusive/detail/tree_algorithms.hpp 2011-12-26 12:10:27 EST (Mon, 26 Dec 2011)
@@ -18,7 +18,7 @@
#include <boost/intrusive/intrusive_fwd.hpp>
#include <cstddef>
#include <boost/intrusive/detail/utilities.hpp>
-//iG pending #include <boost/pointer_cast.hpp>
+#include <boost/intrusive/pointer_traits.hpp>

namespace boost {
namespace intrusive {
@@ -106,7 +106,7 @@
 {
 insert_commit_data()
 : link_left(false)
- , node(0)
+ , node()
 {}
 bool link_left;
 node_ptr node;
@@ -114,7 +114,7 @@

 struct nop_erase_fixup
 {
- void operator()(node_ptr, node_ptr){}
+ void operator()(const node_ptr&, const node_ptr&){}
 };

 /// @cond
@@ -122,7 +122,7 @@
 template<class Disposer>
 struct dispose_subtree_disposer
 {
- dispose_subtree_disposer(Disposer &disp, node_ptr subtree)
+ dispose_subtree_disposer(Disposer &disp, const node_ptr & subtree)
 : disposer_(&disp), subtree_(subtree)
 {}

@@ -139,21 +139,19 @@
 node_ptr subtree_;
 };

- static node_ptr uncast(const_node_ptr ptr)
- {
- return node_ptr(const_cast<node*>(::boost::intrusive::detail::boost_intrusive_get_pointer(ptr)));
- //iG pending return node_ptr(boost::const_pointer_cast<node>(ptr));
- }
+ static node_ptr uncast(const const_node_ptr & ptr)
+ { return pointer_traits<node_ptr>::const_cast_from(ptr); }
+
 /// @endcond

 public:
- static node_ptr begin_node(const_node_ptr header)
+ static node_ptr begin_node(const const_node_ptr & header)
 { return node_traits::get_left(header); }

- static node_ptr end_node(const_node_ptr header)
+ static node_ptr end_node(const const_node_ptr & header)
 { return uncast(header); }

- //! Requires: node is a node of the tree or an node initialized
+ //! Requires: 'node' is a node of the tree or an node initialized
 //! by init(...) or init_node.
 //!
 //! Effects: Returns true if the node is initialized by init() or init_node().
@@ -161,10 +159,10 @@
 //! Complexity: Constant time.
 //!
 //! Throws: Nothing.
- static bool unique(const_node_ptr node)
+ static bool unique(const const_node_ptr & node)
 { return !NodeTraits::get_parent(node); }

- static node_ptr get_header(const_node_ptr node)
+ static node_ptr get_header(const const_node_ptr & node)
 {
 node_ptr h = uncast(node);
 if(NodeTraits::get_parent(node)){
@@ -190,7 +188,7 @@
 //! node1 and node2 are not equivalent according to the ordering rules.
 //!
 //!Experimental function
- static void swap_nodes(node_ptr node1, node_ptr node2)
+ static void swap_nodes(const node_ptr & node1, const node_ptr & node2)
 {
 if(node1 == node2)
 return;
@@ -214,7 +212,7 @@
 //! node1 and node2 are not equivalent according to the ordering rules.
 //!
 //!Experimental function
- static void swap_nodes(node_ptr node1, node_ptr header1, node_ptr node2, node_ptr header2)
+ static void swap_nodes(const node_ptr & node1, const node_ptr & header1, const node_ptr & node2, const node_ptr & header2)
 {
 if(node1 == node2)
 return;
@@ -363,7 +361,7 @@
 //! the node, since no rebalancing and comparison is needed.
 //!
 //!Experimental function
- static void replace_node(node_ptr node_to_be_replaced, node_ptr new_node)
+ static void replace_node(const node_ptr & node_to_be_replaced, const node_ptr & new_node)
 {
 if(node_to_be_replaced == new_node)
 return;
@@ -386,7 +384,7 @@
 //! the node, since no rebalancing or comparison is needed.
 //!
 //!Experimental function
- static void replace_node(node_ptr node_to_be_replaced, node_ptr header, node_ptr new_node)
+ static void replace_node(const node_ptr & node_to_be_replaced, const node_ptr & header, const node_ptr & new_node)
 {
 if(node_to_be_replaced == new_node)
 return;
@@ -429,20 +427,21 @@
 }
 }

- //! Requires: p is a node from the tree except the header.
+ //! Requires: 'node' is a node from the tree except the header.
 //!
 //! Effects: Returns the next node of the tree.
 //!
 //! Complexity: Average constant time.
 //!
 //! Throws: Nothing.
- static node_ptr next_node(node_ptr p)
+ static node_ptr next_node(const node_ptr & node)
 {
- node_ptr p_right(NodeTraits::get_right(p));
+ node_ptr p_right(NodeTraits::get_right(node));
 if(p_right){
 return minimum(p_right);
 }
 else {
+ node_ptr p(node);
 node_ptr x = NodeTraits::get_parent(p);
 while(p == NodeTraits::get_right(x)){
 p = x;
@@ -452,23 +451,24 @@
 }
 }

- //! Requires: p is a node from the tree except the leftmost node.
+ //! Requires: 'node' is a node from the tree except the leftmost node.
 //!
 //! Effects: Returns the previous node of the tree.
 //!
 //! Complexity: Average constant time.
 //!
 //! Throws: Nothing.
- static node_ptr prev_node(node_ptr p)
+ static node_ptr prev_node(const node_ptr & node)
 {
- if(is_header(p)){
- return NodeTraits::get_right(p);
- //return maximum(NodeTraits::get_parent(p));
+ if(is_header(node)){
+ return NodeTraits::get_right(node);
+ //return maximum(NodeTraits::get_parent(node));
 }
- else if(NodeTraits::get_left(p)){
- return maximum(NodeTraits::get_left(p));
+ else if(NodeTraits::get_left(node)){
+ return maximum(NodeTraits::get_left(node));
 }
 else {
+ node_ptr p(node);
 node_ptr x = NodeTraits::get_parent(p);
 while(p == NodeTraits::get_left(x)){
 p = x;
@@ -478,15 +478,16 @@
 }
 }

- //! Requires: p is a node of a tree but not the header.
+ //! Requires: 'node' is a node of a tree but not the header.
 //!
 //! Effects: Returns the minimum node of the subtree starting at p.
 //!
 //! Complexity: Logarithmic to the size of the subtree.
 //!
 //! Throws: Nothing.
- static node_ptr minimum (node_ptr p)
+ static node_ptr minimum (const node_ptr & node)
 {
+ node_ptr p(node);
 for(node_ptr p_left = NodeTraits::get_left(p)
 ;p_left
 ;p_left = NodeTraits::get_left(p)){
@@ -495,15 +496,16 @@
 return p;
 }

- //! Requires: p is a node of a tree but not the header.
+ //! Requires: 'node' is a node of a tree but not the header.
 //!
 //! Effects: Returns the maximum node of the subtree starting at p.
 //!
 //! Complexity: Logarithmic to the size of the subtree.
 //!
 //! Throws: Nothing.
- static node_ptr maximum(node_ptr p)
+ static node_ptr maximum(const node_ptr & node)
 {
+ node_ptr p(node);
 for(node_ptr p_right = NodeTraits::get_right(p)
 ;p_right
 ;p_right = NodeTraits::get_right(p)){
@@ -512,7 +514,7 @@
 return p;
 }

- //! Requires: node must not be part of any tree.
+ //! Requires: 'node' must not be part of any tree.
 //!
 //! Effects: After the function unique(node) == true.
 //!
@@ -521,11 +523,11 @@
 //! Throws: Nothing.
 //!
 //! Nodes: If node is inserted in a tree, this function corrupts the tree.
- static void init(node_ptr node)
+ static void init(const node_ptr & node)
 {
- NodeTraits::set_parent(node, node_ptr(0));
- NodeTraits::set_left(node, node_ptr(0));
- NodeTraits::set_right(node, node_ptr(0));
+ NodeTraits::set_parent(node, node_ptr());
+ NodeTraits::set_left(node, node_ptr());
+ NodeTraits::set_right(node, node_ptr());
 };

 //! Effects: Returns true if node is in the same state as if called init(node)
@@ -533,7 +535,7 @@
 //! Complexity: Constant.
 //!
 //! Throws: Nothing.
- static bool inited(const_node_ptr node)
+ static bool inited(const const_node_ptr & node)
 {
 return !NodeTraits::get_parent(node) &&
 !NodeTraits::get_left(node) &&
@@ -550,9 +552,9 @@
 //! Throws: Nothing.
 //!
 //! Nodes: If node is inserted in a tree, this function corrupts the tree.
- static void init_header(node_ptr header)
+ static void init_header(const node_ptr & header)
 {
- NodeTraits::set_parent(header, node_ptr(0));
+ NodeTraits::set_parent(header, node_ptr());
 NodeTraits::set_left(header, header);
 NodeTraits::set_right(header, header);
 }
@@ -561,7 +563,7 @@
 //! taking a node_ptr parameter and shouldn't throw.
 //!
 //! Effects: Empties the target tree calling
- //! <tt>void disposer::operator()(node_ptr)</tt> for every node of the tree
+ //! <tt>void disposer::operator()(const node_ptr &)</tt> for every node of the tree
 //! except the header.
 //!
 //! Complexity: Linear to the number of element of the source tree plus the.
@@ -569,7 +571,7 @@
 //!
 //! Throws: If cloner functor throws. If this happens target nodes are disposed.
 template<class Disposer>
- static void clear_and_dispose(node_ptr header, Disposer disposer)
+ static void clear_and_dispose(const node_ptr & header, Disposer disposer)
 {
 node_ptr source_root = NodeTraits::get_parent(header);
 if(!source_root)
@@ -591,11 +593,11 @@
 //! only be used for more unlink_leftmost_without_rebalance calls.
 //! This function is normally used to achieve a step by step
 //! controlled destruction of the tree.
- static node_ptr unlink_leftmost_without_rebalance(node_ptr header)
+ static node_ptr unlink_leftmost_without_rebalance(const node_ptr & header)
 {
 node_ptr leftmost = NodeTraits::get_left(header);
 if (leftmost == header)
- return node_ptr(0);
+ return node_ptr();
 node_ptr leftmost_parent(NodeTraits::get_parent(leftmost));
 node_ptr leftmost_right (NodeTraits::get_right(leftmost));
 bool is_root = leftmost_parent == header;
@@ -610,12 +612,12 @@
 NodeTraits::set_left(NodeTraits::get_parent(header), leftmost_right);
 }
 else if (is_root){
- NodeTraits::set_parent(header, node_ptr(0));
+ NodeTraits::set_parent(header, node_ptr());
 NodeTraits::set_left(header, header);
 NodeTraits::set_right(header, header);
 }
 else{
- NodeTraits::set_left(leftmost_parent, node_ptr(0));
+ NodeTraits::set_left(leftmost_parent, node_ptr());
 NodeTraits::set_left(header, leftmost_parent);
 }
 return leftmost;
@@ -628,7 +630,7 @@
 //! Complexity: Linear time.
 //!
 //! Throws: Nothing.
- static std::size_t count(const_node_ptr subtree)
+ static std::size_t count(const const_node_ptr & subtree)
 {
 if(!subtree) return 0;
 std::size_t count = 0;
@@ -664,7 +666,7 @@
 //! Complexity: Linear time.
 //!
 //! Throws: Nothing.
- static std::size_t size(const_node_ptr header)
+ static std::size_t size(const const_node_ptr & header)
 {
 node_ptr beg(begin_node(header));
 node_ptr end(end_node(header));
@@ -682,7 +684,7 @@
 //! Complexity: Constant.
 //!
 //! Throws: Nothing.
- static void swap_tree(node_ptr header1, node_ptr header2)
+ static void swap_tree(const node_ptr & header1, const node_ptr & header2)
 {
 if(header1 == header2)
 return;
@@ -722,7 +724,7 @@
 }
 }

- static bool is_header(const_node_ptr p)
+ static bool is_header(const const_node_ptr & p)
 {
 node_ptr p_left (NodeTraits::get_left(p));
 node_ptr p_right(NodeTraits::get_right(p));
@@ -752,7 +754,7 @@
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static node_ptr find
- (const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp)
+ (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp)
 {
 node_ptr end = uncast(header);
 node_ptr y = lower_bound(header, key, comp);
@@ -774,7 +776,7 @@
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static std::pair<node_ptr, node_ptr> equal_range
- (const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp)
+ (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp)
 {
 node_ptr y = uncast(header);
 node_ptr x = NodeTraits::get_parent(header);
@@ -831,7 +833,7 @@
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static node_ptr lower_bound
- (const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp)
+ (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp)
 {
 node_ptr y = uncast(header);
 node_ptr x = NodeTraits::get_parent(header);
@@ -860,7 +862,7 @@
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static node_ptr upper_bound
- (const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp)
+ (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp)
 {
 node_ptr y = uncast(header);
 node_ptr x = NodeTraits::get_parent(header);
@@ -894,14 +896,14 @@
 //! previously executed to fill "commit_data". No value should be inserted or
 //! erased between the "insert_check" and "insert_commit" calls.
 static void insert_unique_commit
- (node_ptr header, node_ptr new_value, const insert_commit_data &commit_data)
+ (const node_ptr & header, const node_ptr & new_value, const insert_commit_data &commit_data)
 { return insert_commit(header, new_value, commit_data); }

 static void insert_commit
- (node_ptr header, node_ptr new_node, const insert_commit_data &commit_data)
+ (const node_ptr & header, const node_ptr & new_node, const insert_commit_data &commit_data)
 {
 //Check if commit_data has not been initialized by a insert_unique_check call.
- BOOST_INTRUSIVE_INVARIANT_ASSERT(commit_data.node != 0);
+ BOOST_INTRUSIVE_INVARIANT_ASSERT(commit_data.node != node_ptr());
 node_ptr parent_node(commit_data.node);
 if(parent_node == header){
 NodeTraits::set_parent(header, new_node);
@@ -919,8 +921,8 @@
 NodeTraits::set_right(header, new_node);
 }
 NodeTraits::set_parent(new_node, parent_node);
- NodeTraits::set_right(new_node, node_ptr(0));
- NodeTraits::set_left(new_node, node_ptr(0));
+ NodeTraits::set_right(new_node, node_ptr());
+ NodeTraits::set_left(new_node, node_ptr());
 }

 //! Requires: "header" must be the header node of a tree.
@@ -959,14 +961,14 @@
 //! if no more objects are inserted or erased from the set.
 template<class KeyType, class KeyNodePtrCompare>
 static std::pair<node_ptr, bool> insert_unique_check
- (const_node_ptr header, const KeyType &key
+ (const const_node_ptr & header, const KeyType &key
 ,KeyNodePtrCompare comp, insert_commit_data &commit_data, std::size_t *pdepth = 0)
 {
 std::size_t depth = 0;
 node_ptr h(uncast(header));
 node_ptr y(h);
 node_ptr x(NodeTraits::get_parent(y));
- node_ptr prev(0);
+ node_ptr prev = node_ptr();

 //Find the upper bound, cache the previous value and if we should
 //store it in the left or right node
@@ -997,7 +999,7 @@

 template<class KeyType, class KeyNodePtrCompare>
 static std::pair<node_ptr, bool> insert_unique_check
- (const_node_ptr header, node_ptr hint, const KeyType &key
+ (const const_node_ptr & header, const node_ptr &hint, const KeyType &key
 ,KeyNodePtrCompare comp, insert_commit_data &commit_data, std::size_t *pdepth = 0)
 {
 //hint must be bigger than the key
@@ -1019,7 +1021,7 @@

 template<class NodePtrCompare>
 static void insert_equal_check
- ( node_ptr header, node_ptr hint, node_ptr new_node, NodePtrCompare comp
+ (const node_ptr &header, const node_ptr & hint, const node_ptr & new_node, NodePtrCompare comp
 , insert_commit_data &commit_data, std::size_t *pdepth = 0)
 {
 if(hint == header || !comp(hint, new_node)){
@@ -1044,17 +1046,17 @@

 template<class NodePtrCompare>
 static void insert_equal_upper_bound_check
- (node_ptr h, node_ptr new_node, NodePtrCompare comp, insert_commit_data & commit_data, std::size_t *pdepth = 0)
+ (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp, insert_commit_data & commit_data, std::size_t *pdepth = 0)
 { insert_equal_check_impl(true, h, new_node, comp, commit_data, pdepth); }

 template<class NodePtrCompare>
 static void insert_equal_lower_bound_check
- (node_ptr h, node_ptr new_node, NodePtrCompare comp, insert_commit_data & commit_data, std::size_t *pdepth = 0)
+ (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp, insert_commit_data & commit_data, std::size_t *pdepth = 0)
 { insert_equal_check_impl(false, h, new_node, comp, commit_data, pdepth); }

 template<class NodePtrCompare>
 static node_ptr insert_equal
- (node_ptr h, node_ptr hint, node_ptr new_node, NodePtrCompare comp, std::size_t *pdepth = 0)
+ (const node_ptr & h, const node_ptr & hint, const node_ptr & new_node, NodePtrCompare comp, std::size_t *pdepth = 0)
 {
 insert_commit_data commit_data;
 insert_equal_check(h, hint, new_node, comp, commit_data, pdepth);
@@ -1064,7 +1066,7 @@

 template<class NodePtrCompare>
 static node_ptr insert_equal_upper_bound
- (node_ptr h, node_ptr new_node, NodePtrCompare comp, std::size_t *pdepth = 0)
+ (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp, std::size_t *pdepth = 0)
 {
 insert_commit_data commit_data;
 insert_equal_upper_bound_check(h, new_node, comp, commit_data, pdepth);
@@ -1074,7 +1076,7 @@

 template<class NodePtrCompare>
 static node_ptr insert_equal_lower_bound
- (node_ptr h, node_ptr new_node, NodePtrCompare comp, std::size_t *pdepth = 0)
+ (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp, std::size_t *pdepth = 0)
 {
 insert_commit_data commit_data;
 insert_equal_lower_bound_check(h, new_node, comp, commit_data, pdepth);
@@ -1083,7 +1085,7 @@
 }

 static node_ptr insert_before
- (node_ptr header, node_ptr pos, node_ptr new_node, std::size_t *pdepth = 0)
+ (const node_ptr & header, const node_ptr & pos, const node_ptr & new_node, std::size_t *pdepth = 0)
 {
 insert_commit_data commit_data;
 insert_before_check(header, pos, commit_data, pdepth);
@@ -1092,7 +1094,7 @@
 }

 static void insert_before_check
- ( node_ptr header, node_ptr pos
+ (const node_ptr &header, const node_ptr & pos
 , insert_commit_data &commit_data, std::size_t *pdepth = 0)
 {
 node_ptr prev(pos);
@@ -1107,7 +1109,7 @@
 }

 static void push_back
- (node_ptr header, node_ptr new_node, std::size_t *pdepth = 0)
+ (const node_ptr & header, const node_ptr & new_node, std::size_t *pdepth = 0)
 {
 insert_commit_data commit_data;
 push_back_check(header, commit_data, pdepth);
@@ -1115,7 +1117,7 @@
 }

 static void push_back_check
- (node_ptr header, insert_commit_data &commit_data, std::size_t *pdepth = 0)
+ (const node_ptr & header, insert_commit_data &commit_data, std::size_t *pdepth = 0)
 {
 node_ptr prev(NodeTraits::get_right(header));
 if(pdepth){
@@ -1126,7 +1128,7 @@
 }

 static void push_front
- (node_ptr header, node_ptr new_node, std::size_t *pdepth = 0)
+ (const node_ptr & header, const node_ptr & new_node, std::size_t *pdepth = 0)
 {
 insert_commit_data commit_data;
 push_front_check(header, commit_data, pdepth);
@@ -1134,7 +1136,7 @@
 }

 static void push_front_check
- (node_ptr header, insert_commit_data &commit_data, std::size_t *pdepth = 0)
+ (const node_ptr & header, insert_commit_data &commit_data, std::size_t *pdepth = 0)
 {
 node_ptr pos(NodeTraits::get_left(header));
 if(pdepth){
@@ -1144,7 +1146,7 @@
 commit_data.node = pos;
 }

- //! Requires: p can't be a header node.
+ //! Requires: 'node' can't be a header node.
 //!
 //! Effects: Calculates the depth of a node: the depth of a
 //! node is the length (number of edges) of the path from the root
@@ -1153,8 +1155,9 @@
 //! Complexity: Logarithmic to the number of nodes in the tree.
 //!
 //! Throws: Nothing.
- static std::size_t depth(const_node_ptr p)
+ static std::size_t depth(const const_node_ptr & node)
 {
+ const_node_ptr p(node);
 std::size_t depth = 0;
 node_ptr p_parent;
 while(p != NodeTraits::get_parent(p_parent = NodeTraits::get_parent(p))){
@@ -1169,13 +1172,13 @@
 //! take a node_ptr and shouldn't throw.
 //!
 //! Effects: First empties target tree calling
- //! <tt>void disposer::operator()(node_ptr)</tt> for every node of the tree
+ //! <tt>void disposer::operator()(const node_ptr &)</tt> for every node of the tree
 //! except the header.
 //!
 //! Then, duplicates the entire tree pointed by "source_header" cloning each
- //! source node with <tt>node_ptr Cloner::operator()(node_ptr)</tt> to obtain
+ //! source node with <tt>node_ptr Cloner::operator()(const node_ptr &)</tt> to obtain
 //! the nodes of the target tree. If "cloner" throws, the cloned target nodes
- //! are disposed using <tt>void disposer(node_ptr)</tt>.
+ //! are disposed using <tt>void disposer(const node_ptr &)</tt>.
 //!
 //! Complexity: Linear to the number of element of the source tree plus the.
 //! number of elements of tree target tree when calling this function.
@@ -1183,7 +1186,7 @@
 //! Throws: If cloner functor throws. If this happens target nodes are disposed.
 template <class Cloner, class Disposer>
 static void clone
- (const_node_ptr source_header, node_ptr target_header, Cloner cloner, Disposer disposer)
+ (const const_node_ptr & source_header, const node_ptr & target_header, Cloner cloner, Disposer disposer)
 {
 if(!unique(target_header)){
 clear_and_dispose(target_header, disposer);
@@ -1201,9 +1204,9 @@

 template <class Cloner, class Disposer>
 static node_ptr clone_subtree
- ( const_node_ptr source_parent, node_ptr target_parent
- , Cloner cloner, Disposer disposer
- , node_ptr &leftmost_out, node_ptr &rightmost_out
+ (const const_node_ptr &source_parent, const node_ptr &target_parent
+ , Cloner cloner, Disposer disposer
+ , node_ptr &leftmost_out, node_ptr &rightmost_out
 )
 {
 node_ptr target_sub_root = target_parent;
@@ -1221,8 +1224,8 @@
 node_ptr rightmost = target_sub_root;

 //First set the subroot
- NodeTraits::set_left(target_sub_root, node_ptr(0));
- NodeTraits::set_right(target_sub_root, node_ptr(0));
+ NodeTraits::set_left(target_sub_root, node_ptr());
+ NodeTraits::set_right(target_sub_root, node_ptr());
 NodeTraits::set_parent(target_sub_root, target_parent);

 dispose_subtree_disposer<Disposer> rollback(disposer, target_sub_root);
@@ -1234,8 +1237,8 @@
 node_ptr temp = insertion_point;
 //Clone and mark as leaf
 insertion_point = cloner(current);
- NodeTraits::set_left (insertion_point, node_ptr(0));
- NodeTraits::set_right (insertion_point, node_ptr(0));
+ NodeTraits::set_left (insertion_point, node_ptr());
+ NodeTraits::set_right (insertion_point, node_ptr());
 //Insert left
 NodeTraits::set_parent(insertion_point, temp);
 NodeTraits::set_left (temp, insertion_point);
@@ -1250,8 +1253,8 @@
 node_ptr temp = insertion_point;
 //Clone and mark as leaf
 insertion_point = cloner(current);
- NodeTraits::set_left (insertion_point, node_ptr(0));
- NodeTraits::set_right (insertion_point, node_ptr(0));
+ NodeTraits::set_left (insertion_point, node_ptr());
+ NodeTraits::set_right (insertion_point, node_ptr());
 //Insert right
 NodeTraits::set_parent(insertion_point, temp);
 NodeTraits::set_right (temp, insertion_point);
@@ -1276,9 +1279,10 @@
 }

 template<class Disposer>
- static void dispose_subtree(node_ptr x, Disposer disposer)
+ static void dispose_subtree(const node_ptr & node, Disposer disposer)
 {
 node_ptr save;
+ node_ptr x(node);
 while (x){
 save = NodeTraits::get_left(x);
 if (save) {
@@ -1302,7 +1306,7 @@
 //! Complexity: Constant.
 //!
 //! Throws: Nothing.
- static bool is_left_child(node_ptr p)
+ static bool is_left_child(const node_ptr & p)
 { return NodeTraits::get_left(NodeTraits::get_parent(p)) == p; }

 //! Requires: p is a node of a tree.
@@ -1312,11 +1316,11 @@
 //! Complexity: Constant.
 //!
 //! Throws: Nothing.
- static bool is_right_child(node_ptr p)
+ static bool is_right_child(const node_ptr & p)
 { return NodeTraits::get_right(NodeTraits::get_parent(p)) == p; }

 //Fix header and own's parent data when replacing x with own, providing own's old data with parent
- static void replace_own_impl(node_ptr own, node_ptr x, node_ptr header, node_ptr own_parent, bool own_was_left)
+ static void replace_own_impl(const node_ptr & own, const node_ptr & x, const node_ptr & header, const node_ptr & own_parent, bool own_was_left)
 {
 if(NodeTraits::get_parent(header) == own)
 NodeTraits::set_parent(header, x);
@@ -1328,7 +1332,7 @@

 //Fix header and own's parent data when replacing x with own, supposing own
 //links with its parent are still ok
- static void replace_own(node_ptr own, node_ptr x, node_ptr header)
+ static void replace_own(const node_ptr & own, const node_ptr & x, const node_ptr & header)
 {
 node_ptr own_parent(NodeTraits::get_parent(own));
 bool own_is_left(NodeTraits::get_left(own_parent) == own);
@@ -1336,7 +1340,7 @@
 }

 // rotate parent p to left (no header and p's parent fixup)
- static node_ptr rotate_left(node_ptr p)
+ static node_ptr rotate_left(const node_ptr & p)
 {
 node_ptr x(NodeTraits::get_right(p));
 node_ptr x_left(NodeTraits::get_left(x));
@@ -1350,7 +1354,7 @@
 }

 // rotate parent p to left (with header and p's parent fixup)
- static void rotate_left(node_ptr p, node_ptr header)
+ static void rotate_left(const node_ptr & p, const node_ptr & header)
 {
 bool p_was_left(is_left_child(p));
 node_ptr p_old_parent(NodeTraits::get_parent(p));
@@ -1360,7 +1364,7 @@
 }

 // rotate parent p to right (no header and p's parent fixup)
- static node_ptr rotate_right(node_ptr p)
+ static node_ptr rotate_right(const node_ptr & p)
 {
 node_ptr x(NodeTraits::get_left(p));
 node_ptr x_right(NodeTraits::get_right(x));
@@ -1374,7 +1378,7 @@
 }

 // rotate parent p to right (with header and p's parent fixup)
- static void rotate_right(node_ptr p, node_ptr header)
+ static void rotate_right(const node_ptr & p, const node_ptr & header)
 {
 bool p_was_left(is_left_child(p));
 node_ptr p_old_parent(NodeTraits::get_parent(p));
@@ -1383,7 +1387,7 @@
 replace_own_impl(p, x, header, p_old_parent, p_was_left);
 }

- static void erase(node_ptr header, node_ptr z)
+ static void erase(const node_ptr & header, const node_ptr & z)
 {
 data_for_rebalance ignored;
 erase_impl(header, z, ignored);
@@ -1397,7 +1401,7 @@
 };

 template<class F>
- static void erase(node_ptr header, node_ptr z, F z_and_successor_fixup, data_for_rebalance &info)
+ static void erase(const node_ptr & header, const node_ptr & z, F z_and_successor_fixup, data_for_rebalance &info)
 {
 erase_impl(header, z, info);
 if(info.y != z){
@@ -1405,7 +1409,7 @@
 }
 }

- static void unlink(node_ptr node)
+ static void unlink(const node_ptr & node)
 {
 node_ptr x = NodeTraits::get_parent(node);
 if(x){
@@ -1415,13 +1419,13 @@
 }
 }

- static void tree_to_vine(node_ptr header)
+ static void tree_to_vine(const node_ptr & header)
 { subtree_to_vine(NodeTraits::get_parent(header)); }

- static void vine_to_tree(node_ptr header, std::size_t count)
+ static void vine_to_tree(const node_ptr & header, std::size_t count)
 { vine_to_subtree(NodeTraits::get_parent(header), count); }

- static void rebalance(node_ptr header)
+ static void rebalance(const node_ptr & header)
 {
 //Taken from:
 //"Tree rebalancing in optimal time and space"
@@ -1431,18 +1435,18 @@
 vine_to_subtree(NodeTraits::get_parent(header), len);
 }

- static node_ptr rebalance_subtree(node_ptr old_root)
+ static node_ptr rebalance_subtree(const node_ptr & old_root)
 {
 std::size_t len = 0;
 node_ptr new_root = subtree_to_vine(old_root, &len);
 return vine_to_subtree(new_root, len);
 }

- static node_ptr subtree_to_vine(node_ptr old_root, std::size_t *plen = 0)
+ static node_ptr subtree_to_vine(const node_ptr & old_root, std::size_t *plen = 0)
 {
 std::size_t len;
 len = 0;
- if(!old_root) return node_ptr(0);
+ if(!old_root) return node_ptr();

 //To avoid irregularities in the algorithm (old_root can be a
 //left or right child or even the root of the tree) just put the
@@ -1499,7 +1503,7 @@
 return new_root;
 }

- static node_ptr vine_to_subtree(node_ptr old_root, std::size_t count)
+ static node_ptr vine_to_subtree(const node_ptr & old_root, std::size_t count)
 {
 std::size_t leaf_nodes = count + 1 - ((std::size_t) 1 << floor_log2 (count + 1));
 std::size_t vine_nodes = count - leaf_nodes;
@@ -1512,7 +1516,7 @@
 return new_root;
 }

- static node_ptr compress_subtree(node_ptr old_root, std::size_t count)
+ static node_ptr compress_subtree(const node_ptr & old_root, std::size_t count)
 {
 if(!old_root) return old_root;

@@ -1576,7 +1580,7 @@
 //! Complexity: Logarithmic.
 //!
 //! Throws: Nothing.
- static node_ptr get_root(node_ptr node)
+ static node_ptr get_root(const node_ptr & node)
 {
 BOOST_INTRUSIVE_INVARIANT_ASSERT((!inited(node)));
 node_ptr x = NodeTraits::get_parent(node);
@@ -1594,7 +1598,7 @@
 private:
 template<class NodePtrCompare>
 static void insert_equal_check_impl
- (bool upper, node_ptr h, node_ptr new_node, NodePtrCompare comp, insert_commit_data & commit_data, std::size_t *pdepth = 0)
+ (bool upper, const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp, insert_commit_data & commit_data, std::size_t *pdepth = 0)
 {
 std::size_t depth = 0;
 node_ptr y(h);
@@ -1625,11 +1629,11 @@
 if(pdepth) *pdepth = depth;
 }

- static void erase_impl(node_ptr header, node_ptr z, data_for_rebalance &info)
+ static void erase_impl(const node_ptr & header, const node_ptr & z, data_for_rebalance &info)
 {
 node_ptr y(z);
 node_ptr x;
- node_ptr x_parent(0);
+ node_ptr x_parent = node_ptr();
 node_ptr z_left(NodeTraits::get_left(z));
 node_ptr z_right(NodeTraits::get_right(z));
 if(!z_left){

Modified: branches/release/boost/intrusive/detail/tree_node.hpp
==============================================================================
--- branches/release/boost/intrusive/detail/tree_node.hpp (original)
+++ branches/release/boost/intrusive/detail/tree_node.hpp 2011-12-26 12:10:27 EST (Mon, 26 Dec 2011)
@@ -15,7 +15,7 @@

#include <boost/intrusive/detail/config_begin.hpp>
#include <iterator>
-#include <boost/intrusive/detail/pointer_to_other.hpp>
+#include <boost/intrusive/pointer_traits.hpp>
#include <boost/intrusive/detail/mpl.hpp>

namespace boost {
@@ -24,9 +24,9 @@
template<class VoidPointer>
struct tree_node
{
- typedef typename pointer_to_other
- <VoidPointer
- ,tree_node<VoidPointer> >::type node_ptr;
+ typedef typename pointer_traits
+ <VoidPointer>::template rebind_pointer
+ <tree_node<VoidPointer> >::type node_ptr;

 node_ptr parent_, left_, right_;
};
@@ -36,27 +36,27 @@
{
 typedef tree_node<VoidPointer> node;

- typedef typename boost::pointer_to_other
- <VoidPointer, node>::type node_ptr;
- typedef typename boost::pointer_to_other
- <VoidPointer, const node>::type const_node_ptr;
+ typedef typename pointer_traits<VoidPointer>::template
+ rebind_pointer<node>::type node_ptr;
+ typedef typename pointer_traits<VoidPointer>::template
+ rebind_pointer<const node>::type const_node_ptr;

- static node_ptr get_parent(const_node_ptr n)
+ static const node_ptr & get_parent(const const_node_ptr & n)
 { return n->parent_; }

- static void set_parent(node_ptr n, node_ptr p)
+ static void set_parent(const node_ptr & n, const node_ptr & p)
 { n->parent_ = p; }

- static node_ptr get_left(const_node_ptr n)
+ static const node_ptr & get_left(const const_node_ptr & n)
 { return n->left_; }

- static void set_left(node_ptr n, node_ptr l)
+ static void set_left(const node_ptr & n, const node_ptr & l)
 { n->left_ = l; }

- static node_ptr get_right(const_node_ptr n)
+ static const node_ptr & get_right(const const_node_ptr & n)
 { return n->right_; }

- static void set_right(node_ptr n, node_ptr r)
+ static void set_right(const node_ptr & n, const node_ptr & r)
 { n->right_ = r; }
};

@@ -84,8 +84,8 @@
 typedef typename real_value_traits::node_traits node_traits;
 typedef typename node_traits::node node;
 typedef typename node_traits::node_ptr node_ptr;
- typedef typename boost::pointer_to_other
- <node_ptr, void>::type void_pointer;
+ typedef typename pointer_traits<node_ptr>::template
+ rebind_pointer<void>::type void_pointer;
 static const bool store_container_ptr =
 detail::store_cont_ptr_on_it<Container>::value;

@@ -96,10 +96,10 @@

 tree_iterator()
- : members_ (node_ptr(0), (const void *)0)
+ : members_ (node_ptr(), (const void *)0)
 {}

- explicit tree_iterator(node_ptr nodeptr, const Container *cont_ptr)
+ explicit tree_iterator(const node_ptr & nodeptr, const Container *cont_ptr)
 : members_ (nodeptr, cont_ptr)
 {}

@@ -150,7 +150,7 @@
 { return *operator->(); }

 pointer operator->() const
- { return detail::boost_intrusive_get_pointer(this->get_real_value_traits()->to_value_ptr(members_.nodeptr_)); }
+ { return this->get_real_value_traits()->to_value_ptr(members_.nodeptr_); }

 const Container *get_container() const
 { return static_cast<const Container*>(members_.get_ptr()); }

Modified: branches/release/boost/intrusive/detail/utilities.hpp
==============================================================================
--- branches/release/boost/intrusive/detail/utilities.hpp (original)
+++ branches/release/boost/intrusive/detail/utilities.hpp 2011-12-26 12:10:27 EST (Mon, 26 Dec 2011)
@@ -14,13 +14,14 @@
#define BOOST_INTRUSIVE_DETAIL_UTILITIES_HPP

#include <boost/intrusive/detail/config_begin.hpp>
-#include <boost/intrusive/detail/pointer_to_other.hpp>
+#include <boost/intrusive/pointer_traits.hpp>
#include <boost/intrusive/detail/parent_from_member.hpp>
#include <boost/intrusive/detail/ebo_functor_holder.hpp>
#include <boost/intrusive/link_mode.hpp>
#include <boost/intrusive/detail/mpl.hpp>
#include <boost/intrusive/detail/assert.hpp>
#include <boost/intrusive/detail/is_stateful_value_traits.hpp>
+#include <boost/intrusive/pointer_traits.hpp>
#include <boost/cstdint.hpp>
#include <cstddef>
#include <climits>
@@ -104,29 +105,14 @@
 : public Node
{};

-template<class SmartPtr>
-struct smart_ptr_type
-{
- typedef typename SmartPtr::value_type value_type;
- typedef value_type *pointer;
- static pointer get (const SmartPtr &smartptr)
- { return smartptr.get();}
-};
-
-template<class T>
-struct smart_ptr_type<T*>
-{
- typedef T value_type;
- typedef value_type *pointer;
- static pointer get (pointer ptr)
- { return ptr;}
-};
+template <class T>
+inline T* to_raw_pointer(T* p)
+{ return p; }

-//!Overload for smart pointers to avoid ADL problems with boost_intrusive_get_pointer
-template<class Ptr>
-inline typename smart_ptr_type<Ptr>::pointer
-boost_intrusive_get_pointer(const Ptr &ptr)
-{ return smart_ptr_type<Ptr>::get(ptr); }
+template <class Pointer>
+inline typename boost::intrusive::pointer_traits<Pointer>::element_type*
+to_raw_pointer(const Pointer &p)
+{ return boost::intrusive::detail::to_raw_pointer(p.operator->()); }

//This functor compares a stored value
//and the one passed as an argument
@@ -158,7 +144,7 @@
 typedef typename NodeAlgorithms::node_ptr node_ptr;

 public:
- void operator()(node_ptr p)
+ void operator()(const node_ptr & p)
 { NodeAlgorithms::init(p); }
};

@@ -258,13 +244,14 @@
 : base_t(f), cont_(cont)
 {}

- node_ptr operator()(node_ptr p)
+ node_ptr operator()(const node_ptr & p)
 { return this->operator()(*p); }

 node_ptr operator()(const node &to_clone)
 {
 const value_type &v =
- *cont_->get_real_value_traits().to_value_ptr(const_node_ptr(&to_clone));
+ *cont_->get_real_value_traits().to_value_ptr
+ (pointer_traits<const_node_ptr>::pointer_to(to_clone));
 node_ptr n = cont_->get_real_value_traits().to_node_ptr(*base_t::get()(v));
 //Cloned node must be in default mode if the linking mode requires it
 if(safemode_or_autounlink)
@@ -291,7 +278,7 @@
 : base_t(f), cont_(cont)
 {}

- void operator()(node_ptr p)
+ void operator()(const node_ptr & p)
 {
 if(safemode_or_autounlink)
 node_algorithms::init(p);
@@ -312,15 +299,15 @@
template<class VoidPointer>
struct constptr
{
- typedef typename boost::pointer_to_other
- <VoidPointer, const void>::type ConstVoidPtr;
+ typedef typename boost::intrusive::pointer_traits<VoidPointer>::
+ template rebind_pointer<const void>::type ConstVoidPtr;

 constptr(const void *ptr)
 : const_void_ptr_(ptr)
 {}

 const void *get_ptr() const
- { return detail::boost_intrusive_get_pointer(const_void_ptr_); }
+ { return boost::intrusive::detail::to_raw_pointer(const_void_ptr_); }

 ConstVoidPtr const_void_ptr_;
};
@@ -371,27 +358,49 @@
 public:
 typedef detail::node_holder
 <typename NodeTraits::node, Tag, LinkMode, HookType> node_holder;
+ typedef typename NodeTraits::node node;
 typedef NodeTraits node_traits;
 typedef T value_type;
 typedef typename node_traits::node_ptr node_ptr;
 typedef typename node_traits::const_node_ptr const_node_ptr;
- typedef typename boost::pointer_to_other<node_ptr, T>::type pointer;
- typedef typename boost::pointer_to_other<node_ptr, const T>::type const_pointer;
- typedef typename std::iterator_traits<pointer>::reference reference;
- typedef typename std::iterator_traits<const_pointer>::reference const_reference;
+ typedef typename pointer_traits<node_ptr>::
+ template rebind_pointer<T>::type pointer;
+ typedef typename pointer_traits<node_ptr>::
+ template rebind_pointer<const T>::type const_pointer;
+ //typedef typename pointer_traits<pointer>::reference reference;
+ //typedef typename pointer_traits<const_pointer>::reference const_reference;
+ typedef T & reference;
+ typedef const T & const_reference;
+ typedef node_holder & node_holder_reference;
+ typedef const node_holder & const_node_holder_reference;
+ typedef node& node_reference;
+ typedef const node & const_node_reference;
+
 static const link_mode_type link_mode = LinkMode;

- static node_ptr to_node_ptr(reference value)
- { return static_cast<node_holder*>(&value); }
+ static pointer to_value_ptr(const node_ptr & n)
+ {
+ return pointer_traits<pointer>::pointer_to
+ (static_cast<reference>(static_cast<node_holder_reference>(*n)));
+ }

- static const_node_ptr to_node_ptr(const_reference value)
- { return static_cast<const node_holder*>(&value); }
+ static const_pointer to_value_ptr(const const_node_ptr & n)
+ {
+ return pointer_traits<const_pointer>::pointer_to
+ (static_cast<const_reference>(static_cast<const_node_holder_reference>(*n)));
+ }

- static pointer to_value_ptr(node_ptr n)
- { return static_cast<T*>(static_cast<node_holder*>(&*n)); }
+ static node_ptr to_node_ptr(reference value)
+ {
+ return pointer_traits<node_ptr>::pointer_to
+ (static_cast<node_reference>(static_cast<node_holder_reference>(value)));
+ }

- static const_pointer to_value_ptr(const_node_ptr n)
- { return static_cast<const T*>(static_cast<const node_holder*>(&*n)); }
+ static const_node_ptr to_node_ptr(const_reference value)
+ {
+ return pointer_traits<const_node_ptr>::pointer_to
+ (static_cast<const_node_reference>(static_cast<const_node_holder_reference>(value)));
+ }
};

template<class T, class Hook, Hook T::* P>
@@ -404,28 +413,43 @@
 typedef T value_type;
 typedef typename node_traits::node_ptr node_ptr;
 typedef typename node_traits::const_node_ptr const_node_ptr;
- typedef typename boost::pointer_to_other<node_ptr, T>::type pointer;
- typedef typename boost::pointer_to_other<node_ptr, const T>::type const_pointer;
- typedef typename std::iterator_traits<pointer>::reference reference;
- typedef typename std::iterator_traits<const_pointer>::reference const_reference;
+ typedef typename pointer_traits<node_ptr>::
+ template rebind_pointer<T>::type pointer;
+ typedef typename pointer_traits<node_ptr>::
+ template rebind_pointer<const T>::type const_pointer;
+ typedef T & reference;
+ typedef const T & const_reference;
+ typedef node& node_reference;
+ typedef const node & const_node_reference;
+ typedef hook_type& hook_reference;
+ typedef const hook_type & const_hook_reference;
+
 static const link_mode_type link_mode = Hook::boost_intrusive_tags::link_mode;

 static node_ptr to_node_ptr(reference value)
- { return static_cast<node*>(&(value.*P)); }
+ {
+ return pointer_traits<node_ptr>::pointer_to
+ (static_cast<node_reference>(static_cast<hook_reference>(value.*P)));
+ }

 static const_node_ptr to_node_ptr(const_reference value)
- { return static_cast<const node*>(&(value.*P)); }
+ {
+ return pointer_traits<const_node_ptr>::pointer_to
+ (static_cast<const_node_reference>(static_cast<const_hook_reference>(value.*P)));
+ }

- static pointer to_value_ptr(node_ptr n)
+ static pointer to_value_ptr(const node_ptr & n)
 {
- return detail::parent_from_member<T, Hook>
- (static_cast<Hook*>(detail::boost_intrusive_get_pointer(n)), P);
+ return pointer_traits<pointer>::pointer_to
+ (*detail::parent_from_member<T, Hook>
+ (static_cast<Hook*>(boost::intrusive::detail::to_raw_pointer(n)), P));
 }

- static const_pointer to_value_ptr(const_node_ptr n)
+ static const_pointer to_value_ptr(const const_node_ptr & n)
 {
- return detail::parent_from_member<T, Hook>
- (static_cast<const Hook*>(detail::boost_intrusive_get_pointer(n)), P);
+ return pointer_traits<const_pointer>::pointer_to
+ (*detail::parent_from_member<T, Hook>
+ (static_cast<const Hook*>(boost::intrusive::detail::to_raw_pointer(n)), P));
 }
};

@@ -441,29 +465,31 @@
 typedef typename Functor::value_type value_type;
 typedef typename node_traits::node_ptr node_ptr;
 typedef typename node_traits::const_node_ptr const_node_ptr;
- typedef typename boost::pointer_to_other<node_ptr, value_type>::type pointer;
- typedef typename boost::pointer_to_other<node_ptr, const value_type>::type const_pointer;
- typedef typename std::iterator_traits<pointer>::reference reference;
- typedef typename std::iterator_traits<const_pointer>::reference const_reference;
+ typedef typename pointer_traits<node_ptr>::
+ template rebind_pointer<value_type>::type pointer;
+ typedef typename pointer_traits<node_ptr>::
+ template rebind_pointer<const value_type>::type const_pointer;
+ typedef value_type & reference;
+ typedef const value_type & const_reference;
 static const link_mode_type link_mode = hook_type::boost_intrusive_tags::link_mode;

 static node_ptr to_node_ptr(reference value)
- { return static_cast<node*>(&*Functor::to_hook_ptr(value)); }
+ { return static_cast<node*>(boost::intrusive::detail::to_raw_pointer(Functor::to_hook_ptr(value))); }

 static const_node_ptr to_node_ptr(const_reference value)
- { return static_cast<const node*>(&*Functor::to_hook_ptr(value)); }
+ { return static_cast<const node*>(boost::intrusive::detail::to_raw_pointer(Functor::to_hook_ptr(value))); }

- static pointer to_value_ptr(node_ptr n)
+ static pointer to_value_ptr(const node_ptr & n)
 { return Functor::to_value_ptr(to_hook_ptr(n)); }

- static const_pointer to_value_ptr(const_node_ptr n)
+ static const_pointer to_value_ptr(const const_node_ptr & n)
 { return Functor::to_value_ptr(to_hook_ptr(n)); }

 private:
- static hook_ptr to_hook_ptr(node_ptr n)
+ static hook_ptr to_hook_ptr(const node_ptr & n)
 { return hook_ptr(&*static_cast<hook_type*>(&*n)); }

- static const_hook_ptr to_hook_ptr(const_node_ptr n)
+ static const_hook_ptr to_hook_ptr(const const_node_ptr & n)
 { return const_hook_ptr(&*static_cast<const hook_type*>(&*n)); }
};

@@ -624,8 +650,8 @@
template<class Container, bool IsConst>
struct node_to_value
 : public detail::select_constptr
- < typename boost::pointer_to_other
- <typename Container::pointer, void>::type
+ < typename pointer_traits
+ <typename Container::pointer>::template rebind_pointer<void>::type
 , detail::store_cont_ptr_on_it<Container>::value
>::type
{
@@ -635,16 +661,16 @@
 typedef typename Container::real_value_traits real_value_traits;
 typedef typename real_value_traits::value_type value_type;
 typedef typename detail::select_constptr
- < typename boost::pointer_to_other
- <typename Container::pointer, void>::type
+ < typename pointer_traits
+ <typename Container::pointer>::template rebind_pointer<void>::type
 , store_container_ptr >::type Base;
 typedef typename real_value_traits::node_traits::node node;
 typedef typename detail::add_const_if_c
 <value_type, IsConst>::type vtype;
 typedef typename detail::add_const_if_c
 <node, IsConst>::type ntype;
- typedef typename boost::pointer_to_other
- <typename Container::pointer, ntype>::type npointer;
+ typedef typename pointer_traits
+ <typename Container::pointer>::template rebind_pointer<ntype>::type npointer;

 node_to_value(const Container *cont)
 : Base(cont)
@@ -670,7 +696,10 @@
 }

 result_type operator()(first_argument_type arg) const
- { return *(this->get_real_value_traits()->to_value_ptr(npointer(&arg))); }
+ {
+ return *(this->get_real_value_traits()->to_value_ptr
+ (pointer_traits<npointer>::pointer_to(arg)));
+ }
};

//This is not standard, but should work with all compilers
@@ -732,6 +761,115 @@
 detail::max_align rawbuf[(N*sizeof(T)-1)/sizeof(detail::max_align)+1];
};

+
+
+
+template<class It>
+class reverse_iterator
+ : public std::iterator<
+ typename std::iterator_traits<It>::iterator_category,
+ typename std::iterator_traits<It>::value_type,
+ typename std::iterator_traits<It>::difference_type,
+ typename std::iterator_traits<It>::pointer,
+ typename std::iterator_traits<It>::reference>
+{
+ public:
+ typedef typename std::iterator_traits<It>::pointer pointer;
+ typedef typename std::iterator_traits<It>::reference reference;
+ typedef typename std::iterator_traits<It>::difference_type difference_type;
+ typedef It iterator_type;
+
+ reverse_iterator(){}
+
+ explicit reverse_iterator(It r)
+ : m_current(r)
+ {}
+
+ template<class OtherIt>
+ reverse_iterator(const reverse_iterator<OtherIt>& r)
+ : m_current(r.base())
+ {}
+
+ It base() const
+ { return m_current; }
+
+ reference operator*() const
+ { It temp(m_current); --temp; return *temp; }
+
+ pointer operator->() const
+ { It temp(m_current); --temp; return temp.operator->(); }
+
+ reference operator[](difference_type off) const
+ { return this->m_current[-off]; }
+
+ reverse_iterator& operator++()
+ { --m_current; return *this; }
+
+ reverse_iterator operator++(int)
+ {
+ reverse_iterator temp = *this;
+ --m_current;
+ return temp;
+ }
+
+ reverse_iterator& operator--()
+ {
+ ++m_current;
+ return *this;
+ }
+
+ reverse_iterator operator--(int)
+ {
+ reverse_iterator temp(*this);
+ ++m_current;
+ return temp;
+ }
+
+ friend bool operator==(const reverse_iterator& l, const reverse_iterator& r)
+ { return l.m_current == r.m_current; }
+
+ friend bool operator!=(const reverse_iterator& l, const reverse_iterator& r)
+ { return l.m_current != r.m_current; }
+
+ friend bool operator<(const reverse_iterator& l, const reverse_iterator& r)
+ { return l.m_current < r.m_current; }
+
+ friend bool operator<=(const reverse_iterator& l, const reverse_iterator& r)
+ { return l.m_current <= r.m_current; }
+
+ friend bool operator>(const reverse_iterator& l, const reverse_iterator& r)
+ { return l.m_current > r.m_current; }
+
+ friend bool operator>=(const reverse_iterator& l, const reverse_iterator& r)
+ { return l.m_current >= r.m_current; }
+
+ reverse_iterator& operator+=(difference_type off)
+ { m_current -= off; return *this; }
+
+ friend reverse_iterator operator+(const reverse_iterator & l, difference_type off)
+ {
+ reverse_iterator tmp(l.m_current);
+ tmp.m_current -= off;
+ return tmp;
+ }
+
+ reverse_iterator& operator-=(difference_type off)
+ { m_current += off; return *this; }
+
+ friend reverse_iterator operator-(const reverse_iterator & l, difference_type off)
+ {
+ reverse_iterator tmp(l.m_current);
+ tmp.m_current += off;
+ return tmp;
+ }
+
+ friend difference_type operator-(const reverse_iterator& l, const reverse_iterator& r)
+ { return r.m_current - l.m_current; }
+
+ private:
+ It m_current; // the wrapped iterator
+};
+
} //namespace detail
} //namespace intrusive
} //namespace boost

Modified: branches/release/boost/intrusive/detail/workaround.hpp
==============================================================================
--- branches/release/boost/intrusive/detail/workaround.hpp (original)
+++ branches/release/boost/intrusive/detail/workaround.hpp 2011-12-26 12:10:27 EST (Mon, 26 Dec 2011)
@@ -11,20 +11,12 @@
#ifndef BOOST_INTRUSIVE_DETAIL_WRKRND_HPP
#define BOOST_INTRUSIVE_DETAIL_WRKRND_HPP

-#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 2)
-// C++0x features are only enabled when -std=c++0x or -std=gnu++0x are
-// passed on the command line, which in turn defines
-// __GXX_EXPERIMENTAL_CXX0X__. Note: __GXX_EXPERIMENTAL_CPP0X__ is
-// defined by some very early development versions of GCC 4.3; we will
-// remove this part of the check in the near future.
-# if defined(__GXX_EXPERIMENTAL_CPP0X__) || defined(__GXX_EXPERIMENTAL_CXX0X__)
-# define BOOST_INTRUSIVE_RVALUE_REFERENCE
-# define BOOST_INTRUSIVE_VARIADIC_TEMPLATES
-# endif
-#endif
+#include <boost/intrusive/detail/config_begin.hpp>

-#if defined(BOOST_INTRUSIVE_RVALUE_REFERENCE) && defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
-#define BOOST_INTRUSIVE_PERFECT_FORWARDING
+#if !defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_NO_VARIADIC_TEMPLATES)
+ #define BOOST_INTRUSIVE_PERFECT_FORWARDING
#endif

+#include <boost/intrusive/detail/config_end.hpp>
+
#endif //#ifndef BOOST_INTRUSIVE_DETAIL_WRKRND_HPP

Modified: branches/release/boost/intrusive/hashtable.hpp
==============================================================================
--- branches/release/boost/intrusive/hashtable.hpp (original)
+++ branches/release/boost/intrusive/hashtable.hpp 2011-12-26 12:10:27 EST (Mon, 26 Dec 2011)
@@ -18,7 +18,6 @@
#include <utility> //std::pair
#include <algorithm> //std::swap, std::lower_bound, std::upper_bound
#include <cstddef> //std::size_t
-#include <iterator> //std::iterator_traits
//boost
#include <boost/intrusive/detail/assert.hpp>
#include <boost/static_assert.hpp>
@@ -26,7 +25,6 @@
#include <boost/pointer_cast.hpp>
//General intrusive utilities
#include <boost/intrusive/intrusive_fwd.hpp>
-#include <boost/intrusive/detail/pointer_to_other.hpp>
#include <boost/intrusive/detail/hashtable_node.hpp>
#include <boost/intrusive/detail/transform_iterator.hpp>
#include <boost/intrusive/link_mode.hpp>
@@ -36,6 +34,7 @@
#include <boost/intrusive/trivial_value_traits.hpp>
#include <boost/intrusive/unordered_set_hook.hpp>
#include <boost/intrusive/slist.hpp>
+#include <boost/intrusive/pointer_traits.hpp>
#include <boost/intrusive/detail/mpl.hpp>
#include <boost/type_traits.hpp>
#include <boost/move/move.hpp>
@@ -125,7 +124,8 @@
 < typename NodeTraits::node
 , boost::intrusive::value_traits<trivial_traits>
 , boost::intrusive::constant_time_size<false>
- , boost::intrusive::size_type<typename boost::make_unsigned<typename std::iterator_traits<typename NodeTraits::node_ptr>::difference_type>::type>
+ , boost::intrusive::size_type<typename boost::make_unsigned
+ <typename pointer_traits<typename NodeTraits::node_ptr>::difference_type>::type >
>::type
 {};
};
@@ -174,8 +174,10 @@
 <SupposedValueTraits>::type::node_ptr node_ptr;
 typedef typename unordered_bucket_impl
 <SupposedValueTraits>::type bucket_type;
- typedef typename boost::pointer_to_other
- <node_ptr, bucket_type>::type implementation_defined;
+
+ typedef typename pointer_traits
+ <node_ptr>::template rebind_pointer
+ < bucket_type >::type implementation_defined;
 typedef implementation_defined type;
};

@@ -267,6 +269,11 @@
 : detail::ebo_functor_holder<typename Config::equal>(e)//equal()
 , bucket_hash(::boost::forward<BucketTraits>(b_traits), h)
 {}
+
+ template<class T>
+ void set_cache(T)
+ {}
+
 bucket_hash_t<Config> bucket_hash;
};

@@ -285,6 +292,10 @@
 : detail::ebo_functor_holder<typename Config::equal>(e) //equal()
 , bucket_hash(::boost::forward<BucketTraits>(b_traits), h)
 {}
+
+ void set_cache(const bucket_ptr & c)
+ { cached_begin_ = c; }
+
 bucket_hash_t<Config> bucket_hash;
 bucket_ptr cached_begin_;
};
@@ -344,16 +355,11 @@
 typedef typename reduced_node_traits::node slist_node;
 typedef circular_slist_algorithms<group_traits> group_algorithms;

- static node_ptr dcast_bucket_ptr(slist_node_ptr p)
- {
-// This still fails in gcc < 4.4 so forget about it
-// using ::boost::static_pointer_cast;
-// return static_pointer_cast<node>(p);
- return node_ptr(&static_cast<node&>(*p));
- }
+ static node_ptr dcast_bucket_ptr(const slist_node_ptr &p)
+ { return pointer_traits<node_ptr>::pointer_to(static_cast<node&>(*p)); }

- static slist_node_ptr priv_get_bucket_before_begin
- (slist_node_ptr bucket_beg, slist_node_ptr bucket_end, node_ptr p)
+ static slist_node_ptr get_bucket_before_begin
+ (const slist_node_ptr &bucket_beg, const slist_node_ptr &bucket_end, const node_ptr &p)
 {
 //First find the last node of p's group.
 //This requires checking the first node of the next group or
@@ -384,7 +390,7 @@
 return possible_end;
 }

- static node_ptr priv_get_prev_to_first_in_group(slist_node_ptr bucket_node, node_ptr first_in_group)
+ static node_ptr get_prev_to_first_in_group(const slist_node_ptr &bucket_node, const node_ptr &first_in_group)
 {
 //Just iterate using group links and obtain the node
 //before "first_in_group)"
@@ -397,7 +403,7 @@
 return prev_node;
 }

- static node_ptr priv_get_first_in_group_of_last_in_group(node_ptr last_in_group)
+ static node_ptr get_first_in_group_of_last_in_group(const node_ptr &last_in_group)
 {
 //Just iterate using group links and obtain the node
 //before "last_in_group"
@@ -413,8 +419,7 @@
 return possible_first;
 }

-
- static void priv_erase_from_group(slist_node_ptr end_ptr, node_ptr to_erase_ptr, detail::true_)
+ static void erase_from_group(const slist_node_ptr &end_ptr, const node_ptr &to_erase_ptr, detail::true_)
 {
 node_ptr nxt_ptr(node_traits::get_next(to_erase_ptr));
 node_ptr prev_in_group_ptr(group_traits::get_next(to_erase_ptr));
@@ -430,7 +435,7 @@
 }
 else if(last_in_group){
 node_ptr first_in_group =
- priv_get_first_in_group_of_last_in_group(to_erase_ptr);
+ get_first_in_group_of_last_in_group(to_erase_ptr);
 group_algorithms::unlink_after(first_in_group);
 }
 else{
@@ -438,14 +443,87 @@
 }
 }

- static void priv_erase_from_group(slist_node_ptr, node_ptr, detail::false_)
+ static void erase_from_group(const slist_node_ptr&, const node_ptr&, detail::false_)
 {}

- static node_ptr priv_get_last_in_group(node_ptr first_in_group, detail::true_)
+ static node_ptr get_last_in_group(const node_ptr &first_in_group, detail::true_)
 { return group_traits::get_next(first_in_group); }

- static node_ptr priv_get_last_in_group(node_ptr n, detail::false_)
+ static node_ptr get_last_in_group(const node_ptr &n, detail::false_)
 { return n; }
+
+ static void init_group(const node_ptr &n, true_)
+ { group_algorithms::init(n); }
+
+ static void init_group(const node_ptr &, false_)
+ {}
+
+ static void insert_in_group(const node_ptr &first_in_group, const node_ptr &n, true_)
+ {
+ if(first_in_group){
+ if(group_algorithms::unique(first_in_group))
+ group_algorithms::link_after(first_in_group, n);
+ else{
+ group_algorithms::link_after(group_algorithms::node_traits::get_next(first_in_group), n);
+ }
+ }
+ else{
+ group_algorithms::init_header(n);
+ }
+ }
+
+ static slist_node_ptr get_previous_and_next_in_group
+ ( const slist_node_ptr &i, node_ptr &nxt_in_group
+ //If first_end_ptr == last_end_ptr, then first_end_ptr is the bucket of i
+ //Otherwise first_end_ptr is the first bucket and last_end_ptr the last one.
+ , const slist_node_ptr &first_end_ptr, const slist_node_ptr &last_end_ptr)
+ {
+ slist_node_ptr prev;
+ node_ptr elem(dcast_bucket_ptr(i));
+
+ //It's the last in group if the next_node is a bucket
+ slist_node_ptr nxt(node_traits::get_next(elem));
+ bool last_in_group = (first_end_ptr <= nxt && nxt <= last_end_ptr)/* ||
+ (group_traits::get_next(nxt) != elem)*/;
+ //It's the first in group if group_previous's next_node is not
+ //itself, as group list does not link bucket
+ node_ptr prev_in_group(group_traits::get_next(elem));
+ bool first_in_group = node_traits::get_next(prev_in_group) != elem;
+
+ if(first_in_group){
+ node_ptr start_pos;
+ if(last_in_group){
+ start_pos = elem;
+ nxt_in_group = node_ptr();
+ }
+ else{
+ start_pos = prev_in_group;
+ nxt_in_group = node_traits::get_next(elem);
+ }
+ slist_node_ptr bucket_node;
+ if(first_end_ptr != last_end_ptr){
+ bucket_node = group_functions::get_bucket_before_begin
+ (first_end_ptr, last_end_ptr, start_pos);
+ }
+ else{
+ bucket_node = first_end_ptr;
+ }
+ prev = group_functions::get_prev_to_first_in_group(bucket_node, elem);
+ }
+ else{
+ if(last_in_group){
+ nxt_in_group = group_functions::get_first_in_group_of_last_in_group(elem);
+ }
+ else{
+ nxt_in_group = node_traits::get_next(elem);
+ }
+ prev = group_traits::get_next(elem);
+ }
+ return prev;
+ }
+
+ static void insert_in_group(const node_ptr&, const node_ptr&, false_)
+ {}
};

template<class BucketType, class SplitTraits>
@@ -486,6 +564,16 @@
 bool released_;
};

+template<class NodeTraits>
+struct node_functions
+{
+ static void store_hash(typename NodeTraits::node_ptr p, std::size_t h, true_)
+ { return NodeTraits::set_hash(p, h); }
+
+ static void store_hash(typename NodeTraits::node_ptr, std::size_t, false_)
+ {}
+};
+
} //namespace detail {

//!This metafunction will obtain the type of a bucket
@@ -620,27 +708,30 @@

 typedef typename real_value_traits::pointer pointer;
 typedef typename real_value_traits::const_pointer const_pointer;
- typedef typename real_value_traits::value_type value_type;
- typedef typename std::iterator_traits<pointer>::reference reference;
- typedef typename std::iterator_traits<const_pointer>::reference const_reference;
- typedef typename std::iterator_traits<pointer>::difference_type difference_type;
+ typedef typename real_value_traits::value_type value_type;
+ typedef typename pointer_traits<pointer>::reference reference;
+ typedef typename pointer_traits<const_pointer>::reference const_reference;
+ typedef typename pointer_traits<pointer>::difference_type difference_type;
 typedef typename Config::size_type size_type;
 typedef value_type key_type;
 typedef typename Config::equal key_equal;
 typedef typename Config::hash hasher;
 typedef detail::bucket_impl<slist_impl> bucket_type;
- typedef typename boost::pointer_to_other
- <pointer, bucket_type>::type bucket_ptr;
+ typedef typename pointer_traits
+ <pointer>::template rebind_pointer
+ < bucket_type >::type bucket_ptr;
 typedef typename slist_impl::iterator siterator;
 typedef typename slist_impl::const_iterator const_siterator;
 typedef detail::hashtable_iterator<hashtable_impl, false> iterator;
 typedef detail::hashtable_iterator<hashtable_impl, true> const_iterator;
 typedef typename real_value_traits::node_traits node_traits;
 typedef typename node_traits::node node;
- typedef typename boost::pointer_to_other
- <pointer, node>::type node_ptr;
- typedef typename boost::pointer_to_other
- <node_ptr, const node>::type const_node_ptr;
+ typedef typename pointer_traits
+ <pointer>::template rebind_pointer
+ < node >::type node_ptr;
+ typedef typename pointer_traits
+ <pointer>::template rebind_pointer
+ < const node >::type const_node_ptr;
 typedef typename slist_impl::node_algorithms node_algorithms;

 static const bool stateful_value_traits = detail::is_stateful_value_traits<real_value_traits>::value;
@@ -664,8 +755,9 @@
 BOOST_STATIC_ASSERT((!compare_hash || store_hash));

 typedef typename slist_impl::node_ptr slist_node_ptr;
- typedef typename boost::pointer_to_other
- <slist_node_ptr, void>::type void_pointer;
+ typedef typename pointer_traits
+ <slist_node_ptr>::template rebind_pointer
+ < void >::type void_pointer;
 //We'll define group traits, but these won't be instantiated if
 //optimize_multikey is not true
 typedef unordered_group_adapter<node_traits> group_traits;
@@ -677,6 +769,7 @@
 typedef detail::size_holder<constant_time_size, size_type> size_traits;
 typedef detail::size_holder<incremental, size_type> split_traits;
 typedef detail::group_functions<node_traits> group_functions_t;
+ typedef detail::node_functions<node_traits> node_functions_t;

 static const std::size_t hashtable_data_bool_flags_mask =
 ( detail::hash_bool_flags::cache_begin_pos
@@ -721,7 +814,9 @@
 { return base_t::operator()(static_cast<const node &>(to_clone)); }

 void operator()(typename slist_impl::node_ptr to_clone)
- { base_t::operator()(node_ptr(&static_cast<node &>(*to_clone))); }
+ {
+ base_t::operator()(pointer_traits<node_ptr>::pointer_to(static_cast<node &>(*to_clone)));
+ }
 };

 private:
@@ -757,16 +852,16 @@

 /// @cond

- const real_value_traits &get_real_value_traits(detail::bool_<false>) const
+ const real_value_traits &get_real_value_traits(detail::false_) const
 { return this->data_; }

- const real_value_traits &get_real_value_traits(detail::bool_<true>) const
+ const real_value_traits &get_real_value_traits(detail::true_) const
 { return data_.get_value_traits(*this); }

- real_value_traits &get_real_value_traits(detail::bool_<false>)
+ real_value_traits &get_real_value_traits(detail::false_)
 { return this->data_; }

- real_value_traits &get_real_value_traits(detail::bool_<true>)
+ real_value_traits &get_real_value_traits(detail::true_)
 { return data_.get_value_traits(*this); }

 /// @endcond
@@ -931,7 +1026,7 @@
 }
 else{
 size_type buckets_len = this->priv_buckets_len();
- const bucket_type *b = detail::boost_intrusive_get_pointer(this->priv_buckets());
+ const bucket_type *b = boost::intrusive::detail::to_raw_pointer(this->priv_buckets());
 for (size_type n = 0; n < buckets_len; ++n, ++b){
 if(!b->empty()){
 return false;
@@ -954,7 +1049,7 @@
 else{
 size_type len = 0;
 size_type buckets_len = this->priv_buckets_len();
- const bucket_type *b = detail::boost_intrusive_get_pointer(this->priv_buckets());
+ const bucket_type *b = boost::intrusive::detail::to_raw_pointer(this->priv_buckets());
 for (size_type n = 0; n < buckets_len; ++n, ++b){
 len += b->size();
 }
@@ -1258,12 +1353,12 @@
 size_type bucket_num = priv_hash_to_bucket(commit_data.hash);
 bucket_type &b = this->priv_buckets()[bucket_num];
 this->priv_size_traits().increment();
- node_ptr n = node_ptr(&priv_value_to_node(value));
- this->priv_store_hash(n, commit_data.hash, store_hash_t());
+ node_ptr n = pointer_traits<node_ptr>::pointer_to(priv_value_to_node(value));
+ node_functions_t::store_hash(n, commit_data.hash, store_hash_t());
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(n));
 priv_insertion_update_cache(bucket_num);
- this->priv_insert_in_group(node_ptr(0), n, optimize_multikey_t());
+ group_functions_t::insert_in_group(node_ptr(), n, optimize_multikey_t());
 return iterator(b.insert_after(b.before_begin(), *n), this);
 }

@@ -1442,7 +1537,7 @@
 }
 else if(optimize_multikey){
 siterator last = bucket_type::s_iterator_to
- (*node_traits::get_next(group_functions_t::priv_get_last_in_group
+ (*node_traits::get_next(group_functions_t::get_last_in_group
 (dcast_bucket_ptr(it.pointed_node()), optimize_multikey_t())));
 this->priv_erase_range_impl(bucket_num, prev, last, disposer, count);
 }
@@ -2012,7 +2107,7 @@
 if(cache_begin && new_n < new_first_bucket_num)
 new_first_bucket_num = new_n;
 siterator last = bucket_type::s_iterator_to
- (*group_functions_t::priv_get_last_in_group
+ (*group_functions_t::get_last_in_group
 (dcast_bucket_ptr(i.pointed_node()), optimize_multikey_t()));
 if(same_buffer && new_n == n){
 before_i = last;
@@ -2086,7 +2181,7 @@
 const std::size_t hash_value = this->priv_stored_or_compute_hash(v, store_hash_t());
 const size_type new_n = priv_hash_to_bucket(hash_value);
 siterator last = bucket_type::s_iterator_to
- (*group_functions_t::priv_get_last_in_group
+ (*group_functions_t::get_last_in_group
 (dcast_bucket_ptr(i.pointed_node()), optimize_multikey_t()));
 if(new_n == bucket_to_rehash){
 before_i = last;
@@ -2234,10 +2329,10 @@
 return bucket_number;
 }

- std::size_t priv_hash_to_bucket_impl(std::size_t hash_value, std::size_t bucket_len, detail::bool_<false>) const
+ std::size_t priv_hash_to_bucket_impl(std::size_t hash_value, std::size_t bucket_len, detail::false_) const
 { return hash_value % bucket_len; }

- std::size_t priv_hash_to_bucket_impl(std::size_t hash_value, std::size_t bucket_len, detail::bool_<true>) const
+ std::size_t priv_hash_to_bucket_impl(std::size_t hash_value, std::size_t bucket_len, detail::true_) const
 { return hash_value & (bucket_len - 1); }

 const key_equal &priv_equal() const
@@ -2258,16 +2353,16 @@
 const value_type &priv_value_from_slist_node(slist_node_ptr n) const
 { return *this->get_real_value_traits().to_value_ptr(dcast_bucket_ptr(n)); }

- const real_bucket_traits &priv_real_bucket_traits(detail::bool_<false>) const
+ const real_bucket_traits &priv_real_bucket_traits(detail::false_) const
 { return this->data_.internal_.bucket_hash_equal_.bucket_hash.bucket_plus_size_.bucket_traits_; }

- const real_bucket_traits &priv_real_bucket_traits(detail::bool_<true>) const
+ const real_bucket_traits &priv_real_bucket_traits(detail::true_) const
 { return this->data_.internal_.bucket_hash_equal_.bucket_hash.bucket_plus_size_.bucket_traits_.get_bucket_traits(*this); }

- real_bucket_traits &priv_real_bucket_traits(detail::bool_<false>)
+ real_bucket_traits &priv_real_bucket_traits(detail::false_)
 { return this->data_.internal_.bucket_hash_equal_.bucket_hash.bucket_plus_size_.bucket_traits_; }

- real_bucket_traits &priv_real_bucket_traits(detail::bool_<true>)
+ real_bucket_traits &priv_real_bucket_traits(detail::true_)
 { return this->data_.internal_.bucket_hash_equal_.bucket_hash.bucket_plus_size_.bucket_traits_.get_bucket_traits(*this); }

 const real_bucket_traits &priv_real_bucket_traits() const
@@ -2294,8 +2389,8 @@
 size_type priv_buckets_len() const
 { return this->priv_real_bucket_traits().bucket_count(); }

- static node_ptr uncast(const_node_ptr ptr)
- { return node_ptr(const_cast<node*>(detail::boost_intrusive_get_pointer(ptr))); }
+ static node_ptr uncast(const const_node_ptr & ptr)
+ { return node_ptr(const_cast<node*>(boost::intrusive::detail::to_raw_pointer(ptr))); }

 node &priv_value_to_node(value_type &v)
 { return *this->get_real_value_traits().to_node_ptr(v); }
@@ -2331,7 +2426,7 @@
 ++to_erase;
 slist_node_ptr end_ptr = end.pointed_node();
 while(to_erase != end){
- group_functions_t::priv_erase_from_group(end_ptr, dcast_bucket_ptr(to_erase.pointed_node()), optimize_multikey_t());
+ group_functions_t::erase_from_group(end_ptr, 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;
 }
@@ -2353,7 +2448,7 @@
 ++nxt;
 siterator end(b.end());
 while(nxt != end){
- priv_init_group(nxt.pointed_node(), optimize_multikey_t());
+ group_functions_t::init_group(dcast_bucket_ptr(nxt.pointed_node()), optimize_multikey_t());
 nxt = b.erase_after_and_dispose
 (b_begin, make_node_disposer(disposer));
 this->priv_size_traits().decrement();
@@ -2381,12 +2476,7 @@
 }

 static node_ptr dcast_bucket_ptr(typename slist_impl::node_ptr p)
- {
-// This still fails in gcc < 4.4 so forget about it
-// using ::boost::static_pointer_cast;
-// return static_pointer_cast<node>(p);
- return node_ptr(&static_cast<node&>(*p));
- }
+ { return pointer_traits<node_ptr>::pointer_to(static_cast<node&>(*p)); }

 std::size_t priv_stored_or_compute_hash(const value_type &v, detail::true_) const
 { return node_traits::get_hash(this->get_real_value_traits().to_node_ptr(v)); }
@@ -2404,12 +2494,6 @@
 return 0;
 }

- static void priv_store_hash(node_ptr p, std::size_t h, detail::true_)
- { return node_traits::set_hash(p, h); }
-
- static void priv_store_hash(node_ptr, std::size_t, detail::false_)
- {}
-
 static void priv_clear_group_nodes(bucket_type &b, detail::true_)
 {
 siterator it(b.begin()), itend(b.end());
@@ -2438,7 +2522,7 @@
 std::size_t priv_get_bucket_num_no_hash_store(siterator it, detail::true_)
 {
 bucket_ptr f(priv_buckets()), l(f + priv_buckets_len() - 1);
- slist_node_ptr bb = group_functions_t::priv_get_bucket_before_begin
+ slist_node_ptr bb = group_functions_t::get_bucket_before_begin
 ( f->end().pointed_node()
 , l->end().pointed_node()
 , dcast_bucket_ptr(it.pointed_node()));
@@ -2468,29 +2552,6 @@
 return static_cast<std::size_t>(&b - &*f);
 }

- void priv_init_group(slist_node_ptr n, detail::true_)
- { group_algorithms::init(dcast_bucket_ptr(n)); }
-
- void priv_init_group(slist_node_ptr, detail::false_)
- {}
-
- void priv_insert_in_group(node_ptr first_in_group, node_ptr n, detail::true_)
- {
- if(first_in_group){
- if(group_algorithms::unique(first_in_group))
- group_algorithms::link_after(first_in_group, n);
- else{
- group_algorithms::link_after(node_traits::get_next(first_in_group), n);
- }
- }
- else{
- group_algorithms::init_header(n);
- }
- }
-
- void priv_insert_in_group(node_ptr, node_ptr, detail::false_)
- {}
-
 siterator priv_get_previous
 (bucket_type &b, siterator i)
 { return priv_get_previous(b, i, optimize_multikey_t()); }
@@ -2502,7 +2563,7 @@
 node_ptr prev_in_group(group_traits::get_next(elem));
 bool first_in_group = node_traits::get_next(prev_in_group) != elem;
 typename bucket_type::node &n = first_in_group
- ? *group_functions_t::priv_get_prev_to_first_in_group(b.end().pointed_node(), elem)
+ ? *group_functions_t::get_prev_to_first_in_group(b.end().pointed_node(), elem)
 : *group_traits::get_next(elem)
 ;
 return bucket_type::s_iterator_to(n);
@@ -2533,7 +2594,7 @@

 static siterator priv_get_last(bucket_type &b, detail::false_)
 { return b.previous(b.end()); }
-
+/*
 siterator priv_get_previous_and_next_in_group
 (siterator i, node_ptr &nxt_in_group)
 {
@@ -2554,7 +2615,7 @@
 node_ptr start_pos;
 if(last_in_group){
 start_pos = elem;
- nxt_in_group = 0;
+ nxt_in_group = node_ptr();
 }
 else{
 start_pos = prev_in_group;
@@ -2568,15 +2629,15 @@
 ].before_begin().pointed_node();
 }
 else{
- bucket_node = group_functions_t::priv_get_bucket_before_begin
+ bucket_node = group_functions_t::get_bucket_before_begin
 (first_end_ptr, last_end_ptr, start_pos);
 }
 prev = bucket_type::s_iterator_to
- (*group_functions_t::priv_get_prev_to_first_in_group(bucket_node, elem));
+ (*group_functions_t::get_prev_to_first_in_group(bucket_node, elem));
 }
 else{
 if(last_in_group){
- nxt_in_group = group_functions_t::priv_get_first_in_group_of_last_in_group(elem);
+ nxt_in_group = group_functions_t::get_first_in_group_of_last_in_group(elem);
 }
 else{
 nxt_in_group = node_traits::get_next(elem);
@@ -2585,7 +2646,9 @@
 }
 return prev;
 }
+*/

+/*
 template<class Disposer>
 void priv_erase(const_iterator i, Disposer disposer, detail::true_)
 {
@@ -2598,6 +2661,47 @@
 if(safemode_or_autounlink)
 group_algorithms::init(dcast_bucket_ptr(elem.pointed_node()));
 }
+*/
+
+/*
+ if(store_hash){
+ bucket_node = this->priv_buckets()
+ [this->priv_hash_to_bucket
+ (this->priv_stored_hash(elem, store_hash_t()))
+ ].before_begin().pointed_node();
+ }
+ else{
+ bucket_node = group_functions_t::get_bucket_before_begin
+ (first_end_ptr, last_end_ptr, start_pos);
+ }
+*/
+ template<class Disposer>
+ void priv_erase(const_iterator i, Disposer disposer, detail::true_)
+ {
+ slist_node_ptr elem(i.slist_it().pointed_node());
+ slist_node_ptr f_bucket_end, l_bucket_end;
+ if(store_hash){
+ f_bucket_end = l_bucket_end =
+ (this->priv_buckets()
+ [this->priv_hash_to_bucket
+ (this->priv_stored_hash(elem, store_hash_t()))
+ ]).before_begin().pointed_node();
+ }
+ else{
+ f_bucket_end = this->priv_buckets()->cend().pointed_node();
+ l_bucket_end = f_bucket_end + priv_buckets_len() - 1;
+ }
+ node_ptr nxt_in_group;
+ siterator prev = bucket_type::s_iterator_to
+ (*group_functions_t::get_previous_and_next_in_group
+ ( elem, nxt_in_group, f_bucket_end, l_bucket_end)
+ );
+ bucket_type::s_erase_after_and_dispose(prev, make_node_disposer(disposer));
+ if(nxt_in_group)
+ group_algorithms::unlink_after(nxt_in_group);
+ if(safemode_or_autounlink)
+ group_algorithms::init(dcast_bucket_ptr(elem));
+ }

 template <class Disposer>
 void priv_erase(const_iterator i, Disposer disposer, detail::false_)
@@ -2620,7 +2724,7 @@
 siterator priv_begin() const
 { return priv_begin(cache_begin_t()); }

- siterator priv_begin(detail::bool_<false>) const
+ siterator priv_begin(detail::false_) const
 {
 size_type n = 0;
 size_type buckets_len = this->priv_buckets_len();
@@ -2633,7 +2737,7 @@
 return priv_invalid_local_it();
 }

- siterator priv_begin(detail::bool_<true>) const
+ siterator priv_begin(detail::true_) const
 {
 if(this->data_.internal_.bucket_hash_equal_.cached_begin_ == priv_invalid_bucket()){
 return priv_invalid_local_it();
@@ -2646,16 +2750,16 @@
 void priv_initialize_cache()
 { priv_initialize_cache(cache_begin_t()); }

- void priv_initialize_cache(detail::bool_<true>)
+ void priv_initialize_cache(detail::true_)
 { this->data_.internal_.bucket_hash_equal_.cached_begin_ = priv_invalid_bucket(); }

- void priv_initialize_cache(detail::bool_<false>)
+ void priv_initialize_cache(detail::false_)
 {}

 void priv_insertion_update_cache(size_type insertion_bucket)
 { priv_insertion_update_cache(insertion_bucket, cache_begin_t()); }

- void priv_insertion_update_cache(size_type insertion_bucket, detail::bool_<true>)
+ void priv_insertion_update_cache(size_type insertion_bucket, detail::true_)
 {
 bucket_ptr p = priv_buckets() + insertion_bucket;
 if(p < this->data_.internal_.bucket_hash_equal_.cached_begin_){
@@ -2663,13 +2767,13 @@
 }
 }

- void priv_insertion_update_cache(size_type, detail::bool_<false>)
+ void priv_insertion_update_cache(size_type, detail::false_)
 {}

 void priv_erasure_update_cache(size_type first_bucket, size_type last_bucket)
 { priv_erasure_update_cache(first_bucket, last_bucket, cache_begin_t()); }

- void priv_erasure_update_cache(size_type first_bucket_num, size_type last_bucket_num, detail::bool_<true>)
+ void priv_erasure_update_cache(size_type first_bucket_num, size_type last_bucket_num, detail::true_)
 {
 //If the last bucket is the end, the cache must be updated
 //to the last position if all
@@ -2680,13 +2784,13 @@
 }
 }

- void priv_erasure_update_cache(size_type, size_type, detail::bool_<false>)
+ void priv_erasure_update_cache(size_type, size_type, detail::false_)
 {}

 void priv_erasure_update_cache()
 { priv_erasure_update_cache(cache_begin_t()); }

- void priv_erasure_update_cache(detail::bool_<true>)
+ void priv_erasure_update_cache(detail::true_)
 {
 if(constant_time_size && !size()){
 priv_initialize_cache();
@@ -2704,43 +2808,37 @@
 }
 }

- void priv_erasure_update_cache(detail::bool_<false>)
+ void priv_erasure_update_cache(detail::false_)
 {}

- void priv_swap_cache(detail::bool_<true>, hashtable_impl &other)
+ void priv_swap_cache(detail::true_, hashtable_impl &other)
 {
 std::swap( this->data_.internal_.bucket_hash_equal_.cached_begin_
 , other.data_.internal_.bucket_hash_equal_.cached_begin_);
 }

- void priv_swap_cache(detail::bool_<false>, hashtable_impl &)
+ void priv_swap_cache(detail::false_, hashtable_impl &)
 {}

 bucket_ptr priv_get_cache()
 { return priv_get_cache(cache_begin_t()); }

- bucket_ptr priv_get_cache(detail::bool_<true>)
+ bucket_ptr priv_get_cache(detail::true_)
 { return this->data_.internal_.bucket_hash_equal_.cached_begin_; }

- bucket_ptr priv_get_cache(detail::bool_<false>)
+ bucket_ptr priv_get_cache(detail::false_)
 { return this->priv_buckets(); }

- void priv_set_cache(bucket_ptr p)
- { priv_set_cache(p, cache_begin_t()); }
-
- void priv_set_cache(bucket_ptr p, detail::bool_<true>)
- { this->data_.internal_.bucket_hash_equal_.cached_begin_ = p; }
-
- void priv_set_cache(bucket_ptr, detail::bool_<false>)
- {}
+ void priv_set_cache(const bucket_ptr &p)
+ { this->data_.internal_.bucket_hash_equal_.set_cache(p); }

 size_type priv_get_cache_bucket_num()
 { return priv_get_cache_bucket_num(cache_begin_t()); }

- size_type priv_get_cache_bucket_num(detail::bool_<true>)
+ size_type priv_get_cache_bucket_num(detail::true_)
 { return this->data_.internal_.bucket_hash_equal_.cached_begin_ - this->priv_buckets(); }

- size_type priv_get_cache_bucket_num(detail::bool_<false>)
+ size_type priv_get_cache_bucket_num(detail::false_)
 { return 0u; }

 void priv_clear_buckets()
@@ -2803,7 +2901,7 @@
 }
 if(optimize_multikey){
 previt = bucket_type::s_iterator_to
- (*group_functions_t::priv_get_last_in_group
+ (*group_functions_t::get_last_in_group
 (dcast_bucket_ptr(it.pointed_node()), optimize_multikey_t()));
 it = previt;
 }
@@ -2833,16 +2931,16 @@
 it = b.before_begin();
 }
 //Now store hash if needed
- node_ptr n = node_ptr(&priv_value_to_node(value));
- this->priv_store_hash(n, hash_value, store_hash_t());
+ node_ptr n = pointer_traits<node_ptr>::pointer_to(priv_value_to_node(value));
+ node_functions_t::store_hash(n, hash_value, store_hash_t());
 //Checks for some modes
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(n));
 //Shorcut for optimize_multikey cases
 if(optimize_multikey){
 node_ptr first_in_group = found_equal ?
- dcast_bucket_ptr(it.pointed_node()) : node_ptr(0);
- this->priv_insert_in_group(first_in_group, n, optimize_multikey_t());
+ dcast_bucket_ptr(it.pointed_node()) : node_ptr();
+ group_functions_t::insert_in_group(first_in_group, n, optimize_multikey_t());
 }
 //Update cache and increment size if needed
 priv_insertion_update_cache(bucket_num);
@@ -2877,7 +2975,7 @@
 siterator it = to_return.first;
 if(optimize_multikey){
 to_return.second = bucket_type::s_iterator_to
- (*node_traits::get_next(group_functions_t::priv_get_last_in_group
+ (*node_traits::get_next(group_functions_t::get_last_in_group
 (dcast_bucket_ptr(it.pointed_node()), optimize_multikey_t())));
 count = std::distance(it, to_return.second);
 if(to_return.second != b.end()){

Modified: branches/release/boost/intrusive/linear_slist_algorithms.hpp
==============================================================================
--- branches/release/boost/intrusive/linear_slist_algorithms.hpp (original)
+++ branches/release/boost/intrusive/linear_slist_algorithms.hpp 2011-12-26 12:10:27 EST (Mon, 26 Dec 2011)
@@ -62,18 +62,18 @@

 //! Effects: Constructs an non-used list element, putting the next
 //! pointer to null:
- //! <tt>NodeTraits::get_next(this_node) == 0
+ //! <tt>NodeTraits::get_next(this_node) == node_ptr()</tt>
 //!
 //! Complexity: Constant
 //!
 //! Throws: Nothing.
- static void init(node_ptr this_node);
+ static void init(const node_ptr & this_node);

 //! Requires: this_node must be in a circular list or be an empty circular list.
 //!
 //! Effects: Returns true is "this_node" is the only node of a circular list:
 //! or it's a not inserted node:
- //! <tt>return !NodeTraits::get_next(this_node) || NodeTraits::get_next(this_node) == this_node</tt>
+ //! <tt>return false == NodeTraits::get_next(this_node) || NodeTraits::get_next(this_node) == this_node</tt>
 //!
 //! Complexity: Constant
 //!
@@ -95,7 +95,7 @@
 //! Complexity: Constant
 //!
 //! Throws: Nothing.
- static void unlink_after(node_ptr prev_node);
+ static void unlink_after(const node_ptr & prev_node);

 //! Requires: prev_node and last_node must be in a circular list
 //! or be an empty circular list.
@@ -105,7 +105,7 @@
 //! Complexity: Constant
 //!
 //! Throws: Nothing.
- static void unlink_after(node_ptr prev_node, node_ptr last_node);
+ static void unlink_after(const node_ptr & prev_node, const node_ptr & last_node);

 //! Requires: prev_node must be a node of a linear list.
 //!
@@ -114,7 +114,7 @@
 //! Complexity: Constant
 //!
 //! Throws: Nothing.
- static void link_after(node_ptr prev_node, node_ptr this_node);
+ static void link_after(const node_ptr & prev_node, const node_ptr & this_node);

 //! Requires: b and e must be nodes of the same linear list or an empty range.
 //! and p must be a node of a different linear list.
@@ -125,7 +125,7 @@
 //! Complexity: Constant
 //!
 //! Throws: Nothing.
- static void transfer_after(node_ptr p, node_ptr b, node_ptr e);
+ static void transfer_after(const node_ptr & p, const node_ptr & b, const node_ptr & e);

 #endif //#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)

@@ -136,8 +136,8 @@
 //! Complexity: Constant
 //!
 //! Throws: Nothing.
- static void init_header(node_ptr this_node)
- { NodeTraits::set_next(this_node, node_ptr(0)); }
+ static void init_header(const node_ptr & this_node)
+ { NodeTraits::set_next(this_node, node_ptr ()); }

 //! Requires: this_node and prev_init_node must be in the same linear list.
 //!
@@ -148,7 +148,7 @@
 //! Complexity: Linear to the number of elements between prev_init_node and this_node.
 //!
 //! Throws: Nothing.
- static node_ptr get_previous_node(node_ptr prev_init_node, node_ptr this_node)
+ static node_ptr get_previous_node(const node_ptr & prev_init_node, const node_ptr & this_node)
 { return base_t::get_previous_node(prev_init_node, this_node); }

 //! Requires: this_node must be in a linear list or be an empty linear list.
@@ -159,7 +159,7 @@
 //! Complexity: Linear
 //!
 //! Throws: Nothing.
- static std::size_t count(const_node_ptr this_node)
+ static std::size_t count(const const_node_ptr & this_node)
 {
 std::size_t result = 0;
 const_node_ptr p = this_node;
@@ -179,7 +179,7 @@
 //! Complexity: Constant
 //!
 //! Throws: Nothing.
- static void swap_trailing_nodes(node_ptr this_node, node_ptr other_node)
+ static void swap_trailing_nodes(const node_ptr & this_node, const node_ptr & other_node)
 {
 node_ptr this_nxt = NodeTraits::get_next(this_node);
 node_ptr other_nxt = NodeTraits::get_next(other_node);
@@ -194,9 +194,9 @@
 //! Throws: Nothing.
 //!
 //! Complexity: This function is linear to the contained elements.
- static node_ptr reverse(node_ptr p)
+ static node_ptr reverse(const node_ptr & p)
 {
- if(!p) return node_ptr(0);
+ if(!p) return node_ptr();
 node_ptr i = NodeTraits::get_next(p);
 node_ptr first(p);
 while(i){
@@ -217,9 +217,9 @@
 //! Throws: Nothing.
 //!
 //! Complexity: Linear to the number of elements plus the number moved positions.
- static std::pair<node_ptr, node_ptr> move_first_n_backwards(node_ptr p, std::size_t n)
+ static std::pair<node_ptr, node_ptr> move_first_n_backwards(const node_ptr & p, std::size_t n)
 {
- std::pair<node_ptr, node_ptr> ret(node_ptr(0), node_ptr(0));
+ std::pair<node_ptr, node_ptr> ret;
 //Null shift, or count() == 0 or 1, nothing to do
 if(!n || !p || !NodeTraits::get_next(p)){
 return ret;
@@ -227,8 +227,8 @@

 node_ptr first = p;
 bool end_found = false;
- node_ptr new_last(0);
- node_ptr old_last(0);
+ node_ptr new_last = node_ptr();
+ node_ptr old_last = node_ptr();

 //Now find the new last node according to the shift count.
 //If we find 0 before finding the new last node
@@ -237,7 +237,7 @@
 for(std::size_t i = 1; i <= n; ++i){
 new_last = first;
 first = NodeTraits::get_next(first);
- if(first == 0){
+ if(first == node_ptr()){
 //Shortcut the shift with the modulo of the size of the list
 n %= i;
 if(!n) return ret;
@@ -253,12 +253,12 @@
 //If the p has not been found in the previous loop, find it
 //starting in the new first node and unlink it
 if(!end_found){
- old_last = base_t::get_previous_node(first, node_ptr(0));
+ old_last = base_t::get_previous_node(first, node_ptr());
 }

 //Now link p after the new last node
 NodeTraits::set_next(old_last, p);
- NodeTraits::set_next(new_last, node_ptr(0));
+ NodeTraits::set_next(new_last, node_ptr());
 ret.first = first;
 ret.second = new_last;
 return ret;
@@ -272,9 +272,9 @@
 //! Throws: Nothing.
 //!
 //! Complexity: Linear to the number of elements plus the number moved positions.
- static std::pair<node_ptr, node_ptr> move_first_n_forward(node_ptr p, std::size_t n)
+ static std::pair<node_ptr, node_ptr> move_first_n_forward(const node_ptr & p, std::size_t n)
 {
- std::pair<node_ptr, node_ptr> ret(node_ptr(0), node_ptr(0));
+ std::pair<node_ptr, node_ptr> ret;
 //Null shift, or count() == 0 or 1, nothing to do
 if(!n || !p || !NodeTraits::get_next(p))
 return ret;
@@ -312,7 +312,7 @@
 node_ptr new_first(node_traits::get_next(new_last));
 //Now put the old beginning after the old end
 NodeTraits::set_next(old_last, p);
- NodeTraits::set_next(new_last, node_ptr(0));
+ NodeTraits::set_next(new_last, node_ptr());
 ret.first = new_first;
 ret.second = new_last;
 return ret;

Modified: branches/release/boost/intrusive/list.hpp
==============================================================================
--- branches/release/boost/intrusive/list.hpp (original)
+++ branches/release/boost/intrusive/list.hpp 2011-12-26 12:10:27 EST (Mon, 26 Dec 2011)
@@ -19,12 +19,13 @@
#include <boost/intrusive/intrusive_fwd.hpp>
#include <boost/intrusive/list_hook.hpp>
#include <boost/intrusive/circular_list_algorithms.hpp>
-#include <boost/intrusive/detail/pointer_to_other.hpp>
+#include <boost/intrusive/pointer_traits.hpp>
#include <boost/intrusive/detail/clear_on_destructor_base.hpp>
#include <boost/intrusive/detail/mpl.hpp>
#include <boost/intrusive/link_mode.hpp>
#include <boost/static_assert.hpp>
#include <boost/intrusive/options.hpp>
+#include <boost/intrusive/pointer_traits.hpp>
#include <boost/intrusive/detail/utilities.hpp>
#include <iterator>
#include <algorithm>
@@ -91,15 +92,15 @@
 /// @endcond
 typedef typename real_value_traits::pointer pointer;
 typedef typename real_value_traits::const_pointer const_pointer;
- typedef typename std::iterator_traits<pointer>::value_type value_type;
- typedef typename std::iterator_traits<pointer>::reference reference;
- typedef typename std::iterator_traits<const_pointer>::reference const_reference;
- typedef typename std::iterator_traits<pointer>::difference_type difference_type;
+ typedef typename pointer_traits<pointer>::element_type value_type;
+ typedef typename pointer_traits<pointer>::reference reference;
+ typedef typename pointer_traits<const_pointer>::reference const_reference;
+ typedef typename pointer_traits<pointer>::difference_type difference_type;
 typedef typename Config::size_type size_type;
 typedef list_iterator<list_impl, false> iterator;
 typedef list_iterator<list_impl, true> const_iterator;
- typedef std::reverse_iterator<iterator> reverse_iterator;
- typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+ typedef boost::intrusive::detail::reverse_iterator<iterator> reverse_iterator;
+ typedef boost::intrusive::detail::reverse_iterator<const_iterator>const_reverse_iterator;
 typedef typename real_value_traits::node_traits node_traits;
 typedef typename node_traits::node node;
 typedef typename node_traits::node_ptr node_ptr;
@@ -127,17 +128,14 @@
 ));

 //Const cast emulation for smart pointers
- static node_ptr uncast(const_node_ptr ptr)
- {
- return const_cast<node*>(detail::boost_intrusive_get_pointer(ptr));
- //iG pending return node_ptr(boost::const_pointer_cast<node>(ptr));
- }
+ static node_ptr uncast(const const_node_ptr & ptr)
+ { return pointer_traits<node_ptr>::const_cast_from(ptr); }

 node_ptr get_root_node()
- { return node_ptr(&data_.root_plus_size_.root_); }
+ { return pointer_traits<node_ptr>::pointer_to(data_.root_plus_size_.root_); }

 const_node_ptr get_root_node() const
- { return const_node_ptr(&data_.root_plus_size_.root_); }
+ { return pointer_traits<const_node_ptr>::pointer_to(data_.root_plus_size_.root_); }

 struct root_plus_size : public size_traits
 {
@@ -1299,7 +1297,7 @@
 static list_impl &priv_container_from_end_iterator(const const_iterator &end_iterator)
 {
 root_plus_size *r = detail::parent_from_member<root_plus_size, node>
- ( detail::boost_intrusive_get_pointer(end_iterator.pointed_node()), &root_plus_size::root_);
+ ( boost::intrusive::detail::to_raw_pointer(end_iterator.pointed_node()), &root_plus_size::root_);
 data_t *d = detail::parent_from_member<data_t, root_plus_size>
 ( r, &data_t::root_plus_size_);
 list_impl *s = detail::parent_from_member<list_impl, data_t>(d, &list_impl::data_);

Modified: branches/release/boost/intrusive/member_value_traits.hpp
==============================================================================
--- branches/release/boost/intrusive/member_value_traits.hpp (original)
+++ branches/release/boost/intrusive/member_value_traits.hpp 2011-12-26 12:10:27 EST (Mon, 26 Dec 2011)
@@ -16,6 +16,7 @@
#include <boost/intrusive/link_mode.hpp>
#include <iterator>
#include <boost/intrusive/detail/parent_from_member.hpp>
+#include <boost/intrusive/pointer_traits.hpp>

namespace boost {
namespace intrusive {
@@ -29,15 +30,19 @@
struct member_value_traits
{
 public:
- typedef NodeTraits node_traits;
- typedef T value_type;
- typedef typename node_traits::node node;
- typedef typename node_traits::node_ptr node_ptr;
- typedef typename node_traits::const_node_ptr const_node_ptr;
- typedef typename boost::pointer_to_other<node_ptr, T>::type pointer;
- typedef typename boost::pointer_to_other<node_ptr, const T>::type const_pointer;
- typedef typename std::iterator_traits<pointer>::reference reference;
- typedef typename std::iterator_traits<const_pointer>::reference const_reference;
+ typedef NodeTraits node_traits;
+ typedef T value_type;
+ typedef typename node_traits::node node;
+ typedef typename node_traits::node_ptr node_ptr;
+ typedef typename node_traits::const_node_ptr const_node_ptr;
+ typedef typename pointer_traits<node_ptr>::template
+ rebind_pointer<T>::type pointer;
+ typedef typename pointer_traits<node_ptr>::template
+ rebind_pointer<const T>::type const_pointer;
+ //typedef typename pointer_traits<pointer>::reference reference;
+ //typedef typename pointer_traits<const_pointer>::reference const_reference;
+ typedef value_type & reference;
+ typedef const value_type & const_reference;
 static const link_mode_type link_mode = LinkMode;

 static node_ptr to_node_ptr(reference value)
@@ -46,16 +51,16 @@
 static const_node_ptr to_node_ptr(const_reference value)
 { return node_ptr(&(value.*PtrToMember)); }

- static pointer to_value_ptr(node_ptr n)
+ static pointer to_value_ptr(const node_ptr &n)
 {
 return pointer(detail::parent_from_member<value_type, node>
- (detail::boost_intrusive_get_pointer(n), PtrToMember));
+ (boost::intrusive::detail::to_raw_pointer(n), PtrToMember));
 }

- static const_pointer to_value_ptr(const_node_ptr n)
+ static const_pointer to_value_ptr(const const_node_ptr &n)
 {
 return pointer(detail::parent_from_member<value_type, node>
- (detail::boost_intrusive_get_pointer(n), PtrToMember));
+ (boost::intrusive::detail::to_raw_pointer(n), PtrToMember));
 }
};

Modified: branches/release/boost/intrusive/rbtree.hpp
==============================================================================
--- branches/release/boost/intrusive/rbtree.hpp (original)
+++ branches/release/boost/intrusive/rbtree.hpp 2011-12-26 12:10:27 EST (Mon, 26 Dec 2011)
@@ -27,9 +27,10 @@
#include <boost/intrusive/detail/tree_node.hpp>
#include <boost/intrusive/detail/ebo_functor_holder.hpp>
#include <boost/intrusive/detail/mpl.hpp>
-#include <boost/intrusive/detail/pointer_to_other.hpp>
+#include <boost/intrusive/pointer_traits.hpp>
#include <boost/intrusive/detail/clear_on_destructor_base.hpp>
#include <boost/intrusive/detail/function_detector.hpp>
+#include <boost/intrusive/detail/utilities.hpp>
#include <boost/intrusive/options.hpp>
#include <boost/intrusive/rbtree_algorithms.hpp>
#include <boost/intrusive/link_mode.hpp>
@@ -97,18 +98,19 @@
 /// @endcond
 typedef typename real_value_traits::pointer pointer;
 typedef typename real_value_traits::const_pointer const_pointer;
- typedef typename std::iterator_traits<pointer>::value_type value_type;
+
+ typedef typename pointer_traits<pointer>::element_type value_type;
 typedef value_type key_type;
- typedef typename std::iterator_traits<pointer>::reference reference;
- typedef typename std::iterator_traits<const_pointer>::reference const_reference;
- typedef typename std::iterator_traits<pointer>::difference_type difference_type;
+ typedef typename pointer_traits<pointer>::reference reference;
+ typedef typename pointer_traits<const_pointer>::reference const_reference;
+ typedef typename pointer_traits<const_pointer>::difference_type difference_type;
 typedef typename Config::size_type size_type;
 typedef typename Config::compare value_compare;
 typedef value_compare key_compare;
 typedef tree_iterator<rbtree_impl, false> iterator;
 typedef tree_iterator<rbtree_impl, true> const_iterator;
- typedef std::reverse_iterator<iterator> reverse_iterator;
- typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+ typedef boost::intrusive::detail::reverse_iterator<iterator> reverse_iterator;
+ typedef boost::intrusive::detail::reverse_iterator<const_iterator>const_reverse_iterator;
 typedef typename real_value_traits::node_traits node_traits;
 typedef typename node_traits::node node;
 typedef typename node_traits::node_ptr node_ptr;
@@ -163,17 +165,14 @@
 value_traits &priv_value_traits()
 { return data_; }

- const node &priv_header() const
- { return data_.node_plus_pred_.header_plus_size_.header_; }
+ node_ptr priv_header_ptr()
+ { return pointer_traits<node_ptr>::pointer_to(data_.node_plus_pred_.header_plus_size_.header_); }

- node &priv_header()
- { return data_.node_plus_pred_.header_plus_size_.header_; }
+ const_node_ptr priv_header_ptr() const
+ { return pointer_traits<const_node_ptr>::pointer_to(data_.node_plus_pred_.header_plus_size_.header_); }

- static node_ptr uncast(const_node_ptr ptr)
- {
- return node_ptr(const_cast<node*>(detail::boost_intrusive_get_pointer(ptr)));
-//iG pending return node_ptr(boost::const_pointer_cast<node>(ptr));
- }
+ static node_ptr uncast(const const_node_ptr & ptr)
+ { return pointer_traits<node_ptr>::const_cast_from(ptr); }

 size_traits &priv_size_traits()
 { return data_.node_plus_pred_.header_plus_size_; }
@@ -198,10 +197,10 @@
 { return priv_comp(); }

 const node &prot_header_node() const
- { return priv_header(); }
+ { return data_.node_plus_pred_.header_plus_size_.header_; }

 node &prot_header_node()
- { return priv_header(); }
+ { return data_.node_plus_pred_.header_plus_size_.header_; }

 void prot_set_size(size_type s)
 { this->priv_size_traits().set_size(s); }
@@ -229,7 +228,7 @@
 , const value_traits &v_traits = value_traits())
 : data_(cmp, v_traits)
 {
- node_algorithms::init_header(&priv_header());
+ node_algorithms::init_header(this->priv_header_ptr());
 this->priv_size_traits().set_size(size_type(0));
 }

@@ -251,7 +250,7 @@
 , const value_traits &v_traits = value_traits())
 : data_(cmp, v_traits)
 {
- node_algorithms::init_header(&priv_header());
+ node_algorithms::init_header(this->priv_header_ptr());
 this->priv_size_traits().set_size(size_type(0));
 if(unique)
 this->insert_unique(b, e);
@@ -264,7 +263,7 @@
 rbtree_impl(BOOST_RV_REF(rbtree_impl) x)
 : data_(::boost::move(x.priv_comp()), ::boost::move(x.priv_value_traits()))
 {
- node_algorithms::init_header(&priv_header());
+ node_algorithms::init_header(this->priv_header_ptr());
 this->priv_size_traits().set_size(size_type(0));
 this->swap(x);
 }
@@ -290,7 +289,7 @@
 //!
 //! Throws: Nothing.
 iterator begin()
- { return iterator (node_traits::get_left(node_ptr(&priv_header())), this); }
+ { return iterator (node_traits::get_left(this->priv_header_ptr()), this); }

 //! Effects: Returns a const_iterator pointing to the beginning of the tree.
 //!
@@ -306,7 +305,7 @@
 //!
 //! Throws: Nothing.
 const_iterator cbegin() const
- { return const_iterator (node_traits::get_left(const_node_ptr(&priv_header())), this); }
+ { return const_iterator (node_traits::get_left(this->priv_header_ptr()), this); }

 //! Effects: Returns an iterator pointing to the end of the tree.
 //!
@@ -314,7 +313,7 @@
 //!
 //! Throws: Nothing.
 iterator end()
- { return iterator (node_ptr(&priv_header()), this); }
+ { return iterator (this->priv_header_ptr(), this); }

 //! Effects: Returns a const_iterator pointing to the end of the tree.
 //!
@@ -330,7 +329,7 @@
 //!
 //! Throws: Nothing.
 const_iterator cend() const
- { return const_iterator (uncast(const_node_ptr(&priv_header())), this); }
+ { return const_iterator (uncast(this->priv_header_ptr()), this); }

 //! Effects: Returns a reverse_iterator pointing to the beginning of the
 //! reversed tree.
@@ -444,7 +443,7 @@
 //!
 //! Throws: Nothing.
 bool empty() const
- { return node_algorithms::unique(const_node_ptr(&priv_header())); }
+ { return node_algorithms::unique(this->priv_header_ptr()); }

 //! Effects: Returns the number of elements stored in the tree.
 //!
@@ -457,7 +456,7 @@
 if(constant_time_size)
 return this->priv_size_traits().get_size();
 else{
- return (size_type)node_algorithms::size(const_node_ptr(&priv_header()));
+ return (size_type)node_algorithms::size(this->priv_header_ptr());
 }
 }

@@ -472,7 +471,7 @@
 using std::swap;
 swap(priv_comp(), priv_comp());
 //These can't throw
- node_algorithms::swap_tree(node_ptr(&priv_header()), node_ptr(&other.priv_header()));
+ node_algorithms::swap_tree(this->priv_header_ptr(), node_ptr(other.priv_header_ptr()));
 if(constant_time_size){
 size_type backup = this->priv_size_traits().get_size();
 this->priv_size_traits().set_size(other.priv_size_traits().get_size());
@@ -499,7 +498,7 @@
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
 iterator ret(node_algorithms::insert_equal_upper_bound
- (node_ptr(&priv_header()), to_insert, key_node_comp), this);
+ (this->priv_header_ptr(), to_insert, key_node_comp), this);
 this->priv_size_traits().increment();
 return ret;
 }
@@ -526,7 +525,7 @@
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
 iterator ret(node_algorithms::insert_equal
- (node_ptr(&priv_header()), hint.pointed_node(), to_insert, key_node_comp), this);
+ (this->priv_header_ptr(), hint.pointed_node(), to_insert, key_node_comp), this);
 this->priv_size_traits().increment();
 return ret;
 }
@@ -662,7 +661,7 @@
 comp(key_value_comp, this);
 std::pair<node_ptr, bool> ret =
 (node_algorithms::insert_unique_check
- (node_ptr(&priv_header()), key, comp, commit_data));
+ (this->priv_header_ptr(), key, comp, commit_data));
 return std::pair<iterator, bool>(iterator(ret.first, this), ret.second);
 }

@@ -707,7 +706,7 @@
 comp(key_value_comp, this);
 std::pair<node_ptr, bool> ret =
 (node_algorithms::insert_unique_check
- (node_ptr(&priv_header()), hint.pointed_node(), key, comp, commit_data));
+ (this->priv_header_ptr(), hint.pointed_node(), key, comp, commit_data));
 return std::pair<iterator, bool>(iterator(ret.first, this), ret.second);
 }

@@ -734,7 +733,7 @@
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
 node_algorithms::insert_unique_commit
- (node_ptr(&priv_header()), to_insert, commit_data);
+ (this->priv_header_ptr(), to_insert, commit_data);
 this->priv_size_traits().increment();
 return iterator(to_insert, this);
 }
@@ -760,7 +759,7 @@
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
 this->priv_size_traits().increment();
 return iterator(node_algorithms::insert_before
- (node_ptr(&priv_header()), pos.pointed_node(), to_insert), this);
+ (this->priv_header_ptr(), pos.pointed_node(), to_insert), this);
 }

 //! Requires: value must be an lvalue, and it must be no less
@@ -783,7 +782,7 @@
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
 this->priv_size_traits().increment();
- node_algorithms::push_back(node_ptr(&priv_header()), to_insert);
+ node_algorithms::push_back(this->priv_header_ptr(), to_insert);
 }

 //! Requires: value must be an lvalue, and it must be no greater
@@ -806,7 +805,7 @@
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
 this->priv_size_traits().increment();
- node_algorithms::push_front(node_ptr(&priv_header()), to_insert);
+ node_algorithms::push_front(this->priv_header_ptr(), to_insert);
 }

 //! Effects: Erases the element pointed to by pos.
@@ -824,7 +823,7 @@
 node_ptr to_erase(i.pointed_node());
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!node_algorithms::unique(to_erase));
- node_algorithms::erase(&priv_header(), to_erase);
+ node_algorithms::erase(this->priv_header_ptr(), to_erase);
 this->priv_size_traits().decrement();
 if(safemode_or_autounlink)
 node_algorithms::init(to_erase);
@@ -986,7 +985,7 @@
 this->clear_and_dispose(detail::null_disposer());
 }
 else{
- node_algorithms::init_header(&priv_header());
+ node_algorithms::init_header(this->priv_header_ptr());
 this->priv_size_traits().set_size(0);
 }
 }
@@ -1003,9 +1002,9 @@
 template<class Disposer>
 void clear_and_dispose(Disposer disposer)
 {
- node_algorithms::clear_and_dispose(node_ptr(&priv_header())
+ node_algorithms::clear_and_dispose(this->priv_header_ptr()
 , detail::node_disposer<Disposer, rbtree_impl>(disposer, this));
- node_algorithms::init_header(&priv_header());
+ node_algorithms::init_header(this->priv_header_ptr());
 this->priv_size_traits().set_size(0);
 }

@@ -1061,7 +1060,7 @@
 detail::key_nodeptr_comp<KeyValueCompare, rbtree_impl>
 key_node_comp(comp, this);
 return iterator(node_algorithms::lower_bound
- (const_node_ptr(&priv_header()), key, key_node_comp), this);
+ (this->priv_header_ptr(), key, key_node_comp), this);
 }

 //! Effects: Returns a const iterator to the first element whose
@@ -1076,7 +1075,7 @@
 detail::key_nodeptr_comp<KeyValueCompare, rbtree_impl>
 key_node_comp(comp, this);
 return const_iterator(node_algorithms::lower_bound
- (const_node_ptr(&priv_header()), key, key_node_comp), this);
+ (this->priv_header_ptr(), key, key_node_comp), this);
 }

 //! Effects: Returns an iterator to the first element whose
@@ -1101,7 +1100,7 @@
 detail::key_nodeptr_comp<KeyValueCompare, rbtree_impl>
 key_node_comp(comp, this);
 return iterator(node_algorithms::upper_bound
- (const_node_ptr(&priv_header()), key, key_node_comp), this);
+ (this->priv_header_ptr(), key, key_node_comp), this);
 }

 //! Effects: Returns an iterator to the first element whose
@@ -1126,7 +1125,7 @@
 detail::key_nodeptr_comp<KeyValueCompare, rbtree_impl>
 key_node_comp(comp, this);
 return const_iterator(node_algorithms::upper_bound
- (const_node_ptr(&priv_header()), key, key_node_comp), this);
+ (this->priv_header_ptr(), key, key_node_comp), this);
 }

 //! Effects: Finds an iterator to the first element whose key is
@@ -1150,7 +1149,7 @@
 detail::key_nodeptr_comp<KeyValueCompare, rbtree_impl>
 key_node_comp(comp, this);
 return iterator
- (node_algorithms::find(const_node_ptr(&priv_header()), key, key_node_comp), this);
+ (node_algorithms::find(this->priv_header_ptr(), key, key_node_comp), this);
 }

 //! Effects: Finds a const_iterator to the first element whose key is
@@ -1174,7 +1173,7 @@
 detail::key_nodeptr_comp<KeyValueCompare, rbtree_impl>
 key_node_comp(comp, this);
 return const_iterator
- (node_algorithms::find(const_node_ptr(&priv_header()), key, key_node_comp), this);
+ (node_algorithms::find(this->priv_header_ptr(), key, key_node_comp), this);
 }

 //! Effects: Finds a range containing all elements whose key is k or
@@ -1200,7 +1199,7 @@
 detail::key_nodeptr_comp<KeyValueCompare, rbtree_impl>
 key_node_comp(comp, this);
 std::pair<node_ptr, node_ptr> ret
- (node_algorithms::equal_range(const_node_ptr(&priv_header()), key, key_node_comp));
+ (node_algorithms::equal_range(this->priv_header_ptr(), key, key_node_comp));
 return std::pair<iterator, iterator>(iterator(ret.first, this), iterator(ret.second, this));
 }

@@ -1229,7 +1228,7 @@
 detail::key_nodeptr_comp<KeyValueCompare, rbtree_impl>
 key_node_comp(comp, this);
 std::pair<node_ptr, node_ptr> ret
- (node_algorithms::equal_range(const_node_ptr(&priv_header()), key, key_node_comp));
+ (node_algorithms::equal_range(this->priv_header_ptr(), key, key_node_comp));
 return std::pair<const_iterator, const_iterator>(const_iterator(ret.first, this), const_iterator(ret.second, this));
 }

@@ -1255,8 +1254,8 @@
 detail::exception_disposer<rbtree_impl, Disposer>
 rollback(*this, disposer);
 node_algorithms::clone
- (const_node_ptr(&src.priv_header())
- ,node_ptr(&this->priv_header())
+ (const_node_ptr(src.priv_header_ptr())
+ ,node_ptr(this->priv_header_ptr())
 ,detail::node_cloner<Cloner, rbtree_impl>(cloner, this)
 ,detail::node_disposer<Disposer, rbtree_impl>(disposer, this));
 this->priv_size_traits().set_size(src.priv_size_traits().get_size());
@@ -1278,7 +1277,7 @@
 pointer unlink_leftmost_without_rebalance()
 {
 node_ptr to_be_disposed(node_algorithms::unlink_leftmost_without_rebalance
- (node_ptr(&priv_header())));
+ (this->priv_header_ptr()));
 if(!to_be_disposed)
 return 0;
 this->priv_size_traits().decrement();
@@ -1304,7 +1303,7 @@
 void replace_node(iterator replace_this, reference with_this)
 {
 node_algorithms::replace_node( get_real_value_traits().to_node_ptr(*replace_this)
- , node_ptr(&priv_header())
+ , this->priv_header_ptr()
 , get_real_value_traits().to_node_ptr(with_this));
 if(safemode_or_autounlink)
 node_algorithms::init(replace_this.pointed_node());
@@ -1427,7 +1426,7 @@
 static rbtree_impl &priv_container_from_end_iterator(const const_iterator &end_iterator)
 {
 header_plus_size *r = detail::parent_from_member<header_plus_size, node>
- ( detail::boost_intrusive_get_pointer(end_iterator.pointed_node()), &header_plus_size::header_);
+ ( boost::intrusive::detail::to_raw_pointer(end_iterator.pointed_node()), &header_plus_size::header_);
 node_plus_pred_t *n = detail::parent_from_member
 <node_plus_pred_t, header_plus_size>(r, &node_plus_pred_t::header_plus_size_);
 data_t *d = detail::parent_from_member<data_t, node_plus_pred_t>(n, &data_t::node_plus_pred_);

Modified: branches/release/boost/intrusive/rbtree_algorithms.hpp
==============================================================================
--- branches/release/boost/intrusive/rbtree_algorithms.hpp (original)
+++ branches/release/boost/intrusive/rbtree_algorithms.hpp 2011-12-26 12:10:27 EST (Mon, 26 Dec 2011)
@@ -56,6 +56,7 @@
#include <boost/intrusive/detail/assert.hpp>
#include <boost/intrusive/detail/utilities.hpp>
#include <boost/intrusive/detail/tree_algorithms.hpp>
+#include <boost/intrusive/pointer_traits.hpp>

namespace boost {
namespace intrusive {
@@ -135,7 +136,7 @@
 : base_t(f)
 {}

- node_ptr operator()(node_ptr p)
+ node_ptr operator()(const node_ptr & p)
 {
 node_ptr n = base_t::get()(p);
 NodeTraits::set_color(n, NodeTraits::get_color(p));
@@ -145,7 +146,7 @@

 struct rbtree_erase_fixup
 {
- void operator()(node_ptr to_erase, node_ptr successor)
+ void operator()(const node_ptr & to_erase, const node_ptr & successor)
 {
 //Swap color of y and z
 color tmp(NodeTraits::get_color(successor));
@@ -154,17 +155,15 @@
 }
 };

- static node_ptr uncast(const_node_ptr ptr)
- {
- return node_ptr(const_cast<node*>(::boost::intrusive::detail::boost_intrusive_get_pointer(ptr)));
- }
+ static node_ptr uncast(const const_node_ptr & ptr)
+ { return pointer_traits<node_ptr>::const_cast_from(ptr); }
 /// @endcond

 public:
- static node_ptr begin_node(const_node_ptr header)
+ static node_ptr begin_node(const const_node_ptr & header)
 { return tree_algorithms::begin_node(header); }

- static node_ptr end_node(const_node_ptr header)
+ static node_ptr end_node(const const_node_ptr & header)
 { return tree_algorithms::end_node(header); }

 //! This type is the information that will be
@@ -180,7 +179,7 @@
 //! Complexity: Constant.
 //!
 //! Throws: Nothing.
- static void swap_tree(node_ptr header1, node_ptr header2)
+ static void swap_tree(const node_ptr & header1, const node_ptr & header2)
 { return tree_algorithms::swap_tree(header1, header2); }

 //! Requires: node1 and node2 can't be header nodes
@@ -198,7 +197,7 @@
 //! node1 and node2 are not equivalent according to the ordering rules.
 //!
 //!Experimental function
- static void swap_nodes(node_ptr node1, node_ptr node2)
+ static void swap_nodes(const node_ptr & node1, const node_ptr & node2)
 {
 if(node1 == node2)
 return;
@@ -222,7 +221,7 @@
 //! node1 and node2 are not equivalent according to the ordering rules.
 //!
 //!Experimental function
- static void swap_nodes(node_ptr node1, node_ptr header1, node_ptr node2, node_ptr header2)
+ static void swap_nodes(const node_ptr & node1, const node_ptr & header1, const node_ptr & node2, const node_ptr & header2)
 {
 if(node1 == node2) return;

@@ -249,7 +248,7 @@
 //! the node, since no rebalancing and comparison is needed.
 //!
 //!Experimental function
- static void replace_node(node_ptr node_to_be_replaced, node_ptr new_node)
+ static void replace_node(const node_ptr & node_to_be_replaced, const node_ptr & new_node)
 {
 if(node_to_be_replaced == new_node)
 return;
@@ -272,7 +271,7 @@
 //! the node, since no rebalancing or comparison is needed.
 //!
 //!Experimental function
- static void replace_node(node_ptr node_to_be_replaced, node_ptr header, node_ptr new_node)
+ static void replace_node(const node_ptr & node_to_be_replaced, const node_ptr & header, const node_ptr & new_node)
 {
 tree_algorithms::replace_node(node_to_be_replaced, header, new_node);
 NodeTraits::set_color(new_node, NodeTraits::get_color(node_to_be_replaced));
@@ -285,7 +284,7 @@
 //! Complexity: Average complexity is constant time.
 //!
 //! Throws: Nothing.
- static void unlink(node_ptr node)
+ static void unlink(const node_ptr & node)
 {
 node_ptr x = NodeTraits::get_parent(node);
 if(x){
@@ -308,7 +307,7 @@
 //! only be used for more unlink_leftmost_without_rebalance calls.
 //! This function is normally used to achieve a step by step
 //! controlled destruction of the tree.
- static node_ptr unlink_leftmost_without_rebalance(node_ptr header)
+ static node_ptr unlink_leftmost_without_rebalance(const node_ptr & header)
 { return tree_algorithms::unlink_leftmost_without_rebalance(header); }

 //! Requires: node is a node of the tree or an node initialized
@@ -319,7 +318,7 @@
 //! Complexity: Constant time.
 //!
 //! Throws: Nothing.
- static bool unique(const_node_ptr node)
+ static bool unique(const const_node_ptr & node)
 { return tree_algorithms::unique(node); }

 //! Requires: node is a node of the tree but it's not the header.
@@ -329,7 +328,7 @@
 //! Complexity: Linear time.
 //!
 //! Throws: Nothing.
- static std::size_t count(const_node_ptr node)
+ static std::size_t count(const const_node_ptr & node)
 { return tree_algorithms::count(node); }

 //! Requires: header is the header node of the tree.
@@ -339,7 +338,7 @@
 //! Complexity: Linear time.
 //!
 //! Throws: Nothing.
- static std::size_t size(const_node_ptr header)
+ static std::size_t size(const const_node_ptr & header)
 { return tree_algorithms::size(header); }

 //! Requires: p is a node from the tree except the header.
@@ -349,7 +348,7 @@
 //! Complexity: Average constant time.
 //!
 //! Throws: Nothing.
- static node_ptr next_node(node_ptr p)
+ static node_ptr next_node(const node_ptr & p)
 { return tree_algorithms::next_node(p); }

 //! Requires: p is a node from the tree except the leftmost node.
@@ -359,7 +358,7 @@
 //! Complexity: Average constant time.
 //!
 //! Throws: Nothing.
- static node_ptr prev_node(node_ptr p)
+ static node_ptr prev_node(const node_ptr & p)
 { return tree_algorithms::prev_node(p); }

 //! Requires: node must not be part of any tree.
@@ -371,7 +370,7 @@
 //! Throws: Nothing.
 //!
 //! Nodes: If node is inserted in a tree, this function corrupts the tree.
- static void init(node_ptr node)
+ static void init(const node_ptr & node)
 { tree_algorithms::init(node); }

 //! Requires: node must not be part of any tree.
@@ -384,7 +383,7 @@
 //! Throws: Nothing.
 //!
 //! Nodes: If node is inserted in a tree, this function corrupts the tree.
- static void init_header(node_ptr header)
+ static void init_header(const node_ptr & header)
 {
 tree_algorithms::init_header(header);
 NodeTraits::set_color(header, NodeTraits::red());
@@ -398,7 +397,7 @@
 //! Complexity: Amortized constant time.
 //!
 //! Throws: Nothing.
- static node_ptr erase(node_ptr header, node_ptr z)
+ static node_ptr erase(const node_ptr & header, const node_ptr & z)
 {
 typename tree_algorithms::data_for_rebalance info;
 tree_algorithms::erase(header, z, rbtree_erase_fixup(), info);
@@ -417,13 +416,13 @@
 //! take a node_ptr and shouldn't throw.
 //!
 //! Effects: First empties target tree calling
- //! <tt>void disposer::operator()(node_ptr)</tt> for every node of the tree
+ //! <tt>void disposer::operator()(const node_ptr &)</tt> for every node of the tree
 //! except the header.
 //!
 //! Then, duplicates the entire tree pointed by "source_header" cloning each
- //! source node with <tt>node_ptr Cloner::operator()(node_ptr)</tt> to obtain
+ //! source node with <tt>node_ptr Cloner::operator()(const node_ptr &)</tt> to obtain
 //! the nodes of the target tree. If "cloner" throws, the cloned target nodes
- //! are disposed using <tt>void disposer(node_ptr)</tt>.
+ //! are disposed using <tt>void disposer(const node_ptr &)</tt>.
 //!
 //! Complexity: Linear to the number of element of the source tree plus the.
 //! number of elements of tree target tree when calling this function.
@@ -431,7 +430,7 @@
 //! Throws: If cloner functor throws. If this happens target nodes are disposed.
 template <class Cloner, class Disposer>
 static void clone
- (const_node_ptr source_header, node_ptr target_header, Cloner cloner, Disposer disposer)
+ (const const_node_ptr & source_header, const node_ptr & target_header, Cloner cloner, Disposer disposer)
 {
 rbtree_node_cloner<Cloner> new_cloner(cloner);
 tree_algorithms::clone(source_header, target_header, new_cloner, disposer);
@@ -441,7 +440,7 @@
 //! taking a node_ptr parameter and shouldn't throw.
 //!
 //! Effects: Empties the target tree calling
- //! <tt>void disposer::operator()(node_ptr)</tt> for every node of the tree
+ //! <tt>void disposer::operator()(const node_ptr &)</tt> for every node of the tree
 //! except the header.
 //!
 //! Complexity: Linear to the number of element of the source tree plus the.
@@ -449,7 +448,7 @@
 //!
 //! Throws: If cloner functor throws. If this happens target nodes are disposed.
 template<class Disposer>
- static void clear_and_dispose(node_ptr header, Disposer disposer)
+ static void clear_and_dispose(const node_ptr & header, Disposer disposer)
 { tree_algorithms::clear_and_dispose(header, disposer); }

 //! Requires: "header" must be the header node of a tree.
@@ -466,7 +465,7 @@
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static node_ptr lower_bound
- (const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp)
+ (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp)
 { return tree_algorithms::lower_bound(header, key, comp); }

 //! Requires: "header" must be the header node of a tree.
@@ -482,7 +481,7 @@
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static node_ptr upper_bound
- (const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp)
+ (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp)
 { return tree_algorithms::upper_bound(header, key, comp); }

 //! Requires: "header" must be the header node of a tree.
@@ -498,7 +497,7 @@
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static node_ptr find
- (const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp)
+ (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp)
 { return tree_algorithms::find(header, key, comp); }

 //! Requires: "header" must be the header node of a tree.
@@ -516,7 +515,7 @@
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static std::pair<node_ptr, node_ptr> equal_range
- (const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp)
+ (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp)
 { return tree_algorithms::equal_range(header, key, comp); }

 //! Requires: "h" must be the header node of a tree.
@@ -533,7 +532,7 @@
 //! Throws: If "comp" throws.
 template<class NodePtrCompare>
 static node_ptr insert_equal_upper_bound
- (node_ptr h, node_ptr new_node, NodePtrCompare comp)
+ (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp)
 {
 tree_algorithms::insert_equal_upper_bound(h, new_node, comp);
 rebalance_after_insertion(h, new_node);
@@ -554,7 +553,7 @@
 //! Throws: If "comp" throws.
 template<class NodePtrCompare>
 static node_ptr insert_equal_lower_bound
- (node_ptr h, node_ptr new_node, NodePtrCompare comp)
+ (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp)
 {
 tree_algorithms::insert_equal_lower_bound(h, new_node, comp);
 rebalance_after_insertion(h, new_node);
@@ -577,7 +576,7 @@
 //! Throws: If "comp" throws.
 template<class NodePtrCompare>
 static node_ptr insert_equal
- (node_ptr header, node_ptr hint, node_ptr new_node, NodePtrCompare comp)
+ (const node_ptr & header, const node_ptr & hint, const node_ptr & new_node, NodePtrCompare comp)
 {
 tree_algorithms::insert_equal(header, hint, new_node, comp);
 rebalance_after_insertion(header, new_node);
@@ -599,7 +598,7 @@
 //! Note: If "pos" is not the successor of the newly inserted "new_node"
 //! tree invariants might be broken.
 static node_ptr insert_before
- (node_ptr header, node_ptr pos, node_ptr new_node)
+ (const node_ptr & header, const node_ptr & pos, const node_ptr & new_node)
 {
 tree_algorithms::insert_before(header, pos, new_node);
 rebalance_after_insertion(header, new_node);
@@ -619,7 +618,7 @@
 //! Note: If "new_node" is less than the greatest inserted key
 //! tree invariants are broken. This function is slightly faster than
 //! using "insert_before".
- static void push_back(node_ptr header, node_ptr new_node)
+ static void push_back(const node_ptr & header, const node_ptr & new_node)
 {
 tree_algorithms::push_back(header, new_node);
 rebalance_after_insertion(header, new_node);
@@ -638,7 +637,7 @@
 //! Note: If "new_node" is greater than the lowest inserted key
 //! tree invariants are broken. This function is slightly faster than
 //! using "insert_before".
- static void push_front(node_ptr header, node_ptr new_node)
+ static void push_front(const node_ptr & header, const node_ptr & new_node)
 {
 tree_algorithms::push_front(header, new_node);
 rebalance_after_insertion(header, new_node);
@@ -680,7 +679,7 @@
 //! if no more objects are inserted or erased from the set.
 template<class KeyType, class KeyNodePtrCompare>
 static std::pair<node_ptr, bool> insert_unique_check
- (const_node_ptr header, const KeyType &key
+ (const const_node_ptr & header, const KeyType &key
 ,KeyNodePtrCompare comp, insert_commit_data &commit_data)
 { return tree_algorithms::insert_unique_check(header, key, comp, commit_data); }

@@ -725,7 +724,7 @@
 //! if no more objects are inserted or erased from the set.
 template<class KeyType, class KeyNodePtrCompare>
 static std::pair<node_ptr, bool> insert_unique_check
- (const_node_ptr header, node_ptr hint, const KeyType &key
+ (const const_node_ptr & header, const node_ptr &hint, const KeyType &key
 ,KeyNodePtrCompare comp, insert_commit_data &commit_data)
 { return tree_algorithms::insert_unique_check(header, hint, key, comp, commit_data); }

@@ -747,7 +746,7 @@
 //! previously executed to fill "commit_data". No value should be inserted or
 //! erased between the "insert_check" and "insert_commit" calls.
 static void insert_unique_commit
- (node_ptr header, node_ptr new_value, const insert_commit_data &commit_data)
+ (const node_ptr & header, const node_ptr & new_value, const insert_commit_data &commit_data)
 {
 tree_algorithms::insert_unique_commit(header, new_value, commit_data);
 rebalance_after_insertion(header, new_value);
@@ -760,7 +759,7 @@
 //! Complexity: Logarithmic.
 //!
 //! Throws: Nothing.
- static node_ptr get_header(node_ptr n)
+ static node_ptr get_header(const node_ptr & n)
 { return tree_algorithms::get_header(n); }

 /// @cond
@@ -773,7 +772,7 @@
 //! Complexity: Constant.
 //!
 //! Throws: Nothing.
- static bool is_header(const_node_ptr p)
+ static bool is_header(const const_node_ptr & p)
 {
 return NodeTraits::get_color(p) == NodeTraits::red() &&
 tree_algorithms::is_header(p);
@@ -781,9 +780,10 @@
 // NodeTraits::get_parent(NodeTraits::get_parent(p)) == p;
 }

- static void rebalance_after_erasure(node_ptr header, node_ptr x, node_ptr x_parent)
+ static void rebalance_after_erasure(const node_ptr & header, const node_ptr &xnode, const node_ptr &xnode_parent)
 {
- while(x != NodeTraits::get_parent(header) && (x == 0 || NodeTraits::get_color(x) == NodeTraits::black())){
+ node_ptr x(xnode), x_parent(xnode_parent);
+ while(x != NodeTraits::get_parent(header) && (x == node_ptr() || NodeTraits::get_color(x) == NodeTraits::black())){
 if(x == NodeTraits::get_left(x_parent)){
 node_ptr w = NodeTraits::get_right(x_parent);
 if(NodeTraits::get_color(w) == NodeTraits::red()){
@@ -792,14 +792,14 @@
 tree_algorithms::rotate_left(x_parent, header);
 w = NodeTraits::get_right(x_parent);
 }
- if((NodeTraits::get_left(w) == 0 || NodeTraits::get_color(NodeTraits::get_left(w)) == NodeTraits::black()) &&
- (NodeTraits::get_right(w) == 0 || NodeTraits::get_color(NodeTraits::get_right(w)) == NodeTraits::black())){
+ if((NodeTraits::get_left(w) == node_ptr() || NodeTraits::get_color(NodeTraits::get_left(w)) == NodeTraits::black()) &&
+ (NodeTraits::get_right(w) == node_ptr() || NodeTraits::get_color(NodeTraits::get_right(w)) == NodeTraits::black())){
 NodeTraits::set_color(w, NodeTraits::red());
 x = x_parent;
 x_parent = NodeTraits::get_parent(x_parent);
 }
 else {
- if(NodeTraits::get_right(w) == 0 || NodeTraits::get_color(NodeTraits::get_right(w)) == NodeTraits::black()){
+ if(NodeTraits::get_right(w) == node_ptr() || NodeTraits::get_color(NodeTraits::get_right(w)) == NodeTraits::black()){
 NodeTraits::set_color(NodeTraits::get_left(w), NodeTraits::black());
 NodeTraits::set_color(w, NodeTraits::red());
 tree_algorithms::rotate_right(w, header);
@@ -822,14 +822,14 @@
 tree_algorithms::rotate_right(x_parent, header);
 w = NodeTraits::get_left(x_parent);
 }
- if((NodeTraits::get_right(w) == 0 || NodeTraits::get_color(NodeTraits::get_right(w)) == NodeTraits::black()) &&
- (NodeTraits::get_left(w) == 0 || NodeTraits::get_color(NodeTraits::get_left(w)) == NodeTraits::black())){
+ if((NodeTraits::get_right(w) == node_ptr() || NodeTraits::get_color(NodeTraits::get_right(w)) == NodeTraits::black()) &&
+ (NodeTraits::get_left(w) == node_ptr() || NodeTraits::get_color(NodeTraits::get_left(w)) == NodeTraits::black())){
 NodeTraits::set_color(w, NodeTraits::red());
 x = x_parent;
 x_parent = NodeTraits::get_parent(x_parent);
 }
 else {
- if(NodeTraits::get_left(w) == 0 || NodeTraits::get_color(NodeTraits::get_left(w)) == NodeTraits::black()){
+ if(NodeTraits::get_left(w) == node_ptr() || NodeTraits::get_color(NodeTraits::get_left(w)) == NodeTraits::black()){
 NodeTraits::set_color(NodeTraits::get_right(w), NodeTraits::black());
 NodeTraits::set_color(w, NodeTraits::red());
 tree_algorithms::rotate_left(w, header);
@@ -849,8 +849,9 @@
 }

- static void rebalance_after_insertion(node_ptr header, node_ptr p)
+ static void rebalance_after_insertion(const node_ptr & header, const node_ptr &pnode)
 {
+ node_ptr p(pnode);
 NodeTraits::set_color(p, NodeTraits::red());
 while(p != NodeTraits::get_parent(header) && NodeTraits::get_color(NodeTraits::get_parent(p)) == NodeTraits::red()){
 node_ptr p_parent(NodeTraits::get_parent(p));

Modified: branches/release/boost/intrusive/sgtree.hpp
==============================================================================
--- branches/release/boost/intrusive/sgtree.hpp (original)
+++ branches/release/boost/intrusive/sgtree.hpp 2011-12-26 12:10:27 EST (Mon, 26 Dec 2011)
@@ -32,9 +32,10 @@
#include <boost/intrusive/bs_set_hook.hpp>
#include <boost/intrusive/detail/tree_node.hpp>
#include <boost/intrusive/detail/ebo_functor_holder.hpp>
-#include <boost/intrusive/detail/pointer_to_other.hpp>
+#include <boost/intrusive/pointer_traits.hpp>
#include <boost/intrusive/detail/clear_on_destructor_base.hpp>
#include <boost/intrusive/detail/mpl.hpp>
+#include <boost/intrusive/detail/utilities.hpp>
#include <boost/intrusive/options.hpp>
#include <boost/intrusive/sgtree_algorithms.hpp>
#include <boost/intrusive/link_mode.hpp>
@@ -223,24 +224,26 @@
 /// @endcond
 typedef typename real_value_traits::pointer pointer;
 typedef typename real_value_traits::const_pointer const_pointer;
- typedef typename std::iterator_traits<pointer>::value_type value_type;
+ typedef typename pointer_traits<pointer>::element_type value_type;
 typedef value_type key_type;
- typedef typename std::iterator_traits<pointer>::reference reference;
- typedef typename std::iterator_traits<const_pointer>::reference const_reference;
- typedef typename std::iterator_traits<pointer>::difference_type difference_type;
+ typedef typename pointer_traits<pointer>::reference reference;
+ typedef typename pointer_traits<const_pointer>::reference const_reference;
+ typedef typename pointer_traits<const_pointer>::difference_type difference_type;
 typedef typename Config::size_type size_type;
 typedef typename Config::compare value_compare;
 typedef value_compare key_compare;
 typedef tree_iterator<sgtree_impl, false> iterator;
 typedef tree_iterator<sgtree_impl, true> const_iterator;
- typedef std::reverse_iterator<iterator> reverse_iterator;
- typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+ typedef boost::intrusive::detail::reverse_iterator<iterator> reverse_iterator;
+ typedef boost::intrusive::detail::reverse_iterator<const_iterator>const_reverse_iterator;
 typedef typename real_value_traits::node_traits node_traits;
 typedef typename node_traits::node node;
- typedef typename boost::pointer_to_other
- <pointer, node>::type node_ptr;
- typedef typename boost::pointer_to_other
- <node_ptr, const node>::type const_node_ptr;
+ typedef typename pointer_traits
+ <pointer>::template rebind_pointer
+ <node>::type node_ptr;
+ typedef typename pointer_traits
+ <pointer>::template rebind_pointer
+ <const node>::type const_node_ptr;
 typedef sgtree_algorithms<node_traits> node_algorithms;

 static const bool floating_point = Config::floating_point;
@@ -309,14 +312,14 @@
 value_traits &priv_value_traits()
 { return data_; }

- const node &priv_header() const
- { return data_.node_plus_pred_.header_plus_alpha_.header_; }
+ node_ptr priv_header_ptr()
+ { return pointer_traits<node_ptr>::pointer_to(data_.node_plus_pred_.header_plus_alpha_.header_); }

- node &priv_header()
- { return data_.node_plus_pred_.header_plus_alpha_.header_; }
+ const_node_ptr priv_header_ptr() const
+ { return pointer_traits<const_node_ptr>::pointer_to(data_.node_plus_pred_.header_plus_alpha_.header_); }

- static node_ptr uncast(const_node_ptr ptr)
- { return node_ptr(const_cast<node*>(detail::boost_intrusive_get_pointer(ptr))); }
+ static node_ptr uncast(const const_node_ptr & ptr)
+ { return pointer_traits<node_ptr>::const_cast_from(ptr); }

 size_traits &priv_size_traits()
 { return data_.node_plus_pred_.size_traits_; }
@@ -371,7 +374,7 @@
 , const value_traits &v_traits = value_traits())
 : data_(cmp, v_traits)
 {
- node_algorithms::init_header(&priv_header());
+ node_algorithms::init_header(this->priv_header_ptr());
 this->priv_size_traits().set_size(size_type(0));
 }

@@ -393,7 +396,7 @@
 , const value_traits &v_traits = value_traits())
 : data_(cmp, v_traits)
 {
- node_algorithms::init_header(&priv_header());
+ node_algorithms::init_header(this->priv_header_ptr());
 this->priv_size_traits().set_size(size_type(0));
 if(unique)
 this->insert_unique(b, e);
@@ -406,7 +409,7 @@
 sgtree_impl(BOOST_RV_REF(sgtree_impl) x)
 : data_(::boost::move(x.priv_comp()), ::boost::move(x.priv_value_traits()))
 {
- node_algorithms::init_header(&priv_header());
+ node_algorithms::init_header(this->priv_header_ptr());
 this->priv_size_traits().set_size(size_type(0));
 this->swap(x);
 }
@@ -432,7 +435,7 @@
 //!
 //! Throws: Nothing.
 iterator begin()
- { return iterator (node_traits::get_left(node_ptr(&priv_header())), this); }
+ { return iterator (node_traits::get_left(this->priv_header_ptr()), this); }

 //! Effects: Returns a const_iterator pointing to the beginning of the tree.
 //!
@@ -448,7 +451,7 @@
 //!
 //! Throws: Nothing.
 const_iterator cbegin() const
- { return const_iterator (node_traits::get_left(const_node_ptr(&priv_header())), this); }
+ { return const_iterator (node_traits::get_left(this->priv_header_ptr()), this); }

 //! Effects: Returns an iterator pointing to the end of the tree.
 //!
@@ -456,7 +459,7 @@
 //!
 //! Throws: Nothing.
 iterator end()
- { return iterator (node_ptr(&priv_header()), this); }
+ { return iterator (this->priv_header_ptr(), this); }

 //! Effects: Returns a const_iterator pointing to the end of the tree.
 //!
@@ -472,7 +475,7 @@
 //!
 //! Throws: Nothing.
 const_iterator cend() const
- { return const_iterator (uncast(const_node_ptr(&priv_header())), this); }
+ { return const_iterator (uncast(this->priv_header_ptr()), this); }

 //! Effects: Returns a reverse_iterator pointing to the beginning of the
 //! reversed tree.
@@ -586,7 +589,7 @@
 //!
 //! Throws: Nothing.
 bool empty() const
- { return node_algorithms::unique(const_node_ptr(&priv_header())); }
+ { return node_algorithms::unique(this->priv_header_ptr()); }

 //! Effects: Returns the number of elements stored in the tree.
 //!
@@ -599,7 +602,7 @@
 if(constant_time_size)
 return this->priv_size_traits().get_size();
 else{
- return (size_type)node_algorithms::size(const_node_ptr(&priv_header()));
+ return (size_type)node_algorithms::size(this->priv_header_ptr());
 }
 }

@@ -616,7 +619,7 @@
 swap(priv_alpha_traits(), priv_alpha_traits());
 swap(data_.max_tree_size_, other.data_.max_tree_size_);
 //These can't throw
- node_algorithms::swap_tree(node_ptr(&priv_header()), node_ptr(&other.priv_header()));
+ node_algorithms::swap_tree(this->priv_header_ptr(), other.priv_header_ptr());
 if(constant_time_size){
 size_type backup = this->priv_size_traits().get_size();
 this->priv_size_traits().set_size(other.priv_size_traits().get_size());
@@ -644,7 +647,7 @@
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
 std::size_t max_tree_size = (std::size_t)data_.max_tree_size_;
 node_ptr p = node_algorithms::insert_equal_upper_bound
- (node_ptr(&priv_header()), to_insert, key_node_comp
+ (this->priv_header_ptr(), to_insert, key_node_comp
 , (size_type)this->size(), this->get_h_alpha_func(), max_tree_size);
 this->priv_size_traits().increment();
 data_.max_tree_size_ = (size_type)max_tree_size;
@@ -674,7 +677,7 @@
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
 std::size_t max_tree_size = (std::size_t)data_.max_tree_size_;
 node_ptr p = node_algorithms::insert_equal
- (node_ptr(&priv_header()), hint.pointed_node(), to_insert, key_node_comp
+ (this->priv_header_ptr(), hint.pointed_node(), to_insert, key_node_comp
 , (std::size_t)this->size(), this->get_h_alpha_func(), max_tree_size);
 this->priv_size_traits().increment();
 data_.max_tree_size_ = (size_type)max_tree_size;
@@ -812,7 +815,7 @@
 comp(key_value_comp, this);
 std::pair<node_ptr, bool> ret =
 (node_algorithms::insert_unique_check
- (node_ptr(&priv_header()), key, comp, commit_data));
+ (this->priv_header_ptr(), key, comp, commit_data));
 return std::pair<iterator, bool>(iterator(ret.first, this), ret.second);
 }

@@ -857,7 +860,7 @@
 comp(key_value_comp, this);
 std::pair<node_ptr, bool> ret =
 (node_algorithms::insert_unique_check
- (node_ptr(&priv_header()), hint.pointed_node(), key, comp, commit_data));
+ (this->priv_header_ptr(), hint.pointed_node(), key, comp, commit_data));
 return std::pair<iterator, bool>(iterator(ret.first, this), ret.second);
 }

@@ -885,7 +888,7 @@
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
 std::size_t max_tree_size = (std::size_t)data_.max_tree_size_;
 node_algorithms::insert_unique_commit
- ( node_ptr(&priv_header()), to_insert, commit_data
+ ( this->priv_header_ptr(), to_insert, commit_data
 , (std::size_t)this->size(), this->get_h_alpha_func(), max_tree_size);
 this->priv_size_traits().increment();
 data_.max_tree_size_ = (size_type)max_tree_size;
@@ -913,7 +916,7 @@
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
 std::size_t max_tree_size = (std::size_t)data_.max_tree_size_;
 node_ptr p = node_algorithms::insert_before
- ( node_ptr(&priv_header()), pos.pointed_node(), to_insert
+ ( this->priv_header_ptr(), pos.pointed_node(), to_insert
 , (size_type)this->size(), this->get_h_alpha_func(), max_tree_size);
 this->priv_size_traits().increment();
 data_.max_tree_size_ = (size_type)max_tree_size;
@@ -941,7 +944,7 @@
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
 std::size_t max_tree_size = (std::size_t)data_.max_tree_size_;
 node_algorithms::push_back
- ( node_ptr(&priv_header()), to_insert
+ ( this->priv_header_ptr(), to_insert
 , (size_type)this->size(), this->get_h_alpha_func(), max_tree_size);
 this->priv_size_traits().increment();
 data_.max_tree_size_ = (size_type)max_tree_size;
@@ -968,7 +971,7 @@
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
 std::size_t max_tree_size = (std::size_t)data_.max_tree_size_;
 node_algorithms::push_front
- ( node_ptr(&priv_header()), to_insert
+ ( this->priv_header_ptr(), to_insert
 , (size_type)this->size(), this->get_h_alpha_func(), max_tree_size);
 this->priv_size_traits().increment();
 data_.max_tree_size_ = (size_type)max_tree_size;
@@ -991,7 +994,7 @@
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!node_algorithms::unique(to_erase));
 std::size_t max_tree_size = data_.max_tree_size_;
 node_algorithms::erase
- ( &priv_header(), to_erase, (std::size_t)this->size()
+ ( this->priv_header_ptr(), to_erase, (std::size_t)this->size()
 , max_tree_size, this->get_alpha_by_max_size_func());
 data_.max_tree_size_ = (size_type)max_tree_size;
 this->priv_size_traits().decrement();
@@ -1155,7 +1158,7 @@
 this->clear_and_dispose(detail::null_disposer());
 }
 else{
- node_algorithms::init_header(&priv_header());
+ node_algorithms::init_header(this->priv_header_ptr());
 this->priv_size_traits().set_size(0);
 }
 }
@@ -1172,7 +1175,7 @@
 template<class Disposer>
 void clear_and_dispose(Disposer disposer)
 {
- node_algorithms::clear_and_dispose(node_ptr(&priv_header())
+ node_algorithms::clear_and_dispose(this->priv_header_ptr()
 , detail::node_disposer<Disposer, sgtree_impl>(disposer, this));
 this->priv_size_traits().set_size(0);
 }
@@ -1229,7 +1232,7 @@
 detail::key_nodeptr_comp<KeyValueCompare, sgtree_impl>
 key_node_comp(comp, this);
 return iterator(node_algorithms::lower_bound
- (const_node_ptr(&priv_header()), key, key_node_comp), this);
+ (this->priv_header_ptr(), key, key_node_comp), this);
 }

 //! Effects: Returns a const iterator to the first element whose
@@ -1244,7 +1247,7 @@
 detail::key_nodeptr_comp<KeyValueCompare, sgtree_impl>
 key_node_comp(comp, this);
 return const_iterator(node_algorithms::lower_bound
- (const_node_ptr(&priv_header()), key, key_node_comp), this);
+ (this->priv_header_ptr(), key, key_node_comp), this);
 }

 //! Effects: Returns an iterator to the first element whose
@@ -1269,7 +1272,7 @@
 detail::key_nodeptr_comp<KeyValueCompare, sgtree_impl>
 key_node_comp(comp, this);
 return iterator(node_algorithms::upper_bound
- (const_node_ptr(&priv_header()), key, key_node_comp), this);
+ (this->priv_header_ptr(), key, key_node_comp), this);
 }

 //! Effects: Returns an iterator to the first element whose
@@ -1294,7 +1297,7 @@
 detail::key_nodeptr_comp<KeyValueCompare, sgtree_impl>
 key_node_comp(comp, this);
 return const_iterator(node_algorithms::upper_bound
- (const_node_ptr(&priv_header()), key, key_node_comp), this);
+ (this->priv_header_ptr(), key, key_node_comp), this);
 }

 //! Effects: Finds an iterator to the first element whose key is
@@ -1318,7 +1321,7 @@
 detail::key_nodeptr_comp<KeyValueCompare, sgtree_impl>
 key_node_comp(comp, this);
 return iterator
- (node_algorithms::find(const_node_ptr(&priv_header()), key, key_node_comp), this);
+ (node_algorithms::find(this->priv_header_ptr(), key, key_node_comp), this);
 }

 //! Effects: Finds a const_iterator to the first element whose key is
@@ -1342,7 +1345,7 @@
 detail::key_nodeptr_comp<KeyValueCompare, sgtree_impl>
 key_node_comp(comp, this);
 return const_iterator
- (node_algorithms::find(const_node_ptr(&priv_header()), key, key_node_comp), this);
+ (node_algorithms::find(this->priv_header_ptr(), key, key_node_comp), this);
 }

 //! Effects: Finds a range containing all elements whose key is k or
@@ -1368,7 +1371,7 @@
 detail::key_nodeptr_comp<KeyValueCompare, sgtree_impl>
 key_node_comp(comp, this);
 std::pair<node_ptr, node_ptr> ret
- (node_algorithms::equal_range(const_node_ptr(&priv_header()), key, key_node_comp));
+ (node_algorithms::equal_range(this->priv_header_ptr(), key, key_node_comp));
 return std::pair<iterator, iterator>(iterator(ret.first, this), iterator(ret.second, this));
 }

@@ -1397,7 +1400,7 @@
 detail::key_nodeptr_comp<KeyValueCompare, sgtree_impl>
 key_node_comp(comp, this);
 std::pair<node_ptr, node_ptr> ret
- (node_algorithms::equal_range(const_node_ptr(&priv_header()), key, key_node_comp));
+ (node_algorithms::equal_range(this->priv_header_ptr(), key, key_node_comp));
 return std::pair<const_iterator, const_iterator>(const_iterator(ret.first, this), const_iterator(ret.second, this));
 }

@@ -1423,8 +1426,8 @@
 detail::exception_disposer<sgtree_impl, Disposer>
 rollback(*this, disposer);
 node_algorithms::clone
- (const_node_ptr(&src.priv_header())
- ,node_ptr(&this->priv_header())
+ (src.priv_header_ptr()
+ ,this->priv_header_ptr()
 ,detail::node_cloner<Cloner, sgtree_impl>(cloner, this)
 ,detail::node_disposer<Disposer, sgtree_impl>(disposer, this));
 this->priv_size_traits().set_size(src.priv_size_traits().get_size());
@@ -1446,7 +1449,7 @@
 pointer unlink_leftmost_without_rebalance()
 {
 node_ptr to_be_disposed(node_algorithms::unlink_leftmost_without_rebalance
- (node_ptr(&priv_header())));
+ (this->priv_header_ptr()));
 if(!to_be_disposed)
 return 0;
 this->priv_size_traits().decrement();
@@ -1472,7 +1475,7 @@
 void replace_node(iterator replace_this, reference with_this)
 {
 node_algorithms::replace_node( get_real_value_traits().to_node_ptr(*replace_this)
- , node_ptr(&priv_header())
+ , this->priv_header_ptr()
 , get_real_value_traits().to_node_ptr(with_this));
 if(safemode_or_autounlink)
 node_algorithms::init(replace_this.pointed_node());
@@ -1558,7 +1561,7 @@
 //!
 //! Complexity: Linear.
 void rebalance()
- { node_algorithms::rebalance(node_ptr(&priv_header())); }
+ { node_algorithms::rebalance(this->priv_header_ptr()); }

 //! Requires: old_root is a node of a tree.
 //!
@@ -1654,7 +1657,7 @@
 static sgtree_impl &priv_container_from_end_iterator(const const_iterator &end_iterator)
 {
 header_plus_alpha *r = detail::parent_from_member<header_plus_alpha, node>
- ( detail::boost_intrusive_get_pointer(end_iterator.pointed_node()), &header_plus_alpha::header_);
+ ( boost::intrusive::detail::to_raw_pointer(end_iterator.pointed_node()), &header_plus_alpha::header_);
 node_plus_pred_t *n = detail::parent_from_member
 <node_plus_pred_t, header_plus_alpha>(r, &node_plus_pred_t::header_plus_alpha_);
 data_t *d = detail::parent_from_member<data_t, node_plus_pred_t>(n, &data_t::node_plus_pred_);

Modified: branches/release/boost/intrusive/sgtree_algorithms.hpp
==============================================================================
--- branches/release/boost/intrusive/sgtree_algorithms.hpp (original)
+++ branches/release/boost/intrusive/sgtree_algorithms.hpp 2011-12-26 12:10:27 EST (Mon, 26 Dec 2011)
@@ -24,6 +24,7 @@
#include <boost/intrusive/detail/assert.hpp>
#include <boost/intrusive/detail/utilities.hpp>
#include <boost/intrusive/detail/tree_algorithms.hpp>
+#include <boost/intrusive/pointer_traits.hpp>

namespace boost {
@@ -68,17 +69,15 @@

 typedef detail::tree_algorithms<NodeTraits> tree_algorithms;

- static node_ptr uncast(const_node_ptr ptr)
- {
- return node_ptr(const_cast<node*>(::boost::intrusive::detail::boost_intrusive_get_pointer(ptr)));
- }
+ static node_ptr uncast(const const_node_ptr & ptr)
+ { return pointer_traits<node_ptr>::const_cast_from(ptr); }
 /// @endcond

 public:
- static node_ptr begin_node(const_node_ptr header)
+ static node_ptr begin_node(const const_node_ptr & header)
 { return tree_algorithms::begin_node(header); }

- static node_ptr end_node(const_node_ptr header)
+ static node_ptr end_node(const const_node_ptr & header)
 { return tree_algorithms::end_node(header); }

 //! This type is the information that will be
@@ -98,7 +97,7 @@
 //! Complexity: Constant.
 //!
 //! Throws: Nothing.
- static void swap_tree(node_ptr header1, node_ptr header2)
+ static void swap_tree(const node_ptr & header1, const node_ptr & header2)
 { return tree_algorithms::swap_tree(header1, header2); }

 //! Requires: node1 and node2 can't be header nodes
@@ -116,7 +115,7 @@
 //! node1 and node2 are not equivalent according to the ordering rules.
 //!
 //!Experimental function
- static void swap_nodes(node_ptr node1, node_ptr node2)
+ static void swap_nodes(const node_ptr & node1, const node_ptr & node2)
 {
 if(node1 == node2)
 return;
@@ -140,7 +139,7 @@
 //! node1 and node2 are not equivalent according to the ordering rules.
 //!
 //!Experimental function
- static void swap_nodes(node_ptr node1, node_ptr header1, node_ptr node2, node_ptr header2)
+ static void swap_nodes(const node_ptr & node1, const node_ptr & header1, const node_ptr & node2, const node_ptr & header2)
 { tree_algorithms::swap_nodes(node1, header1, node2, header2); }

 //! Requires: node_to_be_replaced must be inserted in a tree
@@ -159,7 +158,7 @@
 //! the node, since no rebalancing and comparison is needed.
 //!
 //!Experimental function
- static void replace_node(node_ptr node_to_be_replaced, node_ptr new_node)
+ static void replace_node(const node_ptr & node_to_be_replaced, const node_ptr & new_node)
 {
 if(node_to_be_replaced == new_node)
 return;
@@ -182,7 +181,7 @@
 //! the node, since no rebalancing or comparison is needed.
 //!
 //!Experimental function
- static void replace_node(node_ptr node_to_be_replaced, node_ptr header, node_ptr new_node)
+ static void replace_node(const node_ptr & node_to_be_replaced, const node_ptr & header, const node_ptr & new_node)
 { tree_algorithms::replace_node(node_to_be_replaced, header, new_node); }

 //! Requires: node is a tree node but not the header.
@@ -192,7 +191,7 @@
 //! Complexity: Average complexity is constant time.
 //!
 //! Throws: Nothing.
- static void unlink(node_ptr node)
+ static void unlink(const node_ptr & node)
 {
 node_ptr x = NodeTraits::get_parent(node);
 if(x){
@@ -215,7 +214,7 @@
 //! only be used for more unlink_leftmost_without_rebalance calls.
 //! This function is normally used to achieve a step by step
 //! controlled destruction of the tree.
- static node_ptr unlink_leftmost_without_rebalance(node_ptr header)
+ static node_ptr unlink_leftmost_without_rebalance(const node_ptr & header)
 { return tree_algorithms::unlink_leftmost_without_rebalance(header); }

 //! Requires: node is a node of the tree or an node initialized
@@ -226,7 +225,7 @@
 //! Complexity: Constant time.
 //!
 //! Throws: Nothing.
- static bool unique(const_node_ptr node)
+ static bool unique(const const_node_ptr & node)
 { return tree_algorithms::unique(node); }

 //! Requires: node is a node of the tree but it's not the header.
@@ -236,7 +235,7 @@
 //! Complexity: Linear time.
 //!
 //! Throws: Nothing.
- static std::size_t count(const_node_ptr node)
+ static std::size_t count(const const_node_ptr & node)
 { return tree_algorithms::count(node); }

 //! Requires: header is the header node of the tree.
@@ -246,7 +245,7 @@
 //! Complexity: Linear time.
 //!
 //! Throws: Nothing.
- static std::size_t size(const_node_ptr header)
+ static std::size_t size(const const_node_ptr & header)
 { return tree_algorithms::size(header); }

 //! Requires: p is a node from the tree except the header.
@@ -256,7 +255,7 @@
 //! Complexity: Average constant time.
 //!
 //! Throws: Nothing.
- static node_ptr next_node(node_ptr p)
+ static node_ptr next_node(const node_ptr & p)
 { return tree_algorithms::next_node(p); }

 //! Requires: p is a node from the tree except the leftmost node.
@@ -266,7 +265,7 @@
 //! Complexity: Average constant time.
 //!
 //! Throws: Nothing.
- static node_ptr prev_node(node_ptr p)
+ static node_ptr prev_node(const node_ptr & p)
 { return tree_algorithms::prev_node(p); }

 //! Requires: node must not be part of any tree.
@@ -278,7 +277,7 @@
 //! Throws: Nothing.
 //!
 //! Nodes: If node is inserted in a tree, this function corrupts the tree.
- static void init(node_ptr node)
+ static void init(const node_ptr & node)
 { tree_algorithms::init(node); }

 //! Requires: node must not be part of any tree.
@@ -291,7 +290,7 @@
 //! Throws: Nothing.
 //!
 //! Nodes: If node is inserted in a tree, this function corrupts the tree.
- static void init_header(node_ptr header)
+ static void init_header(const node_ptr & header)
 { tree_algorithms::init_header(header); }

 //! Requires: header must be the header of a tree, z a node
@@ -303,7 +302,7 @@
 //!
 //! Throws: Nothing.
 template<class AlphaByMaxSize>
- static node_ptr erase(node_ptr header, node_ptr z, std::size_t tree_size, std::size_t &max_tree_size, AlphaByMaxSize alpha_by_maxsize)
+ static node_ptr erase(const node_ptr & header, const node_ptr & z, std::size_t tree_size, std::size_t &max_tree_size, AlphaByMaxSize alpha_by_maxsize)
 {
 //typename tree_algorithms::data_for_rebalance info;
 tree_algorithms::erase(header, z);
@@ -321,13 +320,13 @@
 //! take a node_ptr and shouldn't throw.
 //!
 //! Effects: First empties target tree calling
- //! <tt>void disposer::operator()(node_ptr)</tt> for every node of the tree
+ //! <tt>void disposer::operator()(const node_ptr &)</tt> for every node of the tree
 //! except the header.
 //!
 //! Then, duplicates the entire tree pointed by "source_header" cloning each
- //! source node with <tt>node_ptr Cloner::operator()(node_ptr)</tt> to obtain
+ //! source node with <tt>node_ptr Cloner::operator()(const node_ptr &)</tt> to obtain
 //! the nodes of the target tree. If "cloner" throws, the cloned target nodes
- //! are disposed using <tt>void disposer(node_ptr)</tt>.
+ //! are disposed using <tt>void disposer(const node_ptr &)</tt>.
 //!
 //! Complexity: Linear to the number of element of the source tree plus the.
 //! number of elements of tree target tree when calling this function.
@@ -335,7 +334,7 @@
 //! Throws: If cloner functor throws. If this happens target nodes are disposed.
 template <class Cloner, class Disposer>
 static void clone
- (const_node_ptr source_header, node_ptr target_header, Cloner cloner, Disposer disposer)
+ (const const_node_ptr & source_header, const node_ptr & target_header, Cloner cloner, Disposer disposer)
 {
 tree_algorithms::clone(source_header, target_header, cloner, disposer);
 }
@@ -344,7 +343,7 @@
 //! taking a node_ptr parameter and shouldn't throw.
 //!
 //! Effects: Empties the target tree calling
- //! <tt>void disposer::operator()(node_ptr)</tt> for every node of the tree
+ //! <tt>void disposer::operator()(const node_ptr &)</tt> for every node of the tree
 //! except the header.
 //!
 //! Complexity: Linear to the number of element of the source tree plus the.
@@ -352,7 +351,7 @@
 //!
 //! Throws: If cloner functor throws. If this happens target nodes are disposed.
 template<class Disposer>
- static void clear_and_dispose(node_ptr header, Disposer disposer)
+ static void clear_and_dispose(const node_ptr & header, Disposer disposer)
 { tree_algorithms::clear_and_dispose(header, disposer); }

 //! Requires: "header" must be the header node of a tree.
@@ -369,7 +368,7 @@
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static node_ptr lower_bound
- (const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp)
+ (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp)
 { return tree_algorithms::lower_bound(header, key, comp); }

 //! Requires: "header" must be the header node of a tree.
@@ -385,7 +384,7 @@
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static node_ptr upper_bound
- (const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp)
+ (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp)
 { return tree_algorithms::upper_bound(header, key, comp); }

 //! Requires: "header" must be the header node of a tree.
@@ -401,7 +400,7 @@
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static node_ptr find
- (const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp)
+ (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp)
 { return tree_algorithms::find(header, key, comp); }

 //! Requires: "header" must be the header node of a tree.
@@ -419,7 +418,7 @@
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static std::pair<node_ptr, node_ptr> equal_range
- (const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp)
+ (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp)
 { return tree_algorithms::equal_range(header, key, comp); }

 //! Requires: "h" must be the header node of a tree.
@@ -436,7 +435,7 @@
 //! Throws: If "comp" throws.
 template<class NodePtrCompare, class H_Alpha>
 static node_ptr insert_equal_upper_bound
- (node_ptr h, node_ptr new_node, NodePtrCompare comp
+ (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp
 ,std::size_t tree_size, H_Alpha h_alpha, std::size_t &max_tree_size)
 {
 std::size_t depth;
@@ -459,7 +458,7 @@
 //! Throws: If "comp" throws.
 template<class NodePtrCompare, class H_Alpha>
 static node_ptr insert_equal_lower_bound
- (node_ptr h, node_ptr new_node, NodePtrCompare comp
+ (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp
 ,std::size_t tree_size, H_Alpha h_alpha, std::size_t &max_tree_size)
 {
 std::size_t depth;
@@ -484,7 +483,7 @@
 //! Throws: If "comp" throws.
 template<class NodePtrCompare, class H_Alpha>
 static node_ptr insert_equal
- (node_ptr header, node_ptr hint, node_ptr new_node, NodePtrCompare comp
+ (const node_ptr & header, const node_ptr & hint, const node_ptr & new_node, NodePtrCompare comp
 ,std::size_t tree_size, H_Alpha h_alpha, std::size_t &max_tree_size)
 {
 std::size_t depth;
@@ -529,7 +528,7 @@
 //! if no more objects are inserted or erased from the set.
 template<class KeyType, class KeyNodePtrCompare>
 static std::pair<node_ptr, bool> insert_unique_check
- (const_node_ptr header, const KeyType &key
+ (const const_node_ptr & header, const KeyType &key
 ,KeyNodePtrCompare comp, insert_commit_data &commit_data)
 {
 std::size_t depth;
@@ -556,7 +555,7 @@
 //! tree invariants might be broken.
 template<class H_Alpha>
 static node_ptr insert_before
- (node_ptr header, node_ptr pos, node_ptr new_node
+ (const node_ptr & header, const node_ptr & pos, const node_ptr & new_node
 ,std::size_t tree_size, H_Alpha h_alpha, std::size_t &max_tree_size)
 {
 std::size_t depth;
@@ -579,7 +578,7 @@
 //! tree invariants are broken. This function is slightly faster than
 //! using "insert_before".
 template<class H_Alpha>
- static void push_back(node_ptr header, node_ptr new_node
+ static void push_back(const node_ptr & header, const node_ptr & new_node
 ,std::size_t tree_size, H_Alpha h_alpha, std::size_t &max_tree_size)
 {
 std::size_t depth;
@@ -601,7 +600,7 @@
 //! tree invariants are broken. This function is slightly faster than
 //! using "insert_before".
 template<class H_Alpha>
- static void push_front(node_ptr header, node_ptr new_node
+ static void push_front(const node_ptr & header, const node_ptr & new_node
 ,std::size_t tree_size, H_Alpha h_alpha, std::size_t &max_tree_size)
 {
 std::size_t depth;
@@ -650,7 +649,7 @@
 //! if no more objects are inserted or erased from the set.
 template<class KeyType, class KeyNodePtrCompare>
 static std::pair<node_ptr, bool> insert_unique_check
- (const_node_ptr header, node_ptr hint, const KeyType &key
+ (const const_node_ptr & header, const node_ptr &hint, const KeyType &key
 ,KeyNodePtrCompare comp, insert_commit_data &commit_data)
 {
 std::size_t depth;
@@ -680,7 +679,7 @@
 //! erased between the "insert_check" and "insert_commit" calls.
 template<class H_Alpha>
 static void insert_unique_commit
- (node_ptr header, node_ptr new_value, const insert_commit_data &commit_data
+ (const node_ptr & header, const node_ptr & new_value, const insert_commit_data &commit_data
 ,std::size_t tree_size, H_Alpha h_alpha, std::size_t &max_tree_size)
 {
 tree_algorithms::insert_unique_commit(header, new_value, commit_data);
@@ -694,7 +693,7 @@
 //! Throws: Nothing.
 //!
 //! Complexity: Linear.
- static void rebalance(node_ptr header)
+ static void rebalance(const node_ptr & header)
 { tree_algorithms::rebalance(header); }

 //! Requires: old_root is a node of a tree.
@@ -706,7 +705,7 @@
 //! Throws: Nothing.
 //!
 //! Complexity: Linear.
- static node_ptr rebalance_subtree(node_ptr old_root)
+ static node_ptr rebalance_subtree(const node_ptr & old_root)
 { return tree_algorithms::rebalance_subtree(old_root); }

 //! Requires: "n" must be a node inserted in a tree.
@@ -716,7 +715,7 @@
 //! Complexity: Logarithmic.
 //!
 //! Throws: Nothing.
- static node_ptr get_header(node_ptr n)
+ static node_ptr get_header(const node_ptr & n)
 { return tree_algorithms::get_header(n); }

 /// @cond
@@ -729,12 +728,12 @@
 //! Complexity: Constant.
 //!
 //! Throws: Nothing.
- static bool is_header(const_node_ptr p)
+ static bool is_header(const const_node_ptr & p)
 { return tree_algorithms::is_header(p); }

 template<class H_Alpha>
 static void rebalance_after_insertion
- ( node_ptr x, std::size_t depth
+ (const node_ptr &x, std::size_t depth
 , std::size_t tree_size, H_Alpha h_alpha, std::size_t &max_tree_size)
 {
 if(tree_size > max_tree_size)

Modified: branches/release/boost/intrusive/slist.hpp
==============================================================================
--- branches/release/boost/intrusive/slist.hpp (original)
+++ branches/release/boost/intrusive/slist.hpp 2011-12-26 12:10:27 EST (Mon, 26 Dec 2011)
@@ -21,7 +21,7 @@
#include <boost/intrusive/slist_hook.hpp>
#include <boost/intrusive/circular_slist_algorithms.hpp>
#include <boost/intrusive/linear_slist_algorithms.hpp>
-#include <boost/intrusive/detail/pointer_to_other.hpp>
+#include <boost/intrusive/pointer_traits.hpp>
#include <boost/intrusive/detail/clear_on_destructor_base.hpp>
#include <boost/intrusive/link_mode.hpp>
#include <boost/intrusive/options.hpp>
@@ -121,10 +121,10 @@
 /// @endcond
 typedef typename real_value_traits::pointer pointer;
 typedef typename real_value_traits::const_pointer const_pointer;
- typedef typename std::iterator_traits<pointer>::value_type value_type;
- typedef typename std::iterator_traits<pointer>::reference reference;
- typedef typename std::iterator_traits<const_pointer>::reference const_reference;
- typedef typename std::iterator_traits<pointer>::difference_type difference_type;
+ typedef typename pointer_traits<pointer>::element_type value_type;
+ typedef typename pointer_traits<pointer>::reference reference;
+ typedef typename pointer_traits<const_pointer>::reference const_reference;
+ typedef typename pointer_traits<pointer>::difference_type difference_type;
 typedef typename Config::size_type size_type;
 typedef slist_iterator<slist_impl, false> iterator;
 typedef slist_iterator<slist_impl, true> const_iterator;
@@ -163,18 +163,18 @@
 BOOST_STATIC_ASSERT(!(cache_last && ((int)real_value_traits::link_mode == (int)auto_unlink)));

 node_ptr get_end_node()
- { return node_ptr(linear ? node_ptr(0) : this->get_root_node()); }
+ { return node_ptr(linear ? node_ptr() : this->get_root_node()); }

 const_node_ptr get_end_node() const
 {
 return const_node_ptr
- (linear ? const_node_ptr(0) : this->get_root_node()); }
+ (linear ? const_node_ptr() : this->get_root_node()); }

 node_ptr get_root_node()
- { return node_ptr(&data_.root_plus_size_.root_); }
+ { return pointer_traits<node_ptr>::pointer_to(data_.root_plus_size_.root_); }

 const_node_ptr get_root_node() const
- { return const_node_ptr(&data_.root_plus_size_.root_); }
+ { return pointer_traits<const_node_ptr>::pointer_to(data_.root_plus_size_.root_); }

 node_ptr get_last_node()
 { return this->get_last_node(detail::bool_<cache_last>()); }
@@ -182,13 +182,13 @@
 const_node_ptr get_last_node() const
 { return this->get_last_node(detail::bool_<cache_last>()); }

- void set_last_node(node_ptr n)
+ void set_last_node(const node_ptr &n)
 { return this->set_last_node(n, detail::bool_<cache_last>()); }

 static node_ptr get_last_node(detail::bool_<false>)
- { return node_ptr(0); }
+ { return node_ptr(); }

- static void set_last_node(node_ptr, detail::bool_<false>)
+ static void set_last_node(const node_ptr &, detail::bool_<false>)
 {}

 node_ptr get_last_node(detail::bool_<true>)
@@ -197,12 +197,11 @@
 const_node_ptr get_last_node(detail::bool_<true>) const
 { return const_node_ptr(data_.root_plus_size_.last_); }

- void set_last_node(node_ptr n, detail::bool_<true>)
+ void set_last_node(const node_ptr & n, detail::bool_<true>)
 { data_.root_plus_size_.last_ = n; }

- static node_ptr uncast(const_node_ptr ptr)
- { return node_ptr(const_cast<node*>(detail::boost_intrusive_get_pointer(ptr))); }
-//iG pending { return boost::const_pointer_cast<node>(ptr); }
+ static node_ptr uncast(const const_node_ptr & ptr)
+ { return pointer_traits<node_ptr>::const_cast_from(ptr); }

 void set_default_constructed_state()
 {
@@ -406,7 +405,7 @@
 //! This function is only available is cache_last<> is true.
 void push_back(reference value)
 {
- BOOST_STATIC_ASSERT((cache_last != 0));
+ BOOST_STATIC_ASSERT((cache_last));
 this->insert_after(const_iterator(this->get_last_node(), this), value);
 }

@@ -473,7 +472,7 @@
 //! This function is only available is cache_last<> is true.
 reference back()
 {
- BOOST_STATIC_ASSERT((cache_last != 0));
+ BOOST_STATIC_ASSERT((cache_last));
 return *this->get_real_value_traits().to_value_ptr(this->get_last_node());
 }

@@ -487,7 +486,7 @@
 //! This function is only available is cache_last<> is true.
 const_reference back() const
 {
- BOOST_STATIC_ASSERT((cache_last != 0));
+ BOOST_STATIC_ASSERT((cache_last));
 return *this->get_real_value_traits().to_value_ptr(this->get_last_node());
 }

@@ -835,7 +834,7 @@
 node_ptr bfp = before_first.pointed_node();
 node_ptr lp = last.pointed_node();
 if(cache_last){
- if((lp == this->get_end_node())){
+ if(lp == this->get_end_node()){
 this->set_last_node(bfp);
 }
 }
@@ -1110,7 +1109,8 @@
 this->insert_after(this->cbefore_begin(), b, e, disposer);
 }

- //! Requires: prev is an iterator to an element or x.end()/x.before_begin() in x.
+ //! Requires: prev must point to an element contained by this list or
+ //! to the before_begin() element
 //!
 //! Effects: Transfers all the elements of list x to this list, after the
 //! the element pointed by prev. No destructors or copy constructors are called.
@@ -1226,7 +1226,7 @@
 }
 }

- //! Requires: it is an iterator to an element in x.
+ //! Requires: it is an iterator to an element in *this.
 //!
 //! Effects: Transfers all the elements of list x to this list, before the
 //! the element pointed by it. No destructors or copy constructors are called.
@@ -1743,7 +1743,7 @@
 //!
 //! Note: 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 incorporate_after(const_iterator prev_from, node_ptr first, node_ptr before_last)
+ void incorporate_after(const_iterator prev_from, const node_ptr & first, const node_ptr & before_last)
 {
 if(constant_time_size)
 this->incorporate_after(prev_from, first, before_last, std::distance(first, before_last)+1);
@@ -1766,7 +1766,7 @@
 //!
 //! Note: 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 incorporate_after(const_iterator prev_pos, node_ptr first, node_ptr before_last, difference_type n)
+ void incorporate_after(const_iterator prev_pos, const node_ptr & first, const node_ptr & before_last, difference_type n)
 {
 if(n){
 BOOST_INTRUSIVE_INVARIANT_ASSERT(std::distance(iterator(first, this), iterator(before_last, this))+1 == n);
@@ -1778,7 +1778,7 @@
 }

 private:
- void priv_splice_after(node_ptr prev_pos_n, slist_impl &x, node_ptr before_first_n, node_ptr before_last_n)
+ void priv_splice_after(const node_ptr & prev_pos_n, slist_impl &x, const node_ptr & before_first_n, const node_ptr & before_last_n)
 {
 if (before_first_n != before_last_n && prev_pos_n != before_first_n && prev_pos_n != before_last_n)
 {
@@ -1794,7 +1794,7 @@
 }
 }

- void priv_incorporate_after(node_ptr prev_pos_n, node_ptr first_n, node_ptr before_last_n)
+ void priv_incorporate_after(const node_ptr & prev_pos_n, const node_ptr & first_n, const node_ptr & before_last_n)
 {
 if(cache_last){
 if(node_traits::get_next(prev_pos_n) == this->get_end_node()){
@@ -1894,11 +1894,11 @@
 }

 //circular version
- static void priv_swap_lists(node_ptr this_node, node_ptr other_node, detail::bool_<false>)
+ static void priv_swap_lists(const node_ptr & this_node, const node_ptr & other_node, detail::bool_<false>)
 { node_algorithms::swap_nodes(this_node, other_node); }

 //linear version
- static void priv_swap_lists(node_ptr this_node, node_ptr other_node, detail::bool_<true>)
+ static void priv_swap_lists(const node_ptr & this_node, const node_ptr & other_node, detail::bool_<true>)
 { node_algorithms::swap_trailing_nodes(this_node, other_node); }

 static slist_impl &priv_container_from_end_iterator(const const_iterator &end_iterator)
@@ -1907,7 +1907,7 @@
 //singly linked lists (because "end" is represented by the null pointer)
 BOOST_STATIC_ASSERT(!linear);
 root_plus_size *r = detail::parent_from_member<root_plus_size, node>
- ( detail::boost_intrusive_get_pointer(end_iterator.pointed_node()), (&root_plus_size::root_));
+ ( boost::intrusive::detail::to_raw_pointer(end_iterator.pointed_node()), (&root_plus_size::root_));
 data_t *d = detail::parent_from_member<data_t, root_plus_size>
 ( r, &data_t::root_plus_size_);
 slist_impl *s = detail::parent_from_member<slist_impl, data_t>(d, &slist_impl::data_);

Modified: branches/release/boost/intrusive/splaytree.hpp
==============================================================================
--- branches/release/boost/intrusive/splaytree.hpp (original)
+++ branches/release/boost/intrusive/splaytree.hpp 2011-12-26 12:10:27 EST (Mon, 26 Dec 2011)
@@ -21,12 +21,14 @@
#include <boost/intrusive/detail/assert.hpp>
#include <boost/static_assert.hpp>
#include <boost/intrusive/intrusive_fwd.hpp>
-#include <boost/intrusive/detail/pointer_to_other.hpp>
+#include <boost/intrusive/pointer_traits.hpp>
#include <boost/intrusive/splay_set_hook.hpp>
#include <boost/intrusive/detail/tree_node.hpp>
#include <boost/intrusive/detail/ebo_functor_holder.hpp>
#include <boost/intrusive/detail/clear_on_destructor_base.hpp>
#include <boost/intrusive/detail/mpl.hpp>
+#include <boost/intrusive/detail/utilities.hpp>
+#include <boost/intrusive/pointer_traits.hpp>
#include <boost/intrusive/options.hpp>
#include <boost/intrusive/splaytree_algorithms.hpp>
#include <boost/intrusive/link_mode.hpp>
@@ -95,24 +97,26 @@
 /// @endcond
 typedef typename real_value_traits::pointer pointer;
 typedef typename real_value_traits::const_pointer const_pointer;
- typedef typename std::iterator_traits<pointer>::value_type value_type;
- typedef value_type key_type;
- typedef typename std::iterator_traits<pointer>::reference reference;
- typedef typename std::iterator_traits<const_pointer>::reference const_reference;
- typedef typename std::iterator_traits<pointer>::difference_type difference_type;
+ typedef typename pointer_traits<pointer>::element_type value_type;
+ typedef typename pointer_traits<pointer>::reference reference;
+ typedef typename pointer_traits<const_pointer>::reference const_reference;
+ typedef typename pointer_traits<pointer>::difference_type difference_type;
 typedef typename Config::size_type size_type;
+ typedef value_type key_type;
 typedef typename Config::compare value_compare;
 typedef value_compare key_compare;
 typedef tree_iterator<splaytree_impl, false> iterator;
 typedef tree_iterator<splaytree_impl, true> const_iterator;
- typedef std::reverse_iterator<iterator> reverse_iterator;
- typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+ typedef boost::intrusive::detail::reverse_iterator<iterator> reverse_iterator;
+ typedef boost::intrusive::detail::reverse_iterator<const_iterator>const_reverse_iterator;
 typedef typename real_value_traits::node_traits node_traits;
 typedef typename node_traits::node node;
- typedef typename boost::pointer_to_other
- <pointer, node>::type node_ptr;
- typedef typename boost::pointer_to_other
- <node_ptr, const node>::type const_node_ptr;
+ typedef typename pointer_traits
+ <pointer>::template rebind_pointer
+ <node>::type node_ptr;
+ typedef typename pointer_traits
+ <pointer>::template rebind_pointer
+ <const node>::type const_node_ptr;
 typedef splaytree_algorithms<node_traits> node_algorithms;

 static const bool constant_time_size = Config::constant_time_size;
@@ -164,16 +168,14 @@
 value_traits &priv_value_traits()
 { return data_; }

- const node &priv_header() const
- { return data_.node_plus_pred_.header_plus_size_.header_; }
+ node_ptr priv_header_ptr()
+ { return pointer_traits<node_ptr>::pointer_to(data_.node_plus_pred_.header_plus_size_.header_); }

- node &priv_header()
- { return data_.node_plus_pred_.header_plus_size_.header_; }
+ const_node_ptr priv_header_ptr() const
+ { return pointer_traits<const_node_ptr>::pointer_to(data_.node_plus_pred_.header_plus_size_.header_); }

- static node_ptr uncast(const_node_ptr ptr)
- {
- return node_ptr(const_cast<node*>(detail::boost_intrusive_get_pointer(ptr)));
- }
+ static node_ptr uncast(const const_node_ptr & ptr)
+ { return pointer_traits<node_ptr>::const_cast_from(ptr); }

 size_traits &priv_size_traits()
 { return data_.node_plus_pred_.header_plus_size_; }
@@ -216,7 +218,7 @@
 , const value_traits &v_traits = value_traits())
 : data_(cmp, v_traits)
 {
- node_algorithms::init_header(&priv_header());
+ node_algorithms::init_header(this->priv_header_ptr());
 this->priv_size_traits().set_size(size_type(0));
 }

@@ -238,7 +240,7 @@
 , const value_traits &v_traits = value_traits())
 : data_(cmp, v_traits)
 {
- node_algorithms::init_header(&priv_header());
+ node_algorithms::init_header(this->priv_header_ptr());
 this->priv_size_traits().set_size(size_type(0));
 if(unique)
 this->insert_unique(b, e);
@@ -251,7 +253,7 @@
 splaytree_impl(BOOST_RV_REF(splaytree_impl) x)
 : data_(::boost::move(x.priv_comp()), ::boost::move(x.priv_value_traits()))
 {
- node_algorithms::init_header(&priv_header());
+ node_algorithms::init_header(this->priv_header_ptr());
 this->priv_size_traits().set_size(size_type(0));
 this->swap(x);
 }
@@ -278,7 +280,7 @@
 //!
 //! Throws: Nothing.
 iterator begin()
- { return iterator(node_algorithms::begin_node(&priv_header()), this); }
+ { return iterator(node_algorithms::begin_node(this->priv_header_ptr()), this); }

 //! Effects: Returns a const_iterator pointing to the beginning of the tree.
 //!
@@ -294,7 +296,7 @@
 //!
 //! Throws: Nothing.
 const_iterator cbegin() const
- { return const_iterator(node_algorithms::begin_node(&priv_header()), this); }
+ { return const_iterator(node_algorithms::begin_node(this->priv_header_ptr()), this); }

 //! Effects: Returns an iterator pointing to the end of the tree.
 //!
@@ -302,7 +304,7 @@
 //!
 //! Throws: Nothing.
 iterator end()
- { return iterator (node_ptr(&priv_header()), this); }
+ { return iterator (this->priv_header_ptr(), this); }

 //! Effects: Returns a const_iterator pointing to the end of the tree.
 //!
@@ -318,7 +320,7 @@
 //!
 //! Throws: Nothing.
 const_iterator cend() const
- { return const_iterator (uncast(const_node_ptr(&priv_header())), this); }
+ { return const_iterator (uncast(this->priv_header_ptr()), this); }

 //! Effects: Returns a reverse_iterator pointing to the beginning of the
 //! reversed tree.
@@ -446,7 +448,7 @@
 return this->priv_size_traits().get_size();
 }
 else{
- return (size_type)node_algorithms::size(const_node_ptr(&priv_header()));
+ return (size_type)node_algorithms::size(this->priv_header_ptr());
 }
 }

@@ -461,7 +463,7 @@
 using std::swap;
 swap(priv_comp(), priv_comp());
 //These can't throw
- node_algorithms::swap_tree(node_ptr(&priv_header()), node_ptr(&other.priv_header()));
+ node_algorithms::swap_tree(this->priv_header_ptr(), other.priv_header_ptr());
 if(constant_time_size){
 size_type backup = this->priv_size_traits().get_size();
 this->priv_size_traits().set_size(other.priv_size_traits().get_size());
@@ -488,7 +490,7 @@
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
 iterator ret (node_algorithms::insert_equal_lower_bound
- (node_ptr(&priv_header()), to_insert, key_node_comp), this);
+ (this->priv_header_ptr(), to_insert, key_node_comp), this);
 this->priv_size_traits().increment();
 return ret;
 }
@@ -515,7 +517,7 @@
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
 iterator ret(node_algorithms::insert_equal
- (node_ptr(&priv_header()), hint.pointed_node(), to_insert, key_node_comp), this);
+ (this->priv_header_ptr(), hint.pointed_node(), to_insert, key_node_comp), this);
 this->priv_size_traits().increment();
 return ret;
 }
@@ -645,7 +647,7 @@
 comp(key_value_comp, this);
 std::pair<node_ptr, bool> ret =
 (node_algorithms::insert_unique_check
- (node_ptr(&priv_header()), key, comp, commit_data));
+ (this->priv_header_ptr(), key, comp, commit_data));
 return std::pair<iterator, bool>(iterator(ret.first, this), ret.second);
 }

@@ -690,7 +692,7 @@
 comp(key_value_comp, this);
 std::pair<node_ptr, bool> ret =
 node_algorithms::insert_unique_check
- (node_ptr(&priv_header()), hint.pointed_node(), key, comp, commit_data);
+ (this->priv_header_ptr(), hint.pointed_node(), key, comp, commit_data);
 return std::pair<iterator, bool>(iterator(ret.first, this), ret.second);
 }

@@ -717,7 +719,7 @@
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
 node_algorithms::insert_unique_commit
- (node_ptr(&priv_header()), to_insert, commit_data);
+ (this->priv_header_ptr(), to_insert, commit_data);
 this->priv_size_traits().increment();
 return iterator(to_insert, this);
 }
@@ -737,7 +739,7 @@
 node_ptr to_erase(i.pointed_node());
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!node_algorithms::unique(to_erase));
- node_algorithms::erase(&priv_header(), to_erase);
+ node_algorithms::erase(this->priv_header_ptr(), to_erase);
 this->priv_size_traits().decrement();
 if(safemode_or_autounlink)
 node_algorithms::init(to_erase);
@@ -899,7 +901,7 @@
 this->clear_and_dispose(detail::null_disposer());
 }
 else{
- node_algorithms::init_header(&priv_header());
+ node_algorithms::init_header(this->priv_header_ptr());
 this->priv_size_traits().set_size(0);
 }
 }
@@ -916,7 +918,7 @@
 template<class Disposer>
 void clear_and_dispose(Disposer disposer)
 {
- node_algorithms::clear_and_dispose(node_ptr(&priv_header())
+ node_algorithms::clear_and_dispose(this->priv_header_ptr()
 , detail::node_disposer<Disposer, splaytree_impl>(disposer, this));
 this->priv_size_traits().set_size(0);
 }
@@ -995,7 +997,7 @@
 detail::key_nodeptr_comp<KeyValueCompare, splaytree_impl>
 key_node_comp(comp, this);
 return iterator(node_algorithms::lower_bound
- (const_node_ptr(&priv_header()), key, key_node_comp), this);
+ (this->priv_header_ptr(), key, key_node_comp), this);
 }

 //! Effects: Returns a const iterator to the first element whose
@@ -1010,7 +1012,7 @@
 detail::key_nodeptr_comp<KeyValueCompare, splaytree_impl>
 key_node_comp(comp, this);
 return const_iterator(node_algorithms::lower_bound
- (const_node_ptr(&priv_header()), key, key_node_comp, false), this);
+ (this->priv_header_ptr(), key, key_node_comp, false), this);
 }

 //! Effects: Returns an iterator to the first element whose
@@ -1035,7 +1037,7 @@
 detail::key_nodeptr_comp<KeyValueCompare, splaytree_impl>
 key_node_comp(comp, this);
 return iterator(node_algorithms::upper_bound
- (const_node_ptr(&priv_header()), key, key_node_comp), this);
+ (this->priv_header_ptr(), key, key_node_comp), this);
 }

 //! Effects: Returns an iterator to the first element whose
@@ -1060,7 +1062,7 @@
 detail::key_nodeptr_comp<KeyValueCompare, splaytree_impl>
 key_node_comp(comp, this);
 return const_iterator(node_algorithms::upper_bound_dont_splay
- (const_node_ptr(&priv_header()), key, key_node_comp, false), this);
+ (this->priv_header_ptr(), key, key_node_comp, false), this);
 }

 //! Effects: Finds an iterator to the first element whose key is
@@ -1084,7 +1086,7 @@
 detail::key_nodeptr_comp<KeyValueCompare, splaytree_impl>
 key_node_comp(comp, this);
 return iterator
- (node_algorithms::find(const_node_ptr(&priv_header()), key, key_node_comp), this);
+ (node_algorithms::find(this->priv_header_ptr(), key, key_node_comp), this);
 }

 //! Effects: Finds a const_iterator to the first element whose key is
@@ -1108,7 +1110,7 @@
 detail::key_nodeptr_comp<KeyValueCompare, splaytree_impl>
 key_node_comp(comp, this);
 return const_iterator
- (node_algorithms::find(const_node_ptr(&priv_header()), key, key_node_comp, false), this);
+ (node_algorithms::find(this->priv_header_ptr(), key, key_node_comp, false), this);
 }

 //! Effects: Finds a range containing all elements whose key is k or
@@ -1134,7 +1136,7 @@
 detail::key_nodeptr_comp<KeyValueCompare, splaytree_impl>
 key_node_comp(comp, this);
 std::pair<node_ptr, node_ptr> ret
- (node_algorithms::equal_range(const_node_ptr(&priv_header()), key, key_node_comp));
+ (node_algorithms::equal_range(this->priv_header_ptr(), key, key_node_comp));
 return std::pair<iterator, iterator>(iterator(ret.first, this), iterator(ret.second, this));
 }

@@ -1163,7 +1165,7 @@
 detail::key_nodeptr_comp<KeyValueCompare, splaytree_impl>
 key_node_comp(comp, this);
 std::pair<node_ptr, node_ptr> ret
- (node_algorithms::equal_range(const_node_ptr(&priv_header()), key, key_node_comp, false));
+ (node_algorithms::equal_range(this->priv_header_ptr(), key, key_node_comp, false));
 return std::pair<const_iterator, const_iterator>(const_iterator(ret.first, this), const_iterator(ret.second, this));
 }

@@ -1189,8 +1191,8 @@
 detail::exception_disposer<splaytree_impl, Disposer>
 rollback(*this, disposer);
 node_algorithms::clone
- (const_node_ptr(&src.priv_header())
- ,node_ptr(&this->priv_header())
+ (src.priv_header_ptr()
+ ,this->priv_header_ptr()
 ,detail::node_cloner<Cloner, splaytree_impl>(cloner, this)
 ,detail::node_disposer<Disposer, splaytree_impl>(disposer, this));
 this->priv_size_traits().set_size(src.priv_size_traits().get_size());
@@ -1212,7 +1214,7 @@
 pointer unlink_leftmost_without_rebalance()
 {
 node_ptr to_be_disposed(node_algorithms::unlink_leftmost_without_rebalance
- (node_ptr(&priv_header())));
+ (this->priv_header_ptr()));
 if(!to_be_disposed)
 return 0;
 this->priv_size_traits().decrement();
@@ -1230,7 +1232,7 @@
 //!
 //! Throws: Nothing.
 void splay_up(iterator i)
- { return node_algorithms::splay_up(i.pointed_node(), &priv_header()); }
+ { return node_algorithms::splay_up(i.pointed_node(), this->priv_header_ptr()); }

 //! Effects: Rearranges the splay set so that if *this stores an element
 //! with a key equivalent to value the element is placed as the root of the
@@ -1247,7 +1249,7 @@
 {
 detail::key_nodeptr_comp<KeyValueCompare, splaytree_impl>
 key_node_comp(comp, this);
- node_ptr r = node_algorithms::splay_down(&priv_header(), key, key_node_comp);
+ node_ptr r = node_algorithms::splay_down(this->priv_header_ptr(), key, key_node_comp);
 return iterator(r, this);
 }

@@ -1280,7 +1282,7 @@
 void replace_node(iterator replace_this, reference with_this)
 {
 node_algorithms::replace_node( get_real_value_traits().to_node_ptr(*replace_this)
- , node_ptr(&priv_header())
+ , this->priv_header_ptr()
 , get_real_value_traits().to_node_ptr(with_this));
 if(safemode_or_autounlink)
 node_algorithms::init(replace_this.pointed_node());
@@ -1366,7 +1368,7 @@
 //!
 //! Complexity: Linear.
 void rebalance()
- { node_algorithms::rebalance(node_ptr(&priv_header())); }
+ { node_algorithms::rebalance(this->priv_header_ptr()); }

 //! Requires: old_root is a node of a tree.
 //!
@@ -1430,7 +1432,7 @@
 static splaytree_impl &priv_container_from_end_iterator(const const_iterator &end_iterator)
 {
 header_plus_size *r = detail::parent_from_member<header_plus_size, node>
- ( detail::boost_intrusive_get_pointer(end_iterator.pointed_node()), &header_plus_size::header_);
+ ( boost::intrusive::detail::to_raw_pointer(end_iterator.pointed_node()), &header_plus_size::header_);
 node_plus_pred_t *n = detail::parent_from_member
 <node_plus_pred_t, header_plus_size>(r, &node_plus_pred_t::header_plus_size_);
 data_t *d = detail::parent_from_member<data_t, node_plus_pred_t>(n, &data_t::node_plus_pred_);

Modified: branches/release/boost/intrusive/splaytree_algorithms.hpp
==============================================================================
--- branches/release/boost/intrusive/splaytree_algorithms.hpp (original)
+++ branches/release/boost/intrusive/splaytree_algorithms.hpp 2011-12-26 12:10:27 EST (Mon, 26 Dec 2011)
@@ -49,6 +49,7 @@
#include <boost/intrusive/detail/config_begin.hpp>
#include <boost/intrusive/detail/assert.hpp>
#include <boost/intrusive/intrusive_fwd.hpp>
+#include <boost/intrusive/pointer_traits.hpp>
#include <cstddef>
#include <boost/intrusive/detail/utilities.hpp>
#include <boost/intrusive/detail/tree_algorithms.hpp>
@@ -63,8 +64,8 @@
struct splaydown_rollback
{
 typedef typename NodeTraits::node_ptr node_ptr;
- splaydown_rollback( const node_ptr *pcur_subtree, node_ptr header
- , node_ptr leftmost , node_ptr rightmost)
+ splaydown_rollback( const node_ptr *pcur_subtree, const node_ptr & header
+ , const node_ptr & leftmost , const node_ptr & rightmost)
 : pcur_subtree_(pcur_subtree) , header_(header)
 , leftmost_(leftmost) , rightmost_(rightmost)
 {}
@@ -145,17 +146,15 @@

 /// @cond
 private:
- static node_ptr uncast(const_node_ptr ptr)
- {
- return node_ptr(const_cast<node*>(::boost::intrusive::detail::boost_intrusive_get_pointer(ptr)));
- }
+ static node_ptr uncast(const const_node_ptr & ptr)
+ { return pointer_traits<node_ptr>::const_cast_from(ptr); }
 /// @endcond

 public:
- static node_ptr begin_node(const_node_ptr header)
+ static node_ptr begin_node(const const_node_ptr & header)
 { return tree_algorithms::begin_node(header); }

- static node_ptr end_node(const_node_ptr header)
+ static node_ptr end_node(const const_node_ptr & header)
 { return tree_algorithms::end_node(header); }

 //! Requires: node is a node of the tree or an node initialized
@@ -166,10 +165,10 @@
 //! Complexity: Constant time.
 //!
 //! Throws: Nothing.
- static bool unique(const_node_ptr node)
+ static bool unique(const const_node_ptr & node)
 { return tree_algorithms::unique(node); }

- static void unlink(node_ptr node)
+ static void unlink(const node_ptr & node)
 { tree_algorithms::unlink(node); }

 //! Requires: node1 and node2 can't be header nodes
@@ -187,7 +186,7 @@
 //! node1 and node2 are not equivalent according to the ordering rules.
 //!
 //!Experimental function
- static void swap_nodes(node_ptr node1, node_ptr node2)
+ static void swap_nodes(const node_ptr & node1, const node_ptr & node2)
 {
 if(node1 == node2)
 return;
@@ -211,7 +210,7 @@
 //! node1 and node2 are not equivalent according to the ordering rules.
 //!
 //!Experimental function
- static void swap_nodes(node_ptr node1, node_ptr header1, node_ptr node2, node_ptr header2)
+ static void swap_nodes(const node_ptr & node1, const node_ptr & header1, const node_ptr & node2, const node_ptr & header2)
 { tree_algorithms::swap_nodes(node1, header1, node2, header2); }

 //! Requires: node_to_be_replaced must be inserted in a tree
@@ -230,7 +229,7 @@
 //! the node, since no rebalancing and comparison is needed.
 //!
 //!Experimental function
- static void replace_node(node_ptr node_to_be_replaced, node_ptr new_node)
+ static void replace_node(const node_ptr & node_to_be_replaced, const node_ptr & new_node)
 {
 if(node_to_be_replaced == new_node)
 return;
@@ -253,7 +252,7 @@
 //! the node, since no rebalancing or comparison is needed.
 //!
 //!Experimental function
- static void replace_node(node_ptr node_to_be_replaced, node_ptr header, node_ptr new_node)
+ static void replace_node(const node_ptr & node_to_be_replaced, const node_ptr & header, const node_ptr & new_node)
 { tree_algorithms::replace_node(node_to_be_replaced, header, new_node); }

 //! Requires: p is a node from the tree except the header.
@@ -263,7 +262,7 @@
 //! Complexity: Average constant time.
 //!
 //! Throws: Nothing.
- static node_ptr next_node(node_ptr p)
+ static node_ptr next_node(const node_ptr & p)
 { return tree_algorithms::next_node(p); }

 //! Requires: p is a node from the tree except the leftmost node.
@@ -273,7 +272,7 @@
 //! Complexity: Average constant time.
 //!
 //! Throws: Nothing.
- static node_ptr prev_node(node_ptr p)
+ static node_ptr prev_node(const node_ptr & p)
 { return tree_algorithms::prev_node(p); }

 //! Requires: node must not be part of any tree.
@@ -285,7 +284,7 @@
 //! Throws: Nothing.
 //!
 //! Nodes: If node is inserted in a tree, this function corrupts the tree.
- static void init(node_ptr node)
+ static void init(const node_ptr & node)
 { tree_algorithms::init(node); }

 //! Requires: node must not be part of any tree.
@@ -298,14 +297,14 @@
 //! Throws: Nothing.
 //!
 //! Nodes: If node is inserted in a tree, this function corrupts the tree.
- static void init_header(node_ptr header)
+ static void init_header(const node_ptr & header)
 { tree_algorithms::init_header(header); }

 //! Requires: "disposer" must be an object function
 //! taking a node_ptr parameter and shouldn't throw.
 //!
 //! Effects: Empties the target tree calling
- //! <tt>void disposer::operator()(node_ptr)</tt> for every node of the tree
+ //! <tt>void disposer::operator()(const node_ptr &)</tt> for every node of the tree
 //! except the header.
 //!
 //! Complexity: Linear to the number of element of the source tree plus the.
@@ -313,7 +312,7 @@
 //!
 //! Throws: If cloner functor throws. If this happens target nodes are disposed.
 template<class Disposer>
- static void clear_and_dispose(node_ptr header, Disposer disposer)
+ static void clear_and_dispose(const node_ptr & header, Disposer disposer)
 { tree_algorithms::clear_and_dispose(header, disposer); }

 //! Requires: node is a node of the tree but it's not the header.
@@ -323,7 +322,7 @@
 //! Complexity: Linear time.
 //!
 //! Throws: Nothing.
- static std::size_t count(const_node_ptr node)
+ static std::size_t count(const const_node_ptr & node)
 { return tree_algorithms::count(node); }

 //! Requires: header is the header node of the tree.
@@ -333,7 +332,7 @@
 //! Complexity: Linear time.
 //!
 //! Throws: Nothing.
- static std::size_t size(const_node_ptr header)
+ static std::size_t size(const const_node_ptr & header)
 { return tree_algorithms::size(header); }

 //! Requires: header1 and header2 must be the header nodes
@@ -345,7 +344,7 @@
 //! Complexity: Constant.
 //!
 //! Throws: Nothing.
- static void swap_tree(node_ptr header1, node_ptr header2)
+ static void swap_tree(const node_ptr & header1, const node_ptr & header2)
 { return tree_algorithms::swap_tree(header1, header2); }

 //! Requires: "header" must be the header node of a tree.
@@ -366,7 +365,7 @@
 //! previously executed to fill "commit_data". No value should be inserted or
 //! erased between the "insert_check" and "insert_commit" calls.
 static void insert_unique_commit
- (node_ptr header, node_ptr new_value, const insert_commit_data &commit_data)
+ (const node_ptr & header, const node_ptr & new_value, const insert_commit_data &commit_data)
 { tree_algorithms::insert_unique_commit(header, new_value, commit_data); }

 //! Requires: "header" must be the header node of a tree.
@@ -405,7 +404,7 @@
 //! if no more objects are inserted or erased from the set.
 template<class KeyType, class KeyNodePtrCompare>
 static std::pair<node_ptr, bool> insert_unique_check
- (node_ptr header, const KeyType &key
+ (const node_ptr & header, const KeyType &key
 ,KeyNodePtrCompare comp, insert_commit_data &commit_data)
 {
 splay_down(header, key, comp);
@@ -414,14 +413,14 @@

 template<class KeyType, class KeyNodePtrCompare>
 static std::pair<node_ptr, bool> insert_unique_check
- (node_ptr header, node_ptr hint, const KeyType &key
+ (const node_ptr & header, const node_ptr &hint, const KeyType &key
 ,KeyNodePtrCompare comp, insert_commit_data &commit_data)
 {
 splay_down(header, key, comp);
 return tree_algorithms::insert_unique_check(header, hint, key, comp, commit_data);
 }

- static bool is_header(const_node_ptr p)
+ static bool is_header(const const_node_ptr & p)
 { return tree_algorithms::is_header(p); }

 //! Requires: "header" must be the header node of a tree.
@@ -437,7 +436,7 @@
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static node_ptr find
- (const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp, bool splay = true)
+ (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp, bool splay = true)
 {
 if(splay)
 splay_down(uncast(header), key, comp);
@@ -462,7 +461,7 @@
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static std::pair<node_ptr, node_ptr> equal_range
- (const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp, bool splay = true)
+ (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp, bool splay = true)
 {
 //if(splay)
 //splay_down(uncast(header), key, comp);
@@ -488,7 +487,7 @@
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static node_ptr lower_bound
- (const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp, bool splay = true)
+ (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp, bool splay = true)
 {
 //if(splay)
 //splay_down(uncast(header), key, comp);
@@ -511,7 +510,7 @@
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static node_ptr upper_bound
- (const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp, bool splay = true)
+ (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp, bool splay = true)
 {
 //if(splay)
 //splay_down(uncast(header), key, comp);
@@ -537,7 +536,7 @@
 //! Throws: If "comp" throws.
 template<class NodePtrCompare>
 static node_ptr insert_equal
- (node_ptr header, node_ptr hint, node_ptr new_node, NodePtrCompare comp)
+ (const node_ptr & header, const node_ptr & hint, const node_ptr & new_node, NodePtrCompare comp)
 {
 splay_down(header, new_node, comp);
 return tree_algorithms::insert_equal(header, hint, new_node, comp);
@@ -559,7 +558,7 @@
 //! Note: If "pos" is not the successor of the newly inserted "new_node"
 //! tree invariants might be broken.
 static node_ptr insert_before
- (node_ptr header, node_ptr pos, node_ptr new_node)
+ (const node_ptr & header, const node_ptr & pos, const node_ptr & new_node)
 {
 tree_algorithms::insert_before(header, pos, new_node);
 splay_up(new_node, header);
@@ -579,7 +578,7 @@
 //! Note: If "new_node" is less than the greatest inserted key
 //! tree invariants are broken. This function is slightly faster than
 //! using "insert_before".
- static void push_back(node_ptr header, node_ptr new_node)
+ static void push_back(const node_ptr & header, const node_ptr & new_node)
 {
 tree_algorithms::push_back(header, new_node);
 splay_up(new_node, header);
@@ -598,7 +597,7 @@
 //! Note: If "new_node" is greater than the lowest inserted key
 //! tree invariants are broken. This function is slightly faster than
 //! using "insert_before".
- static void push_front(node_ptr header, node_ptr new_node)
+ static void push_front(const node_ptr & header, const node_ptr & new_node)
 {
 tree_algorithms::push_front(header, new_node);
 splay_up(new_node, header);
@@ -618,7 +617,7 @@
 //! Throws: If "comp" throws.
 template<class NodePtrCompare>
 static node_ptr insert_equal_upper_bound
- (node_ptr header, node_ptr new_node, NodePtrCompare comp)
+ (const node_ptr & header, const node_ptr & new_node, NodePtrCompare comp)
 {
 splay_down(header, new_node, comp);
 return tree_algorithms::insert_equal_upper_bound(header, new_node, comp);
@@ -638,7 +637,7 @@
 //! Throws: If "comp" throws.
 template<class NodePtrCompare>
 static node_ptr insert_equal_lower_bound
- (node_ptr header, node_ptr new_node, NodePtrCompare comp)
+ (const node_ptr & header, const node_ptr & new_node, NodePtrCompare comp)
 {
 splay_down(header, new_node, comp);
 return tree_algorithms::insert_equal_lower_bound(header, new_node, comp);
@@ -649,13 +648,13 @@
 //! take a node_ptr and shouldn't throw.
 //!
 //! Effects: First empties target tree calling
- //! <tt>void disposer::operator()(node_ptr)</tt> for every node of the tree
+ //! <tt>void disposer::operator()(const node_ptr &)</tt> for every node of the tree
 //! except the header.
 //!
 //! Then, duplicates the entire tree pointed by "source_header" cloning each
- //! source node with <tt>node_ptr Cloner::operator()(node_ptr)</tt> to obtain
+ //! source node with <tt>node_ptr Cloner::operator()(const node_ptr &)</tt> to obtain
 //! the nodes of the target tree. If "cloner" throws, the cloned target nodes
- //! are disposed using <tt>void disposer(node_ptr)</tt>.
+ //! are disposed using <tt>void disposer(const node_ptr &)</tt>.
 //!
 //! Complexity: Linear to the number of element of the source tree plus the.
 //! number of elements of tree target tree when calling this function.
@@ -663,23 +662,23 @@
 //! Throws: If cloner functor throws. If this happens target nodes are disposed.
 template <class Cloner, class Disposer>
 static void clone
- (const_node_ptr source_header, node_ptr target_header, Cloner cloner, Disposer disposer)
+ (const const_node_ptr & source_header, const node_ptr & target_header, Cloner cloner, Disposer disposer)
 { tree_algorithms::clone(source_header, target_header, cloner, disposer); }

 // delete node | complexity : constant | exception : nothrow
- static void erase(node_ptr header, node_ptr z, bool splay = true)
+ static void erase(const node_ptr & header, const node_ptr & z, bool splay = true)
 {
// node_base* n = t->right;
-// if( t->left != 0 ){
+// if( t->left != node_ptr() ){
// node_base* l = t->previous();
// splay_up( l , t );
// n = t->left;
// n->right = t->right;
-// if( n->right != 0 )
+// if( n->right != node_ptr() )
// n->right->parent = n;
// }
//
-// if( n != 0 )
+// if( n != node_ptr() )
// n->parent = t->parent;
//
// if( t->parent->left == t )
@@ -695,11 +694,11 @@
 }
 /*
 //possibility 2
- if(splay && NodeTraits::get_left(z) != 0 ){
+ if(splay && NodeTraits::get_left(z) != node_ptr() ){
 node_ptr l = NodeTraits::get_left(z);
 splay_up(l, header);
 }*//*
- if(splay && NodeTraits::get_left(z) != 0 ){
+ if(splay && NodeTraits::get_left(z) != node_ptr() ){
 node_ptr l = prev_node(z);
 splay_up_impl(l, z);
 }*/
@@ -715,15 +714,13 @@
 }

 // bottom-up splay, use data_ as parent for n | complexity : logarithmic | exception : nothrow
- static void splay_up(node_ptr n, node_ptr header)
+ static void splay_up(const node_ptr & node, const node_ptr & header)
 {
- if(n == header){ // do a splay for the right most node instead
- // this is to boost performance of equal_range/count on equivalent containers in the case
- // where there are many equal elements at the end
- n = NodeTraits::get_right(header);
- }
-
- node_ptr t = header;
+ // If (node == header) do a splay for the right most node instead
+ // this is to boost performance of equal_range/count on equivalent containers in the case
+ // where there are many equal elements at the end
+ node_ptr n((node == header) ? NodeTraits::get_right(header) : node);
+ node_ptr t(header);

 if( n == t ) return;

@@ -753,7 +750,7 @@

 // top-down splay | complexity : logarithmic | exception : strong, note A
 template<class KeyType, class KeyNodePtrCompare>
- static node_ptr splay_down(node_ptr header, const KeyType &key, KeyNodePtrCompare comp)
+ static node_ptr splay_down(const node_ptr & header, const KeyType &key, KeyNodePtrCompare comp)
 {
 if(!NodeTraits::get_parent(header))
 return header;
@@ -782,19 +779,19 @@

 for( ;; ){
 if(comp(key, t)){
- if(NodeTraits::get_left(t) == 0 )
+ if(NodeTraits::get_left(t) == node_ptr() )
 break;
 if(comp(key, NodeTraits::get_left(t))){
 t = tree_algorithms::rotate_right(t);

- if(NodeTraits::get_left(t) == 0)
+ if(NodeTraits::get_left(t) == node_ptr())
 break;
 link_right(t, r);
 }
 else if(comp(NodeTraits::get_left(t), key)){
 link_right(t, r);

- if(NodeTraits::get_right(t) == 0 )
+ if(NodeTraits::get_right(t) == node_ptr() )
 break;
 link_left(t, l);
 }
@@ -803,20 +800,20 @@
 }
 }
 else if(comp(t, key)){
- if(NodeTraits::get_right(t) == 0 )
+ if(NodeTraits::get_right(t) == node_ptr() )
 break;

 if(comp(NodeTraits::get_right(t), key)){
 t = tree_algorithms::rotate_left( t );

- if(NodeTraits::get_right(t) == 0 )
+ if(NodeTraits::get_right(t) == node_ptr() )
 break;
 link_left(t, l);
 }
 else if(comp(key, NodeTraits::get_right(t))){
 link_left(t, l);

- if(NodeTraits::get_left(t) == 0)
+ if(NodeTraits::get_left(t) == node_ptr())
 break;

 link_right(t, r);
@@ -850,7 +847,7 @@
 //! Throws: Nothing.
 //!
 //! Complexity: Linear.
- static void rebalance(node_ptr header)
+ static void rebalance(const node_ptr & header)
 { tree_algorithms::rebalance(header); }

 //! Requires: old_root is a node of a tree.
@@ -862,7 +859,7 @@
 //! Throws: Nothing.
 //!
 //! Complexity: Linear.
- static node_ptr rebalance_subtree(node_ptr old_root)
+ static node_ptr rebalance_subtree(const node_ptr & old_root)
 { return tree_algorithms::rebalance_subtree(old_root); }

@@ -873,7 +870,7 @@
 //! Complexity: Logarithmic.
 //!
 //! Throws: Nothing.
- static node_ptr get_header(node_ptr n)
+ static node_ptr get_header(const node_ptr & n)
 { return tree_algorithms::get_header(n); }

 private:
@@ -881,23 +878,23 @@
 /// @cond

 // assemble the three sub-trees into new tree pointed to by t | complexity : constant | exception : nothrow
- static void assemble( node_ptr t, node_ptr l, node_ptr r, const_node_ptr null_node )
+ static void assemble(const node_ptr &t, const node_ptr & l, const node_ptr & r, const const_node_ptr & null_node )
 {
 NodeTraits::set_right(l, NodeTraits::get_left(t));
 NodeTraits::set_left(r, NodeTraits::get_right(t));

- if(NodeTraits::get_right(l) != 0){
+ if(NodeTraits::get_right(l) != node_ptr()){
 NodeTraits::set_parent(NodeTraits::get_right(l), l);
 }

- if(NodeTraits::get_left(r) != 0){
+ if(NodeTraits::get_left(r) != node_ptr()){
 NodeTraits::set_parent(NodeTraits::get_left(r), r);
 }

 NodeTraits::set_left (t, NodeTraits::get_right(null_node));
 NodeTraits::set_right(t, NodeTraits::get_left(null_node));

- if( NodeTraits::get_left(t) != 0 ){
+ if( NodeTraits::get_left(t) != node_ptr() ){
 NodeTraits::set_parent(NodeTraits::get_left(t), t);
 }

@@ -907,7 +904,7 @@
 }

 // break link to left child node and attach it to left tree pointed to by l | complexity : constant | exception : nothrow
- static void link_left(node_ptr& t, node_ptr& l)
+ static void link_left(node_ptr & t, node_ptr & l)
 {
 NodeTraits::set_right(l, t);
 NodeTraits::set_parent(t, l);
@@ -916,7 +913,7 @@
 }

 // break link to right child node and attach it to right tree pointed to by r | complexity : constant | exception : nothrow
- static void link_right(node_ptr& t, node_ptr& r)
+ static void link_right(node_ptr & t, node_ptr & r)
 {
 NodeTraits::set_left(r, t);
 NodeTraits::set_parent(t, r);
@@ -925,7 +922,7 @@
 }

 // rotate n with its parent | complexity : constant | exception : nothrow
- static void rotate(node_ptr n)
+ static void rotate(const node_ptr & n)
 {
 node_ptr p = NodeTraits::get_parent(n);
 node_ptr g = NodeTraits::get_parent(p);
@@ -935,13 +932,13 @@

 if(NodeTraits::get_left(p) == n){
 NodeTraits::set_left(p, NodeTraits::get_right(n));
- if(NodeTraits::get_left(p) != 0)
+ if(NodeTraits::get_left(p) != node_ptr())
 NodeTraits::set_parent(NodeTraits::get_left(p), p);
 NodeTraits::set_right(n, p);
 }
 else{ // must be ( p->right == n )
 NodeTraits::set_right(p, NodeTraits::get_left(n));
- if(NodeTraits::get_right(p) != 0)
+ if(NodeTraits::get_right(p) != node_ptr())
 NodeTraits::set_parent(NodeTraits::get_right(p), p);
 NodeTraits::set_left(n, p);
 }
@@ -953,7 +950,7 @@
 if(NodeTraits::get_parent(g) == p)
 NodeTraits::set_parent(g, n);
 else{//must be ( g->right == p )
- BOOST_INTRUSIVE_INVARIANT_ASSERT(0);
+ BOOST_INTRUSIVE_INVARIANT_ASSERT(false);
 NodeTraits::set_right(g, n);
 }
 }

Modified: branches/release/boost/intrusive/treap.hpp
==============================================================================
--- branches/release/boost/intrusive/treap.hpp (original)
+++ branches/release/boost/intrusive/treap.hpp 2011-12-26 12:10:27 EST (Mon, 26 Dec 2011)
@@ -25,8 +25,10 @@
#include <boost/intrusive/bs_set_hook.hpp>
#include <boost/intrusive/detail/tree_node.hpp>
#include <boost/intrusive/detail/ebo_functor_holder.hpp>
-#include <boost/intrusive/detail/pointer_to_other.hpp>
+#include <boost/intrusive/pointer_traits.hpp>
#include <boost/intrusive/detail/clear_on_destructor_base.hpp>
+#include <boost/intrusive/detail/utilities.hpp>
+#include <boost/intrusive/pointer_traits.hpp>
#include <boost/intrusive/options.hpp>
#include <boost/intrusive/detail/mpl.hpp>
#include <boost/intrusive/treap_algorithms.hpp>
@@ -98,25 +100,27 @@
 /// @endcond
 typedef typename real_value_traits::pointer pointer;
 typedef typename real_value_traits::const_pointer const_pointer;
- typedef typename std::iterator_traits<pointer>::value_type value_type;
+ typedef typename pointer_traits<pointer>::element_type value_type;
+ typedef typename pointer_traits<pointer>::reference reference;
+ typedef typename pointer_traits<const_pointer>::reference const_reference;
+ typedef typename pointer_traits<pointer>::difference_type difference_type;
 typedef value_type key_type;
- typedef typename std::iterator_traits<pointer>::reference reference;
- typedef typename std::iterator_traits<const_pointer>::reference const_reference;
- typedef typename std::iterator_traits<pointer>::difference_type difference_type;
 typedef typename Config::size_type size_type;
 typedef typename Config::compare value_compare;
 typedef typename Config::priority_compare priority_compare;
 typedef value_compare key_compare;
- typedef tree_iterator<treap_impl, false> iterator;
- typedef tree_iterator<treap_impl, true> const_iterator;
- typedef std::reverse_iterator<iterator> reverse_iterator;
- typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+ typedef tree_iterator<treap_impl, false> iterator;
+ typedef tree_iterator<treap_impl, true> const_iterator;
+ typedef boost::intrusive::detail::reverse_iterator<iterator> reverse_iterator;
+ typedef boost::intrusive::detail::reverse_iterator<const_iterator>const_reverse_iterator;
 typedef typename real_value_traits::node_traits node_traits;
 typedef typename node_traits::node node;
- typedef typename boost::pointer_to_other
- <pointer, node>::type node_ptr;
- typedef typename boost::pointer_to_other
- <node_ptr, const node>::type const_node_ptr;
+ typedef typename pointer_traits
+ <pointer>::template rebind_pointer
+ <node>::type node_ptr;
+ typedef typename pointer_traits
+ <pointer>::template rebind_pointer
+ <const node>::type const_node_ptr;
 typedef treap_algorithms<node_traits> node_algorithms;

 static const bool constant_time_size = Config::constant_time_size;
@@ -182,16 +186,14 @@
 value_traits &priv_value_traits()
 { return data_; }

- const node &priv_header() const
- { return data_.node_plus_pred_.header_plus_priority_size_.header_plus_size_.header_; }
+ node_ptr priv_header_ptr()
+ { return pointer_traits<node_ptr>::pointer_to(data_.node_plus_pred_.header_plus_priority_size_.header_plus_size_.header_); }

- node &priv_header()
- { return data_.node_plus_pred_.header_plus_priority_size_.header_plus_size_.header_; }
+ const_node_ptr priv_header_ptr() const
+ { return pointer_traits<const_node_ptr>::pointer_to(data_.node_plus_pred_.header_plus_priority_size_.header_plus_size_.header_); }

- static node_ptr uncast(const_node_ptr ptr)
- {
- return node_ptr(const_cast<node*>(detail::boost_intrusive_get_pointer(ptr)));
- }
+ static node_ptr uncast(const const_node_ptr & ptr)
+ { return pointer_traits<node_ptr>::const_cast_from(ptr); }

 size_traits &priv_size_traits()
 { return data_.node_plus_pred_.header_plus_priority_size_.header_plus_size_; }
@@ -235,7 +237,7 @@
 , const value_traits &v_traits = value_traits())
 : data_(cmp, pcmp, v_traits)
 {
- node_algorithms::init_header(&priv_header());
+ node_algorithms::init_header(this->priv_header_ptr());
 this->priv_size_traits().set_size(size_type(0));
 }

@@ -259,7 +261,7 @@
 , const value_traits &v_traits = value_traits())
 : data_(cmp, pcmp, v_traits)
 {
- node_algorithms::init_header(&priv_header());
+ node_algorithms::init_header(this->priv_header_ptr());
 this->priv_size_traits().set_size(size_type(0));
 if(unique)
 this->insert_unique(b, e);
@@ -274,7 +276,7 @@
 , ::boost::move(x.priv_pcomp())
 , ::boost::move(x.priv_value_traits()))
 {
- node_algorithms::init_header(&priv_header());
+ node_algorithms::init_header(this->priv_header_ptr());
 this->priv_size_traits().set_size(size_type(0));
 this->swap(x);
 }
@@ -301,7 +303,7 @@
 //!
 //! Throws: Nothing.
 iterator begin()
- { return iterator (node_traits::get_left(node_ptr(&priv_header())), this); }
+ { return iterator (node_traits::get_left(this->priv_header_ptr()), this); }

 //! Effects: Returns a const_iterator pointing to the beginning of the treap.
 //!
@@ -317,7 +319,7 @@
 //!
 //! Throws: Nothing.
 const_iterator cbegin() const
- { return const_iterator (node_traits::get_left(const_node_ptr(&priv_header())), this); }
+ { return const_iterator (node_traits::get_left(this->priv_header_ptr()), this); }

 //! Effects: Returns an iterator pointing to the end of the treap.
 //!
@@ -325,7 +327,7 @@
 //!
 //! Throws: Nothing.
 iterator end()
- { return iterator (node_ptr(&priv_header()), this); }
+ { return iterator (this->priv_header_ptr(), this); }

 //! Effects: Returns a const_iterator pointing to the end of the treap.
 //!
@@ -341,7 +343,7 @@
 //!
 //! Throws: Nothing.
 const_iterator cend() const
- { return const_iterator (uncast(const_node_ptr(&priv_header())), this); }
+ { return const_iterator (uncast(this->priv_header_ptr()), this); }

 //! Effects: Returns an iterator pointing to the highest priority object of the treap.
@@ -350,7 +352,7 @@
 //!
 //! Throws: Nothing.
 iterator top()
- { return this->empty() ? this->end() : iterator (node_traits::get_parent(node_ptr(&priv_header())), this); }
+ { return this->empty() ? this->end() : iterator (node_traits::get_parent(this->priv_header_ptr()), this); }

 //! Effects: Returns a const_iterator pointing to the highest priority object of the treap..
 //!
@@ -366,7 +368,7 @@
 //!
 //! Throws: Nothing.
 const_iterator ctop() const
- { return this->empty() ? this->cend() : const_iterator (node_traits::get_parent(const_node_ptr(&priv_header())), this); }
+ { return this->empty() ? this->cend() : const_iterator (node_traits::get_parent(this->priv_header_ptr()), this); }

 //! Effects: Returns a reverse_iterator pointing to the beginning of the
 //! reversed treap.
@@ -515,7 +517,7 @@
 //!
 //! Throws: Nothing.
 bool empty() const
- { return node_algorithms::unique(const_node_ptr(&priv_header())); }
+ { return node_algorithms::unique(this->priv_header_ptr()); }

 //! Effects: Returns the number of elements stored in the treap.
 //!
@@ -528,7 +530,7 @@
 if(constant_time_size)
 return this->priv_size_traits().get_size();
 else{
- return (size_type)node_algorithms::size(const_node_ptr(&priv_header()));
+ return (size_type)node_algorithms::size(this->priv_header_ptr());
 }
 }

@@ -544,7 +546,7 @@
 swap(priv_comp(), priv_comp());
 swap(priv_pcomp(), priv_pcomp());
 //These can't throw
- node_algorithms::swap_tree(node_ptr(&priv_header()), node_ptr(&other.priv_header()));
+ node_algorithms::swap_tree(this->priv_header_ptr(), other.priv_header_ptr());
 if(constant_time_size){
 size_type backup = this->priv_size_traits().get_size();
 this->priv_size_traits().set_size(other.priv_size_traits().get_size());
@@ -573,7 +575,7 @@
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
 iterator ret(node_algorithms::insert_equal_upper_bound
- (node_ptr(&priv_header()), to_insert, key_node_comp, key_node_pcomp), this);
+ (this->priv_header_ptr(), to_insert, key_node_comp, key_node_pcomp), this);
 this->priv_size_traits().increment();
 return ret;
 }
@@ -602,7 +604,7 @@
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
 iterator ret (node_algorithms::insert_equal
- (node_ptr(&priv_header()), hint.pointed_node(), to_insert, key_node_comp, key_node_pcomp), this);
+ (this->priv_header_ptr(), hint.pointed_node(), to_insert, key_node_comp, key_node_pcomp), this);
 this->priv_size_traits().increment();
 return ret;
 }
@@ -748,7 +750,7 @@
 pcomp(key_value_pcomp, this);
 std::pair<node_ptr, bool> ret =
 (node_algorithms::insert_unique_check
- (node_ptr(&priv_header()), key, comp, pcomp, commit_data));
+ (this->priv_header_ptr(), key, comp, pcomp, commit_data));
 return std::pair<iterator, bool>(iterator(ret.first, this), ret.second);
 }

@@ -800,7 +802,7 @@
 pcomp(key_value_pcomp, this);
 std::pair<node_ptr, bool> ret =
 (node_algorithms::insert_unique_check
- (node_ptr(&priv_header()), hint.pointed_node(), key, comp, pcomp, commit_data));
+ (this->priv_header_ptr(), hint.pointed_node(), key, comp, pcomp, commit_data));
 return std::pair<iterator, bool>(iterator(ret.first, this), ret.second);
 }

@@ -826,7 +828,7 @@
 node_ptr to_insert(get_real_value_traits().to_node_ptr(value));
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
- node_algorithms::insert_unique_commit(node_ptr(&priv_header()), to_insert, commit_data);
+ node_algorithms::insert_unique_commit(this->priv_header_ptr(), to_insert, commit_data);
 this->priv_size_traits().increment();
 return iterator(to_insert, this);
 }
@@ -853,7 +855,7 @@
 detail::key_nodeptr_comp<priority_compare, treap_impl>
 pcomp(priv_pcomp(), this);
 iterator ret (node_algorithms::insert_before
- (node_ptr(&priv_header()), pos.pointed_node(), to_insert, pcomp), this);
+ (this->priv_header_ptr(), pos.pointed_node(), to_insert, pcomp), this);
 this->priv_size_traits().increment();
 return ret;
 }
@@ -879,7 +881,7 @@
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
 detail::key_nodeptr_comp<priority_compare, treap_impl>
 pcomp(priv_pcomp(), this);
- node_algorithms::push_back(node_ptr(&priv_header()), to_insert, pcomp);
+ node_algorithms::push_back(this->priv_header_ptr(), to_insert, pcomp);
 this->priv_size_traits().increment();
 }

@@ -904,7 +906,7 @@
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
 detail::key_nodeptr_comp<priority_compare, treap_impl>
 pcomp(priv_pcomp(), this);
- node_algorithms::push_front(node_ptr(&priv_header()), to_insert, pcomp);
+ node_algorithms::push_front(this->priv_header_ptr(), to_insert, pcomp);
 this->priv_size_traits().increment();
 }

@@ -925,7 +927,7 @@
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!node_algorithms::unique(to_erase));
 detail::key_nodeptr_comp<priority_compare, treap_impl>
 key_node_pcomp(priv_pcomp(), this);
- node_algorithms::erase(&priv_header(), to_erase, key_node_pcomp);
+ node_algorithms::erase(this->priv_header_ptr(), to_erase, key_node_pcomp);
 this->priv_size_traits().decrement();
 if(safemode_or_autounlink)
 node_algorithms::init(to_erase);
@@ -1090,7 +1092,7 @@
 this->clear_and_dispose(detail::null_disposer());
 }
 else{
- node_algorithms::init_header(&priv_header());
+ node_algorithms::init_header(priv_header_ptr());
 this->priv_size_traits().set_size(0);
 }
 }
@@ -1107,9 +1109,9 @@
 template<class Disposer>
 void clear_and_dispose(Disposer disposer)
 {
- node_algorithms::clear_and_dispose(node_ptr(&priv_header())
+ node_algorithms::clear_and_dispose(this->priv_header_ptr()
 , detail::node_disposer<Disposer, treap_impl>(disposer, this));
- node_algorithms::init_header(&priv_header());
+ node_algorithms::init_header(this->priv_header_ptr());
 this->priv_size_traits().set_size(0);
 }

@@ -1165,7 +1167,7 @@
 detail::key_nodeptr_comp<KeyValueCompare, treap_impl>
 key_node_comp(comp, this);
 return iterator(node_algorithms::lower_bound
- (const_node_ptr(&priv_header()), key, key_node_comp), this);
+ (this->priv_header_ptr(), key, key_node_comp), this);
 }

 //! Effects: Returns a const iterator to the first element whose
@@ -1180,7 +1182,7 @@
 detail::key_nodeptr_comp<KeyValueCompare, treap_impl>
 key_node_comp(comp, this);
 return const_iterator(node_algorithms::lower_bound
- (const_node_ptr(&priv_header()), key, key_node_comp), this);
+ (this->priv_header_ptr(), key, key_node_comp), this);
 }

 //! Effects: Returns an iterator to the first element whose
@@ -1205,7 +1207,7 @@
 detail::key_nodeptr_comp<KeyValueCompare, treap_impl>
 key_node_comp(comp, this);
 return iterator(node_algorithms::upper_bound
- (const_node_ptr(&priv_header()), key, key_node_comp), this);
+ (this->priv_header_ptr(), key, key_node_comp), this);
 }

 //! Effects: Returns an iterator to the first element whose
@@ -1230,7 +1232,7 @@
 detail::key_nodeptr_comp<KeyValueCompare, treap_impl>
 key_node_comp(comp, this);
 return const_iterator(node_algorithms::upper_bound
- (const_node_ptr(&priv_header()), key, key_node_comp), this);
+ (this->priv_header_ptr(), key, key_node_comp), this);
 }

 //! Effects: Finds an iterator to the first element whose key is
@@ -1254,7 +1256,7 @@
 detail::key_nodeptr_comp<KeyValueCompare, treap_impl>
 key_node_comp(comp, this);
 return iterator
- (node_algorithms::find(const_node_ptr(&priv_header()), key, key_node_comp), this);
+ (node_algorithms::find(this->priv_header_ptr(), key, key_node_comp), this);
 }

 //! Effects: Finds a const_iterator to the first element whose key is
@@ -1278,7 +1280,7 @@
 detail::key_nodeptr_comp<KeyValueCompare, treap_impl>
 key_node_comp(comp, this);
 return const_iterator
- (node_algorithms::find(const_node_ptr(&priv_header()), key, key_node_comp), this);
+ (node_algorithms::find(this->priv_header_ptr(), key, key_node_comp), this);
 }

 //! Effects: Finds a range containing all elements whose key is k or
@@ -1304,7 +1306,7 @@
 detail::key_nodeptr_comp<KeyValueCompare, treap_impl>
 key_node_comp(comp, this);
 std::pair<node_ptr, node_ptr> ret
- (node_algorithms::equal_range(const_node_ptr(&priv_header()), key, key_node_comp));
+ (node_algorithms::equal_range(this->priv_header_ptr(), key, key_node_comp));
 return std::pair<iterator, iterator>(iterator(ret.first, this), iterator(ret.second, this));
 }

@@ -1333,7 +1335,7 @@
 detail::key_nodeptr_comp<KeyValueCompare, treap_impl>
 key_node_comp(comp, this);
 std::pair<node_ptr, node_ptr> ret
- (node_algorithms::equal_range(const_node_ptr(&priv_header()), key, key_node_comp));
+ (node_algorithms::equal_range(this->priv_header_ptr(), key, key_node_comp));
 return std::pair<const_iterator, const_iterator>(const_iterator(ret.first, this), const_iterator(ret.second, this));
 }

@@ -1359,8 +1361,8 @@
 detail::exception_disposer<treap_impl, Disposer>
 rollback(*this, disposer);
 node_algorithms::clone
- (const_node_ptr(&src.priv_header())
- ,node_ptr(&this->priv_header())
+ (src.priv_header_ptr()
+ ,this->priv_header_ptr()
 ,detail::node_cloner<Cloner, treap_impl>(cloner, this)
 ,detail::node_disposer<Disposer, treap_impl>(disposer, this));
 this->priv_size_traits().set_size(src.priv_size_traits().get_size());
@@ -1382,7 +1384,7 @@
 pointer unlink_leftmost_without_rebalance()
 {
 node_ptr to_be_disposed(node_algorithms::unlink_leftmost_without_rebalance
- (node_ptr(&priv_header())));
+ (this->priv_header_ptr()));
 if(!to_be_disposed)
 return 0;
 this->priv_size_traits().decrement();
@@ -1408,7 +1410,7 @@
 void replace_node(iterator replace_this, reference with_this)
 {
 node_algorithms::replace_node( get_real_value_traits().to_node_ptr(*replace_this)
- , node_ptr(&priv_header())
+ , this->priv_header_ptr()
 , get_real_value_traits().to_node_ptr(with_this));
 if(safemode_or_autounlink)
 node_algorithms::init(replace_this.pointed_node());
@@ -1510,7 +1512,7 @@
 static treap_impl &priv_container_from_end_iterator(const const_iterator &end_iterator)
 {
 header_plus_size *r = detail::parent_from_member<header_plus_size, node>
- ( detail::boost_intrusive_get_pointer(end_iterator.pointed_node()), &header_plus_size::header_);
+ ( boost::intrusive::detail::to_raw_pointer(end_iterator.pointed_node()), &header_plus_size::header_);
 typename node_plus_pred_t::header_plus_priority_size *n =
 detail::parent_from_member
 < typename node_plus_pred_t::header_plus_priority_size

Modified: branches/release/boost/intrusive/treap_algorithms.hpp
==============================================================================
--- branches/release/boost/intrusive/treap_algorithms.hpp (original)
+++ branches/release/boost/intrusive/treap_algorithms.hpp 2011-12-26 12:10:27 EST (Mon, 26 Dec 2011)
@@ -19,6 +19,7 @@
#include <boost/intrusive/intrusive_fwd.hpp>

#include <boost/intrusive/detail/assert.hpp>
+#include <boost/intrusive/pointer_traits.hpp>
#include <boost/intrusive/detail/utilities.hpp>
#include <boost/intrusive/detail/tree_algorithms.hpp>
#include <algorithm>
@@ -82,7 +83,7 @@
 remove_on_destroy(const remove_on_destroy&);
 remove_on_destroy& operator=(const remove_on_destroy&);
 public:
- remove_on_destroy(node_ptr header, node_ptr z)
+ remove_on_destroy(const node_ptr & header, const node_ptr & z)
 : header_(header), z_(z), remove_it_(true)
 {}
 ~remove_on_destroy()
@@ -106,7 +107,7 @@
 rerotate_on_destroy& operator=(const rerotate_on_destroy&);

 public:
- rerotate_on_destroy(node_ptr header, node_ptr p, std::size_t &n)
+ rerotate_on_destroy(const node_ptr & header, const node_ptr & p, std::size_t &n)
 : header_(header), p_(p), n_(n), remove_it_(true)
 {}

@@ -143,17 +144,16 @@

 typedef detail::tree_algorithms<NodeTraits> tree_algorithms;

- static node_ptr uncast(const_node_ptr ptr)
- {
- return node_ptr(const_cast<node*>(::boost::intrusive::detail::boost_intrusive_get_pointer(ptr)));
- }
+ static node_ptr uncast(const const_node_ptr & ptr)
+ { return pointer_traits<node_ptr>::const_cast_from(ptr); }
+
 /// @endcond

 public:
- static node_ptr begin_node(const_node_ptr header)
+ static node_ptr begin_node(const const_node_ptr & header)
 { return tree_algorithms::begin_node(header); }

- static node_ptr end_node(const_node_ptr header)
+ static node_ptr end_node(const const_node_ptr & header)
 { return tree_algorithms::end_node(header); }

 //! This type is the information that will be
@@ -177,7 +177,7 @@
 //! Complexity: Constant.
 //!
 //! Throws: Nothing.
- static void swap_tree(node_ptr header1, node_ptr header2)
+ static void swap_tree(const node_ptr & header1, const node_ptr & header2)
 { return tree_algorithms::swap_tree(header1, header2); }

 //! Requires: node1 and node2 can't be header nodes
@@ -195,7 +195,7 @@
 //! node1 and node2 are not equivalent according to the ordering rules.
 //!
 //!Experimental function
- static void swap_nodes(node_ptr node1, node_ptr node2)
+ static void swap_nodes(const node_ptr & node1, const node_ptr & node2)
 {
 if(node1 == node2)
 return;
@@ -219,7 +219,7 @@
 //! node1 and node2 are not equivalent according to the ordering rules.
 //!
 //!Experimental function
- static void swap_nodes(node_ptr node1, node_ptr header1, node_ptr node2, node_ptr header2)
+ static void swap_nodes(const node_ptr & node1, const node_ptr & header1, const node_ptr & node2, const node_ptr & header2)
 { tree_algorithms::swap_nodes(node1, header1, node2, header2); }

 //! Requires: node_to_be_replaced must be inserted in a tree
@@ -238,7 +238,7 @@
 //! the node, since no rebalancing and comparison is needed.
 //!
 //!Experimental function
- static void replace_node(node_ptr node_to_be_replaced, node_ptr new_node)
+ static void replace_node(const node_ptr & node_to_be_replaced, const node_ptr & new_node)
 {
 if(node_to_be_replaced == new_node)
 return;
@@ -261,7 +261,7 @@
 //! the node, since no rebalancing or comparison is needed.
 //!
 //!Experimental function
- static void replace_node(node_ptr node_to_be_replaced, node_ptr header, node_ptr new_node)
+ static void replace_node(const node_ptr & node_to_be_replaced, const node_ptr & header, const node_ptr & new_node)
 { tree_algorithms::replace_node(node_to_be_replaced, header, new_node); }

 //! Requires: node is a tree node but not the header.
@@ -272,7 +272,7 @@
 //!
 //! Throws: If "pcomp" throws, strong guarantee
 template<class NodePtrPriorityCompare>
- static void unlink(node_ptr node, NodePtrPriorityCompare pcomp)
+ static void unlink(const node_ptr & node, NodePtrPriorityCompare pcomp)
 {
 node_ptr x = NodeTraits::get_parent(node);
 if(x){
@@ -295,7 +295,7 @@
 //! only be used for more unlink_leftmost_without_rebalance calls.
 //! This function is normally used to achieve a step by step
 //! controlled destruction of the tree.
- static node_ptr unlink_leftmost_without_rebalance(node_ptr header)
+ static node_ptr unlink_leftmost_without_rebalance(const node_ptr & header)
 { return tree_algorithms::unlink_leftmost_without_rebalance(header); }

 //! Requires: node is a node of the tree or an node initialized
@@ -306,7 +306,7 @@
 //! Complexity: Constant time.
 //!
 //! Throws: Nothing.
- static bool unique(const_node_ptr node)
+ static bool unique(const const_node_ptr & node)
 { return tree_algorithms::unique(node); }

 //! Requires: node is a node of the tree but it's not the header.
@@ -316,7 +316,7 @@
 //! Complexity: Linear time.
 //!
 //! Throws: Nothing.
- static std::size_t count(const_node_ptr node)
+ static std::size_t count(const const_node_ptr & node)
 { return tree_algorithms::count(node); }

 //! Requires: header is the header node of the tree.
@@ -326,7 +326,7 @@
 //! Complexity: Linear time.
 //!
 //! Throws: Nothing.
- static std::size_t size(const_node_ptr header)
+ static std::size_t size(const const_node_ptr & header)
 { return tree_algorithms::size(header); }

 //! Requires: p is a node from the tree except the header.
@@ -336,7 +336,7 @@
 //! Complexity: Average constant time.
 //!
 //! Throws: Nothing.
- static node_ptr next_node(node_ptr p)
+ static node_ptr next_node(const node_ptr & p)
 { return tree_algorithms::next_node(p); }

 //! Requires: p is a node from the tree except the leftmost node.
@@ -346,7 +346,7 @@
 //! Complexity: Average constant time.
 //!
 //! Throws: Nothing.
- static node_ptr prev_node(node_ptr p)
+ static node_ptr prev_node(const node_ptr & p)
 { return tree_algorithms::prev_node(p); }

 //! Requires: node must not be part of any tree.
@@ -358,7 +358,7 @@
 //! Throws: Nothing.
 //!
 //! Nodes: If node is inserted in a tree, this function corrupts the tree.
- static void init(node_ptr node)
+ static void init(const node_ptr & node)
 { tree_algorithms::init(node); }

 //! Requires: node must not be part of any tree.
@@ -371,7 +371,7 @@
 //! Throws: Nothing.
 //!
 //! Nodes: If node is inserted in a tree, this function corrupts the tree.
- static void init_header(node_ptr header)
+ static void init_header(const node_ptr & header)
 {
 tree_algorithms::init_header(header);
 }
@@ -385,7 +385,7 @@
 //!
 //! Throws: If "pcomp" throws, strong guarantee.
 template<class NodePtrPriorityCompare>
- static node_ptr erase(node_ptr header, node_ptr z, NodePtrPriorityCompare pcomp)
+ static node_ptr erase(const node_ptr & header, const node_ptr & z, NodePtrPriorityCompare pcomp)
 {
 rebalance_for_erasure(header, z, pcomp);
 tree_algorithms::erase(header, z);
@@ -398,13 +398,13 @@
 //! take a node_ptr and shouldn't throw.
 //!
 //! Effects: First empties target tree calling
- //! <tt>void disposer::operator()(node_ptr)</tt> for every node of the tree
+ //! <tt>void disposer::operator()(const node_ptr &)</tt> for every node of the tree
 //! except the header.
 //!
 //! Then, duplicates the entire tree pointed by "source_header" cloning each
- //! source node with <tt>node_ptr Cloner::operator()(node_ptr)</tt> to obtain
+ //! source node with <tt>node_ptr Cloner::operator()(const node_ptr &)</tt> to obtain
 //! the nodes of the target tree. If "cloner" throws, the cloned target nodes
- //! are disposed using <tt>void disposer(node_ptr)</tt>.
+ //! are disposed using <tt>void disposer(const node_ptr &)</tt>.
 //!
 //! Complexity: Linear to the number of element of the source tree plus the.
 //! number of elements of tree target tree when calling this function.
@@ -412,7 +412,7 @@
 //! Throws: If cloner functor throws. If this happens target nodes are disposed.
 template <class Cloner, class Disposer>
 static void clone
- (const_node_ptr source_header, node_ptr target_header, Cloner cloner, Disposer disposer)
+ (const const_node_ptr & source_header, const node_ptr & target_header, Cloner cloner, Disposer disposer)
 {
 tree_algorithms::clone(source_header, target_header, cloner, disposer);
 }
@@ -421,7 +421,7 @@
 //! taking a node_ptr parameter and shouldn't throw.
 //!
 //! Effects: Empties the target tree calling
- //! <tt>void disposer::operator()(node_ptr)</tt> for every node of the tree
+ //! <tt>void disposer::operator()(const node_ptr &)</tt> for every node of the tree
 //! except the header.
 //!
 //! Complexity: Linear to the number of element of the source tree plus the.
@@ -429,7 +429,7 @@
 //!
 //! Throws: If cloner functor throws. If this happens target nodes are disposed.
 template<class Disposer>
- static void clear_and_dispose(node_ptr header, Disposer disposer)
+ static void clear_and_dispose(const node_ptr & header, Disposer disposer)
 { tree_algorithms::clear_and_dispose(header, disposer); }

 //! Requires: "header" must be the header node of a tree.
@@ -446,7 +446,7 @@
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static node_ptr lower_bound
- (const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp)
+ (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp)
 { return tree_algorithms::lower_bound(header, key, comp); }

 //! Requires: "header" must be the header node of a tree.
@@ -462,7 +462,7 @@
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static node_ptr upper_bound
- (const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp)
+ (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp)
 { return tree_algorithms::upper_bound(header, key, comp); }

 //! Requires: "header" must be the header node of a tree.
@@ -478,7 +478,7 @@
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static node_ptr find
- (const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp)
+ (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp)
 { return tree_algorithms::find(header, key, comp); }

 //! Requires: "header" must be the header node of a tree.
@@ -496,7 +496,7 @@
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static std::pair<node_ptr, node_ptr> equal_range
- (const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp)
+ (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp)
 { return tree_algorithms::equal_range(header, key, comp); }

 //! Requires: "h" must be the header node of a tree.
@@ -516,7 +516,7 @@
 //! Throws: If "comp" throw or "pcomp" throw.
 template<class NodePtrCompare, class NodePtrPriorityCompare>
 static node_ptr insert_equal_upper_bound
- (node_ptr h, node_ptr new_node, NodePtrCompare comp, NodePtrPriorityCompare pcomp)
+ (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp, NodePtrPriorityCompare pcomp)
 {
 insert_commit_data commit_data;
 tree_algorithms::insert_equal_upper_bound_check(h, new_node, comp, commit_data);
@@ -541,7 +541,7 @@
 //! Throws: If "comp" throws.
 template<class NodePtrCompare, class NodePtrPriorityCompare>
 static node_ptr insert_equal_lower_bound
- (node_ptr h, node_ptr new_node, NodePtrCompare comp, NodePtrPriorityCompare pcomp)
+ (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp, NodePtrPriorityCompare pcomp)
 {
 insert_commit_data commit_data;
 tree_algorithms::insert_equal_lower_bound_check(h, new_node, comp, commit_data);
@@ -569,7 +569,7 @@
 //! Throws: If "comp" throw or "pcomp" throw.
 template<class NodePtrCompare, class NodePtrPriorityCompare>
 static node_ptr insert_equal
- (node_ptr h, node_ptr hint, node_ptr new_node, NodePtrCompare comp, NodePtrPriorityCompare pcomp)
+ (const node_ptr & h, const node_ptr & hint, const node_ptr & new_node, NodePtrCompare comp, NodePtrPriorityCompare pcomp)
 {
 insert_commit_data commit_data;
 tree_algorithms::insert_equal_check(h, hint, new_node, comp, commit_data);
@@ -597,7 +597,7 @@
 //! tree invariants might be broken.
 template<class NodePtrPriorityCompare>
 static node_ptr insert_before
- (node_ptr header, node_ptr pos, node_ptr new_node, NodePtrPriorityCompare pcomp)
+ (const node_ptr & header, const node_ptr & pos, const node_ptr & new_node, NodePtrPriorityCompare pcomp)
 {
 insert_commit_data commit_data;
 tree_algorithms::insert_before_check(header, pos, commit_data);
@@ -623,7 +623,7 @@
 //! tree invariants are broken. This function is slightly faster than
 //! using "insert_before".
 template<class NodePtrPriorityCompare>
- static void push_back(node_ptr header, node_ptr new_node, NodePtrPriorityCompare pcomp)
+ static void push_back(const node_ptr & header, const node_ptr & new_node, NodePtrPriorityCompare pcomp)
 {
 insert_commit_data commit_data;
 tree_algorithms::push_back_check(header, commit_data);
@@ -648,7 +648,7 @@
 //! tree invariants are broken. This function is slightly faster than
 //! using "insert_before".
 template<class NodePtrPriorityCompare>
- static void push_front(node_ptr header, node_ptr new_node, NodePtrPriorityCompare pcomp)
+ static void push_front(const node_ptr & header, const node_ptr & new_node, NodePtrPriorityCompare pcomp)
 {
 insert_commit_data commit_data;
 tree_algorithms::push_front_check(header, commit_data);
@@ -691,7 +691,7 @@
 //! if no more objects are inserted or erased from the set.
 template<class KeyType, class KeyNodePtrCompare, class KeyNodePtrPrioCompare>
 static std::pair<node_ptr, bool> insert_unique_check
- (const_node_ptr header, const KeyType &key
+ (const const_node_ptr & header, const KeyType &key
 ,KeyNodePtrCompare comp, KeyNodePtrPrioCompare pcomp
 ,insert_commit_data &commit_data)
 {
@@ -743,7 +743,7 @@
 //! if no more objects are inserted or erased from the set.
 template<class KeyType, class KeyNodePtrCompare, class KeyNodePtrPrioCompare>
 static std::pair<node_ptr, bool> insert_unique_check
- (const_node_ptr header, node_ptr hint, const KeyType &key
+ (const const_node_ptr & header, const node_ptr & hint, const KeyType &key
 ,KeyNodePtrCompare comp, KeyNodePtrPrioCompare pcomp, insert_commit_data &commit_data)
 {
 std::pair<node_ptr, bool> ret =
@@ -771,7 +771,7 @@
 //! previously executed to fill "commit_data". No value should be inserted or
 //! erased between the "insert_check" and "insert_commit" calls.
 static void insert_unique_commit
- (node_ptr header, node_ptr new_node, const insert_commit_data &commit_data)
+ (const node_ptr & header, const node_ptr & new_node, const insert_commit_data &commit_data)
 {
 tree_algorithms::insert_unique_commit(header, new_node, commit_data);
 rebalance_after_insertion_commit(header, new_node, commit_data.rotations);
@@ -784,7 +784,7 @@
 //! Complexity: Logarithmic.
 //!
 //! Throws: Nothing.
- static node_ptr get_header(node_ptr n)
+ static node_ptr get_header(const node_ptr & n)
 { return tree_algorithms::get_header(n); }

 /// @cond
@@ -797,13 +797,13 @@
 //! Complexity: Constant.
 //!
 //! Throws: Nothing.
- static bool is_header(const_node_ptr p)
+ static bool is_header(const const_node_ptr & p)
 {
 return tree_algorithms::is_header(p);
 }

 template<class NodePtrPriorityCompare>
- static void rebalance_for_erasure(node_ptr header, node_ptr z, NodePtrPriorityCompare pcomp)
+ static void rebalance_for_erasure(const node_ptr & header, const node_ptr & z, NodePtrPriorityCompare pcomp)
 {
 std::size_t n = 0;
 rerotate_on_destroy rb(header, z, n);
@@ -826,7 +826,7 @@

 template<class NodePtrPriorityCompare>
 static void rebalance_check_and_commit
- (node_ptr h, node_ptr new_node, NodePtrPriorityCompare pcomp, insert_commit_data &commit_data)
+ (const node_ptr & h, const node_ptr & new_node, NodePtrPriorityCompare pcomp, insert_commit_data &commit_data)
 {
 rebalance_after_insertion_check(h, commit_data.node, new_node, pcomp, commit_data.rotations);
 //No-throw
@@ -837,9 +837,10 @@

 template<class Key, class KeyNodePriorityCompare>
 static void rebalance_after_insertion_check
- ( const_node_ptr header, const_node_ptr upnode, const Key &k
+ (const const_node_ptr &header, const const_node_ptr & up, const Key &k
 , KeyNodePriorityCompare pcomp, std::size_t &num_rotations)
 {
+ const_node_ptr upnode(up);
 //First check rotations since pcomp can throw
 num_rotations = 0;
 std::size_t n = 0;
@@ -850,7 +851,7 @@
 num_rotations = n;
 }

- static void rebalance_after_insertion_commit(node_ptr header, node_ptr p, std::size_t n)
+ static void rebalance_after_insertion_commit(const node_ptr & header, const node_ptr & p, std::size_t n)
 {
 // Now execute n rotations
 for( node_ptr p_parent = NodeTraits::get_parent(p)
@@ -867,7 +868,7 @@
 }

 template<class NodePtrPriorityCompare>
- static bool check_invariant(const_node_ptr header, NodePtrPriorityCompare pcomp)
+ static bool check_invariant(const const_node_ptr & header, NodePtrPriorityCompare pcomp)
 {
 node_ptr beg = begin_node(header);
 node_ptr end = end_node(header);

Modified: branches/release/boost/intrusive/trivial_value_traits.hpp
==============================================================================
--- branches/release/boost/intrusive/trivial_value_traits.hpp (original)
+++ branches/release/boost/intrusive/trivial_value_traits.hpp 2011-12-26 12:10:27 EST (Mon, 26 Dec 2011)
@@ -14,6 +14,7 @@
#define BOOST_INTRUSIVE_TRIVIAL_VALUE_TRAITS_HPP

#include <boost/intrusive/link_mode.hpp>
+#include <boost/intrusive/pointer_traits.hpp>

namespace boost {
namespace intrusive {
@@ -31,10 +32,12 @@
 typedef node_ptr pointer;
 typedef const_node_ptr const_pointer;
 static const link_mode_type link_mode = LinkMode;
- static node_ptr to_node_ptr (value_type &value) { return node_ptr(&value); }
- static const_node_ptr to_node_ptr (const value_type &value) { return const_node_ptr(&value); }
- static pointer to_value_ptr(node_ptr n) { return pointer(n); }
- static const_pointer to_value_ptr(const_node_ptr n) { return const_pointer(n); }
+ static node_ptr to_node_ptr (value_type &value)
+ { return pointer_traits<node_ptr>::pointer_to(value); }
+ static const_node_ptr to_node_ptr (const value_type &value)
+ { return pointer_traits<const_node_ptr>::pointer_to(value); }
+ static const pointer & to_value_ptr(const node_ptr &n) { return n; }
+ static const const_pointer &to_value_ptr(const const_node_ptr &n) { return n; }
};

} //namespace intrusive

Modified: branches/release/boost/intrusive/unordered_set_hook.hpp
==============================================================================
--- branches/release/boost/intrusive/unordered_set_hook.hpp (original)
+++ branches/release/boost/intrusive/unordered_set_hook.hpp 2011-12-26 12:10:27 EST (Mon, 26 Dec 2011)
@@ -18,9 +18,10 @@
#include <boost/intrusive/intrusive_fwd.hpp>
#include <boost/pointer_cast.hpp>
#include <boost/intrusive/detail/utilities.hpp>
-#include <boost/intrusive/detail/pointer_to_other.hpp>
+#include <boost/intrusive/pointer_traits.hpp>
#include <boost/intrusive/slist_hook.hpp>
#include <boost/intrusive/options.hpp>
+#include <boost/intrusive/pointer_traits.hpp>
#include <boost/intrusive/detail/generic_hook.hpp>

namespace boost {
@@ -32,10 +33,10 @@
struct unordered_node
 : public slist_node<VoidPointer>
{
- typedef typename boost::pointer_to_other
- < VoidPointer
- , unordered_node<VoidPointer, StoreHash, OptimizeMultiKey>
- >::type node_ptr;
+ typedef typename pointer_traits
+ <VoidPointer>::template rebind_pointer
+ < unordered_node<VoidPointer, StoreHash, OptimizeMultiKey> >::type
+ node_ptr;
 node_ptr prev_in_group_;
 std::size_t hash_;
};
@@ -44,10 +45,10 @@
struct unordered_node<VoidPointer, false, true>
 : public slist_node<VoidPointer>
{
- typedef typename boost::pointer_to_other
- < VoidPointer
- , unordered_node<VoidPointer, false, true>
- >::type node_ptr;
+ typedef typename pointer_traits
+ <VoidPointer>::template rebind_pointer
+ < unordered_node<VoidPointer, false, true> >::type
+ node_ptr;
 node_ptr prev_in_group_;
};

@@ -55,10 +56,10 @@
struct unordered_node<VoidPointer, true, false>
 : public slist_node<VoidPointer>
{
- typedef typename boost::pointer_to_other
- < VoidPointer
- , unordered_node<VoidPointer, true, false>
- >::type node_ptr;
+ typedef typename pointer_traits
+ <VoidPointer>::template rebind_pointer
+ < unordered_node<VoidPointer, true, false> >::type
+ node_ptr;
 std::size_t hash_;
};

@@ -68,35 +69,35 @@
{
 typedef slist_node_traits<VoidPointer> reduced_slist_node_traits;
 typedef unordered_node<VoidPointer, StoreHash, OptimizeMultiKey> node;
- typedef typename boost::pointer_to_other
- <VoidPointer, node>::type node_ptr;
- typedef typename boost::pointer_to_other
- <VoidPointer, const node>::type const_node_ptr;
+
+ typedef typename pointer_traits
+ <VoidPointer>::template rebind_pointer
+ < node >::type node_ptr;
+ typedef typename pointer_traits
+ <VoidPointer>::template rebind_pointer
+ < const node >::type const_node_ptr;

 static const bool store_hash = StoreHash;
 static const bool optimize_multikey = OptimizeMultiKey;

- static node_ptr get_next(const_node_ptr n)
+ static node_ptr get_next(const const_node_ptr & n)
 {
-// This still fails in gcc < 4.4 so forget about it
-// using ::boost::static_pointer_cast;
-// return static_pointer_cast<node>(n->next_);
- return node_ptr(&static_cast<node&>(*n->next_));
+ return pointer_traits<node_ptr>::pointer_to(static_cast<node&>(*n->next_));
 }

- static void set_next(node_ptr n, node_ptr next)
+ static void set_next(const node_ptr & n, const node_ptr & next)
 { n->next_ = next; }

- static node_ptr get_prev_in_group(const_node_ptr n)
+ static node_ptr get_prev_in_group(const const_node_ptr & n)
 { return n->prev_in_group_; }

- static void set_prev_in_group(node_ptr n, node_ptr prev)
+ static void set_prev_in_group(const node_ptr & n, const node_ptr & prev)
 { n->prev_in_group_ = prev; }

- static std::size_t get_hash(const_node_ptr n)
+ static std::size_t get_hash(const const_node_ptr & n)
 { return n->hash_; }

- static void set_hash(node_ptr n, std::size_t h)
+ static void set_hash(const node_ptr & n, std::size_t h)
 { n->hash_ = h; }
};

@@ -107,10 +108,10 @@
 typedef typename NodeTraits::node_ptr node_ptr;
 typedef typename NodeTraits::const_node_ptr const_node_ptr;

- static node_ptr get_next(const_node_ptr n)
+ static node_ptr get_next(const const_node_ptr & n)
 { return NodeTraits::get_prev_in_group(n); }

- static void set_next(node_ptr n, node_ptr next)
+ static void set_next(const node_ptr & n, const node_ptr & next)
 { NodeTraits::set_prev_in_group(n, next); }
};

Modified: branches/release/boost/move/move.hpp
==============================================================================
--- branches/release/boost/move/move.hpp (original)
+++ branches/release/boost/move/move.hpp 2011-12-26 12:10:27 EST (Mon, 26 Dec 2011)
@@ -23,9 +23,12 @@

#ifdef BOOST_MSVC
 #ifndef _CRT_SECURE_NO_DEPRECATE
- #define BOOST_INTERPROCESS_CRT_SECURE_NO_DEPRECATE
- #define _CRT_SECURE_NO_DEPRECATE
- #define _SCL_SECURE_NO_WARNINGS
+ #define BOOST_INTERPROCESS_CRT_SECURE_NO_DEPRECATE
+ #define _CRT_SECURE_NO_DEPRECATE
+ #endif
+ #ifndef _SCL_SECURE_NO_WARNINGS
+ #define BOOST_INTERPROCESS_SCL_SECURE_NO_WARNINGS
+ #define _SCL_SECURE_NO_WARNINGS
 #endif
 #pragma warning (push)
 #pragma warning(disable:4996)
@@ -1080,14 +1083,112 @@
 : BOOST_MOVE_BOOST_NS::has_trivial_destructor<T>
{};

+
+
+namespace move_detail {
+
+// Code from Jeffrey Lee Hellrung, many thanks
+
+#ifndef BOOST_NO_RVALUE_REFERENCES
+ template< class T> struct forward_type { typedef T type; };
+#else // #ifndef BOOST_NO_RVALUE_REFERENCES
+ template< class T>
+ struct forward_type
+ { typedef const T &type; };
+
+ template< class T>
+ struct forward_type< boost::rv<T> >
+ { typedef T type; };
+#endif // #ifndef BOOST_NO_RVALUE_REFERENCES
+
+
+
+// Code from Jeffrey Lee Hellrung, many thanks
+
+template< class T > struct is_rvalue_reference : BOOST_MOVE_BOOST_NS::integral_constant<bool, false> { };
+#ifndef BOOST_NO_RVALUE_REFERENCES
+ template< class T > struct is_rvalue_reference< T&& > : BOOST_MOVE_BOOST_NS::integral_constant<bool, true> { };
+#else // #ifndef BOOST_NO_RVALUE_REFERENCES
+ template< class T > struct is_rvalue_reference< boost::rv<T>& >
+ : BOOST_MOVE_BOOST_NS::integral_constant<bool, true>
+ {};
+
+ template< class T > struct is_rvalue_reference< const boost::rv<T>& >
+ : BOOST_MOVE_BOOST_NS::integral_constant<bool, true>
+ {};
+#endif // #ifndef BOOST_NO_RVALUE_REFERENCES
+
+#ifndef BOOST_NO_RVALUE_REFERENCES
+ template< class T > struct add_rvalue_reference { typedef T&& type; };
+#else // #ifndef BOOST_NO_RVALUE_REFERENCES
+ namespace detail_add_rvalue_reference
+ {
+ template< class T
+ , bool emulation = ::boost::has_move_emulation_enabled<T>::value
+ , bool rv = ::boost::move_detail::is_rv<T>::value >
+ struct add_rvalue_reference_impl { typedef T type; };
+
+ template< class T, bool emulation>
+ struct add_rvalue_reference_impl< T, emulation, true > { typedef T & type; };
+
+ template< class T, bool rv >
+ struct add_rvalue_reference_impl< T, true, rv > { typedef ::boost::rv<T>& type; };
+ } // namespace detail_add_rvalue_reference
+
+ template< class T >
+ struct add_rvalue_reference
+ : detail_add_rvalue_reference::add_rvalue_reference_impl<T>
+ { };
+
+ template< class T >
+ struct add_rvalue_reference<T &>
+ { typedef T & type; };
+
+#endif // #ifndef BOOST_NO_RVALUE_REFERENCES
+
+template< class T > struct remove_rvalue_reference { typedef T type; };
+
+#ifndef BOOST_NO_RVALUE_REFERENCES
+ template< class T > struct remove_rvalue_reference< T&& > { typedef T type; };
+#else // #ifndef BOOST_NO_RVALUE_REFERENCES
+ template< class T > struct remove_rvalue_reference< rv<T> > { typedef T type; };
+ template< class T > struct remove_rvalue_reference< const rv<T> > { typedef T type; };
+ template< class T > struct remove_rvalue_reference< volatile rv<T> > { typedef T type; };
+ template< class T > struct remove_rvalue_reference< const volatile rv<T> > { typedef T type; };
+ template< class T > struct remove_rvalue_reference< rv<T>& > { typedef T type; };
+ template< class T > struct remove_rvalue_reference< const rv<T>& > { typedef T type; };
+ template< class T > struct remove_rvalue_reference< volatile rv<T>& > { typedef T type; };
+ template< class T > struct remove_rvalue_reference< const volatile rv<T>& >{ typedef T type; };
+#endif // #ifndef BOOST_NO_RVALUE_REFERENCES
+
+template <typename T>
+typename boost::move_detail::add_rvalue_reference<T>::type declval();
+
+}
+// Ideas from Boost.Move review, Jeffrey Lee Hellrung:
+//
+//- TypeTraits metafunctions is_lvalue_reference, add_lvalue_reference, and remove_lvalue_reference ?
+// Perhaps add_reference and remove_reference can be modified so that they behave wrt emulated rvalue
+// references the same as wrt real rvalue references, i.e., add_reference< rv<T>& > -> T& rather than
+// rv<T>& (since T&& & -> T&).
+//
+//- Add'l TypeTraits has_[trivial_]move_{constructor,assign}...?
+//
+//- An as_lvalue(T& x) function, which amounts to an identity operation in C++0x, but strips emulated
+// rvalue references in C++03. This may be necessary to prevent "accidental moves".
+
} //namespace boost {

#if defined BOOST_MSVC
 #pragma warning (pop)
 #ifdef BOOST_INTERPROCESS_CRT_SECURE_NO_DEPRECATE
- #undef BOOST_INTERPROCESS_CRT_SECURE_NO_DEPRECATE
- #undef _CRT_SECURE_NO_DEPRECATE
- #undef _SCL_SECURE_NO_WARNINGS
+ #undef BOOST_INTERPROCESS_CRT_SECURE_NO_DEPRECATE
+ #undef _CRT_SECURE_NO_DEPRECATE
+ #endif
+
+ #ifdef BOOST_INTERPROCESS_SCL_SECURE_NO_WARNINGS
+ #undef BOOST_INTERPROCESS_SCL_SECURE_NO_WARNINGS
+ #undef _SCL_SECURE_NO_WARNINGS
 #endif
#endif

Date view	Thread view	Subject view	Author view

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