Index: boost/intrusive/avltree.hpp
===================================================================
--- boost/intrusive/avltree.hpp	(revision 58999)
+++ boost/intrusive/avltree.hpp	(working copy)
@@ -167,7 +167,7 @@
 
    static node_ptr uncast(const_node_ptr ptr)
    {
-      return node_ptr(const_cast<node*>(detail::get_pointer(ptr)));
+      return node_ptr(const_cast<node*>(detail::get_pointer_no_adl(ptr)));
    }
 
    size_traits &priv_size_traits()
@@ -1398,7 +1398,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::get_pointer(end_iterator.pointed_node()), &header_plus_size::header_);
+         ( detail::get_pointer_no_adl(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_);
Index: boost/intrusive/avltree_algorithms.hpp
===================================================================
--- boost/intrusive/avltree_algorithms.hpp	(revision 58999)
+++ boost/intrusive/avltree_algorithms.hpp	(working copy)
@@ -104,7 +104,7 @@
 
    static node_ptr uncast(const_node_ptr ptr)
    {
-      return node_ptr(const_cast<node*>(::boost::intrusive::detail::get_pointer(ptr)));
+      return node_ptr(const_cast<node*>(::boost::intrusive::detail::get_pointer_no_adl(ptr)));
    }
    /// @endcond
 
Index: boost/intrusive/derivation_value_traits.hpp
===================================================================
--- boost/intrusive/derivation_value_traits.hpp	(revision 58999)
+++ boost/intrusive/derivation_value_traits.hpp	(working copy)
@@ -44,10 +44,10 @@
    { return node_ptr(&value); }
 
    static pointer to_value_ptr(node_ptr n) 
-   {  return pointer(static_cast<T*>(detail::get_pointer(n))); }
+   {  return pointer(static_cast<T*>(detail::get_pointer_no_adl(n))); }
 
    static const_pointer to_value_ptr(const_node_ptr n)
-   {  return const_pointer(static_cast<const T*>(detail::get_pointer(n))); }
+   {  return const_pointer(static_cast<const T*>(detail::get_pointer_no_adl(n))); }
 };
 
 } //namespace intrusive 
Index: boost/intrusive/detail/hashtable_node.hpp
===================================================================
--- boost/intrusive/detail/hashtable_node.hpp	(revision 58999)
+++ boost/intrusive/detail/hashtable_node.hpp	(working copy)
@@ -164,10 +164,10 @@
    { return *this->operator ->(); }
 
    pointer operator->() const
-   { return detail::get_pointer(this->get_real_value_traits()->to_value_ptr(downcast_bucket(slist_it_.pointed_node()))); }
+   { return detail::get_pointer_no_adl(this->get_real_value_traits()->to_value_ptr(downcast_bucket(slist_it_.pointed_node()))); }
 
    const Container *get_container() const
-   {  return detail::get_pointer(cont_);  }
+   {  return detail::get_pointer_no_adl(cont_);  }
 
    const real_value_traits *get_real_value_traits() const
    {  return &this->get_container()->get_real_value_traits();  }
@@ -175,8 +175,8 @@
    private:
    void increment()
    {
-      const Container *cont =  detail::get_pointer(cont_);
-      bucket_type* buckets = detail::get_pointer(cont->bucket_pointer());
+      const Container *cont =  detail::get_pointer_no_adl(cont_);
+      bucket_type* buckets = detail::get_pointer_no_adl(cont->bucket_pointer());
       size_type   buckets_len    = cont->bucket_count();
 
       ++slist_it_;
Index: boost/intrusive/detail/list_node.hpp
===================================================================
--- boost/intrusive/detail/list_node.hpp	(revision 58999)
+++ boost/intrusive/detail/list_node.hpp	(working copy)
@@ -143,7 +143,7 @@
    {  return *operator->();   }
 
    pointer operator->() const
-   { return detail::get_pointer(this->get_real_value_traits()->to_value_ptr(members_.nodeptr_)); }
+   { return detail::get_pointer_no_adl(this->get_real_value_traits()->to_value_ptr(members_.nodeptr_)); }
 
    const Container *get_container() const
    {
Index: boost/intrusive/detail/slist_node.hpp
===================================================================
--- boost/intrusive/detail/slist_node.hpp	(revision 58999)
+++ boost/intrusive/detail/slist_node.hpp	(working copy)
@@ -122,7 +122,7 @@
    {  return *operator->();   }
 
    pointer operator->() const
-   { return detail::get_pointer(this->get_real_value_traits()->to_value_ptr(members_.nodeptr_)); }
+   { return detail::get_pointer_no_adl(this->get_real_value_traits()->to_value_ptr(members_.nodeptr_)); }
 
    const Container *get_container() const
    {
Index: boost/intrusive/detail/tree_algorithms.hpp
===================================================================
--- boost/intrusive/detail/tree_algorithms.hpp	(revision 58999)
+++ boost/intrusive/detail/tree_algorithms.hpp	(working copy)
@@ -140,7 +140,7 @@
 
    static node_ptr uncast(const_node_ptr ptr)
    {
-      return node_ptr(const_cast<node*>(::boost::intrusive::detail::get_pointer(ptr)));
+      return node_ptr(const_cast<node*>(::boost::intrusive::detail::get_pointer_no_adl(ptr)));
    }
    /// @endcond
 
Index: boost/intrusive/detail/tree_node.hpp
===================================================================
--- boost/intrusive/detail/tree_node.hpp	(revision 58999)
+++ boost/intrusive/detail/tree_node.hpp	(working copy)
@@ -153,7 +153,7 @@
    {  return *operator->();   }
 
    pointer operator->() const
-   { return detail::get_pointer(this->get_real_value_traits()->to_value_ptr(members_.nodeptr_)); }
+   { return detail::get_pointer_no_adl(this->get_real_value_traits()->to_value_ptr(members_.nodeptr_)); }
 
    const Container *get_container() const
    {  return static_cast<const Container*>(members_.get_ptr());   }
Index: boost/intrusive/detail/utilities.hpp
===================================================================
--- boost/intrusive/detail/utilities.hpp	(revision 58999)
+++ boost/intrusive/detail/utilities.hpp	(working copy)
@@ -125,7 +125,7 @@
 //!Overload for smart pointers to avoid ADL problems with get_pointer
 template<class Ptr>
 inline typename smart_ptr_type<Ptr>::pointer
-get_pointer(const Ptr &ptr)
+get_pointer_no_adl(const Ptr &ptr)
 {  return smart_ptr_type<Ptr>::get(ptr);   }
 
 //This functor compares a stored value
@@ -319,7 +319,7 @@
    {}
 
    const void *get_ptr() const
-   {  return detail::get_pointer(const_void_ptr_);  }
+   {  return detail::get_pointer_no_adl(const_void_ptr_);  }
 
    ConstVoidPtr const_void_ptr_;
 };
@@ -422,13 +422,13 @@
    static pointer to_value_ptr(node_ptr n)
    {
       return detail::parent_from_member<T, Hook>
-         (static_cast<Hook*>(detail::get_pointer(n)), P);
+         (static_cast<Hook*>(detail::get_pointer_no_adl(n)), P);
    }
 
    static const_pointer to_value_ptr(const_node_ptr n)
    {
       return detail::parent_from_member<T, Hook>
-         (static_cast<const Hook*>(detail::get_pointer(n)), P);
+         (static_cast<const Hook*>(detail::get_pointer_no_adl(n)), P);
    }
 };
 
Index: boost/intrusive/hashtable.hpp
===================================================================
--- boost/intrusive/hashtable.hpp	(revision 58999)
+++ boost/intrusive/hashtable.hpp	(working copy)
@@ -886,7 +886,7 @@
       }
       else{
          size_type buckets_len = this->priv_buckets_len();
-         const bucket_type *b = detail::get_pointer(this->priv_buckets());
+         const bucket_type *b = detail::get_pointer_no_adl(this->priv_buckets());
          for (size_type n = 0; n < buckets_len; ++n, ++b){
             if(!b->empty()){
                return false;
@@ -909,7 +909,7 @@
       else{
          size_type len = 0;
          size_type buckets_len = this->priv_buckets_len();
-         const bucket_type *b = detail::get_pointer(this->priv_buckets());
+         const bucket_type *b = detail::get_pointer_no_adl(this->priv_buckets());
          for (size_type n = 0; n < buckets_len; ++n, ++b){
             len += b->size();
          }
@@ -2240,7 +2240,7 @@
    {  return this->priv_real_bucket_traits().bucket_count();  }
 
    static node_ptr uncast(const_node_ptr ptr)
-   {  return node_ptr(const_cast<node*>(detail::get_pointer(ptr)));  }
+   {  return node_ptr(const_cast<node*>(detail::get_pointer_no_adl(ptr)));  }
 
    node &priv_value_to_node(value_type &v)
    {  return *this->get_real_value_traits().to_node_ptr(v);  }
Index: boost/intrusive/list.hpp
===================================================================
--- boost/intrusive/list.hpp	(revision 58999)
+++ boost/intrusive/list.hpp	(working copy)
@@ -129,8 +129,8 @@
    //Const cast emulation for smart pointers
    static node_ptr uncast(const_node_ptr ptr)
    {
-      //return node_ptr(detail::get_pointer(ptr)));
-      return const_cast<node*>(detail::get_pointer(ptr));
+      //return node_ptr(detail::get_pointer_no_adl(ptr)));
+      return const_cast<node*>(detail::get_pointer_no_adl(ptr));
    }
 
    node_ptr get_root_node()
@@ -1268,7 +1268,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::get_pointer(end_iterator.pointed_node()), &root_plus_size::root_);
+         ( detail::get_pointer_no_adl(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_);
Index: boost/intrusive/member_value_traits.hpp
===================================================================
--- boost/intrusive/member_value_traits.hpp	(revision 58999)
+++ boost/intrusive/member_value_traits.hpp	(working copy)
@@ -49,13 +49,13 @@
    static pointer to_value_ptr(node_ptr n)
    {
       return pointer(detail::parent_from_member<value_type, node>
-         (detail::get_pointer(n), PtrToMember)); 
+         (detail::get_pointer_no_adl(n), PtrToMember)); 
    }
 
    static const_pointer to_value_ptr(const_node_ptr n)
    {
       return pointer(detail::parent_from_member<value_type, node>
-         (detail::get_pointer(n), PtrToMember)); 
+         (detail::get_pointer_no_adl(n), PtrToMember)); 
    }
 };
 
Index: boost/intrusive/rbtree.hpp
===================================================================
--- boost/intrusive/rbtree.hpp	(revision 58999)
+++ boost/intrusive/rbtree.hpp	(working copy)
@@ -167,7 +167,7 @@
 
    static node_ptr uncast(const_node_ptr ptr)
    {
-      return node_ptr(const_cast<node*>(detail::get_pointer(ptr)));
+      return node_ptr(const_cast<node*>(detail::get_pointer_no_adl(ptr)));
    }
 
    size_traits &priv_size_traits()
@@ -1390,7 +1390,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::get_pointer(end_iterator.pointed_node()), &header_plus_size::header_);
+         ( detail::get_pointer_no_adl(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_);
Index: boost/intrusive/rbtree_algorithms.hpp
===================================================================
--- boost/intrusive/rbtree_algorithms.hpp	(revision 58999)
+++ boost/intrusive/rbtree_algorithms.hpp	(working copy)
@@ -157,7 +157,7 @@
 
    static node_ptr uncast(const_node_ptr ptr)
    {
-      return node_ptr(const_cast<node*>(::boost::intrusive::detail::get_pointer(ptr)));
+      return node_ptr(const_cast<node*>(::boost::intrusive::detail::get_pointer_no_adl(ptr)));
    }
    /// @endcond
 
Index: boost/intrusive/sgtree.hpp
===================================================================
--- boost/intrusive/sgtree.hpp	(revision 58999)
+++ boost/intrusive/sgtree.hpp	(working copy)
@@ -310,7 +310,7 @@
    {  return data_.node_plus_pred_.header_plus_alpha_.header_;  }
 
    static node_ptr uncast(const_node_ptr ptr)
-   {  return node_ptr(const_cast<node*>(detail::get_pointer(ptr)));  }
+   {  return node_ptr(const_cast<node*>(detail::get_pointer_no_adl(ptr)));  }
 
    size_traits &priv_size_traits()
    {  return data_.node_plus_pred_.size_traits_;  }
@@ -1631,7 +1631,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::get_pointer(end_iterator.pointed_node()), &header_plus_alpha::header_);
+         ( detail::get_pointer_no_adl(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_);
Index: boost/intrusive/sgtree_algorithms.hpp
===================================================================
--- boost/intrusive/sgtree_algorithms.hpp	(revision 58999)
+++ boost/intrusive/sgtree_algorithms.hpp	(working copy)
@@ -70,7 +70,7 @@
 
    static node_ptr uncast(const_node_ptr ptr)
    {
-      return node_ptr(const_cast<node*>(::boost::intrusive::detail::get_pointer(ptr)));
+      return node_ptr(const_cast<node*>(::boost::intrusive::detail::get_pointer_no_adl(ptr)));
    }
    /// @endcond
 
Index: boost/intrusive/slist.hpp
===================================================================
--- boost/intrusive/slist.hpp	(revision 58999)
+++ boost/intrusive/slist.hpp	(working copy)
@@ -206,7 +206,7 @@
    {  data_.root_plus_size_.last_ = n;  }
 
    static node_ptr uncast(const_node_ptr ptr)
-   {  return node_ptr(const_cast<node*>(detail::get_pointer(ptr)));  }
+   {  return node_ptr(const_cast<node*>(detail::get_pointer_no_adl(ptr)));  }
 
    void set_default_constructed_state()
    {
@@ -1879,7 +1879,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::get_pointer(end_iterator.pointed_node()), (&root_plus_size::root_));
+         ( detail::get_pointer_no_adl(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_);
Index: boost/intrusive/splaytree.hpp
===================================================================
--- boost/intrusive/splaytree.hpp	(revision 58999)
+++ boost/intrusive/splaytree.hpp	(working copy)
@@ -166,7 +166,7 @@
 
    static node_ptr uncast(const_node_ptr ptr)
    {
-      return node_ptr(const_cast<node*>(detail::get_pointer(ptr)));
+      return node_ptr(const_cast<node*>(detail::get_pointer_no_adl(ptr)));
    }
 
    size_traits &priv_size_traits()
@@ -1405,7 +1405,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::get_pointer(end_iterator.pointed_node()), &header_plus_size::header_);
+         ( detail::get_pointer_no_adl(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_);
Index: boost/intrusive/splaytree_algorithms.hpp
===================================================================
--- boost/intrusive/splaytree_algorithms.hpp	(revision 58999)
+++ boost/intrusive/splaytree_algorithms.hpp	(working copy)
@@ -147,7 +147,7 @@
    private:
    static node_ptr uncast(const_node_ptr ptr)
    {
-      return node_ptr(const_cast<node*>(::boost::intrusive::detail::get_pointer(ptr)));
+      return node_ptr(const_cast<node*>(::boost::intrusive::detail::get_pointer_no_adl(ptr)));
    }
    /// @endcond
 
Index: boost/intrusive/treap.hpp
===================================================================
--- boost/intrusive/treap.hpp	(revision 58999)
+++ boost/intrusive/treap.hpp	(working copy)
@@ -184,7 +184,7 @@
 
    static node_ptr uncast(const_node_ptr ptr)
    {
-      return node_ptr(const_cast<node*>(detail::get_pointer(ptr)));
+      return node_ptr(const_cast<node*>(detail::get_pointer_no_adl(ptr)));
    }
 
    size_traits &priv_size_traits()
@@ -1482,7 +1482,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::get_pointer(end_iterator.pointed_node()), &header_plus_size::header_);
+         ( detail::get_pointer_no_adl(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
Index: boost/intrusive/treap_algorithms.hpp
===================================================================
--- boost/intrusive/treap_algorithms.hpp	(revision 58999)
+++ boost/intrusive/treap_algorithms.hpp	(working copy)
@@ -145,7 +145,7 @@
 
    static node_ptr uncast(const_node_ptr ptr)
    {
-      return node_ptr(const_cast<node*>(::boost::intrusive::detail::get_pointer(ptr)));
+      return node_ptr(const_cast<node*>(::boost::intrusive::detail::get_pointer_no_adl(ptr)));
    }
    /// @endcond
 
Index: libs/intrusive/test/common_functors.hpp
===================================================================
--- libs/intrusive/test/common_functors.hpp	(revision 58999)
+++ libs/intrusive/test/common_functors.hpp	(working copy)
@@ -29,7 +29,7 @@
    {
       typedef typename std::iterator_traits<Pointer>::value_type value_type;
       BOOST_INTRUSIVE_INVARIANT_ASSERT(( detail::is_same<T, value_type>::value ));
-      delete detail::get_pointer(p); 
+      delete detail::get_pointer_no_adl(p); 
    }
 };
 
Index: libs/intrusive/test/smart_ptr.hpp
===================================================================
--- libs/intrusive/test/smart_ptr.hpp	(revision 58999)
+++ libs/intrusive/test/smart_ptr.hpp	(working copy)
@@ -303,7 +303,7 @@
    pt2 = ptr;
 }
 
-//!detail::get_pointer() enables boost::mem_fn to recognize smart_ptr.
+//!get_pointer() enables boost::mem_fn to recognize smart_ptr.
 //!Never throws.
 template<class T>
 inline T* get_pointer(const smart_ptr<T>  & p)