New Interprocess version

[SVN r38271]

include/boost/intrusive/derivation_value_traits.hpp

@@ -0,0 +1,57 @@
+/////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga  2006-2007
+//
+// 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_DERIVATION_VALUE_TRAITS_HPP
+#define BOOST_INTRUSIVE_DERIVATION_VALUE_TRAITS_HPP
+
+#include <boost/intrusive/linking_policy.hpp>
+#include <iterator>
+
+namespace boost {
+namespace intrusive {
+
+//!This value traits template is used to create value traits
+//!from user defined node traits where value_traits::value_type will
+//!derive from node_traits::node
+template<class T, class NodeTraits, linking_policy Policy>
+struct derivation_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;
+
+   enum { linking_policy = Policy };
+
+   static node_ptr to_node_ptr(reference value)
+   { return node_ptr(&value); }
+
+   static const_node_ptr to_node_ptr(const_reference value)
+   { return node_ptr(&value); }
+
+   static pointer to_value_ptr(node_ptr n) 
+   {  return pointer(static_cast<T*>(detail::get_pointer(n))); }
+
+   static const_pointer to_value_ptr(const_node_ptr n)
+   {  return const_pointer(static_cast<T*>(detail::get_pointer(n))); }
+};
+
+} //namespace intrusive 
+} //namespace boost 
+
+#endif //BOOST_INTRUSIVE_DERIVATION_VALUE_TRAITS_HPP

include/boost/intrusive/detail/assert.hpp

@@ -22,14 +22,14 @@
 #define BOOST_INTRUSIVE_INVARIANT_ASSERT BOOST_ASSERT
 #endif
 
-#if !defined(BOOST_INTRUSIVE_SAFE_MODE_CONTAINER_INSERTION_ASSERT)
+#if !defined(BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT)
 #include <boost/assert.hpp>
-#define BOOST_INTRUSIVE_SAFE_MODE_CONTAINER_INSERTION_ASSERT BOOST_ASSERT
+#define BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT BOOST_ASSERT
 #endif
 
-#if !defined(BOOST_INTRUSIVE_SAFE_MODE_HOOK_DESTRUCTOR_ASSERT)
+#if !defined(BOOST_INTRUSIVE_SAFE_HOOK_DESTRUCTOR_ASSERT)
 #include <boost/assert.hpp>
-#define BOOST_INTRUSIVE_SAFE_MODE_HOOK_DESTRUCTOR_ASSERT BOOST_ASSERT
+#define BOOST_INTRUSIVE_SAFE_HOOK_DESTRUCTOR_ASSERT BOOST_ASSERT
 #endif
 
 #endif //BOOST_INTRUSIVE_DETAIL_ASSERT_HPP

include/boost/intrusive/detail/config_begin.hpp

@@ -12,8 +12,6 @@
 
 #ifndef BOOST_INTRUSIVE_SELECT_COMPILER_INCLUDED
 #ifndef BOOST_COMPILER_CONFIG
-//#include <boost/config/select_compiler_config.hpp>
-//#include BOOST_COMPILER_CONFIG
 #include <boost/config.hpp>
 #endif
 #define BOOST_INTRUSIVE_SELECT_COMPILER_INCLUDED

include/boost/intrusive/detail/parent_from_member.hpp

@@ -14,32 +14,34 @@
 
 #include <boost/intrusive/detail/config_begin.hpp>
 #include <cstddef>
+
 namespace boost {
 namespace intrusive {
 namespace detail {
 
 template<class Parent, class Member>
-std::size_t offset_from_pointer_to_member(const Member Parent::* ptr_to_member)
+inline std::size_t offset_from_pointer_to_member(const Member Parent::* ptr_to_member)
 {
    //The implementation of a pointer to member is compiler dependent.
-   #if (defined(_MSC_VER)  || defined(__GNUC__) || defined(BOOST_INTEL) || defined(__HP_aCC))
+   #if (defined(_MSC_VER)  || defined(__GNUC__) || \
+        defined(BOOST_INTEL) || defined(__HP_aCC))
    //This works with gcc, msvc, ac++
-   return *(const std::size_t*)(const void*)&ptr_to_member;
+   return *(const std::ptrdiff_t*)(void*)&ptr_to_member;
    #else
    //This is the traditional C-front approach: __MWERKS__, __DMC__, __SUNPRO_CC
-   return *(const std::size_t*)(const void*)&ptr_to_member - 1;
+   return *(const std::ptrdiff_t*)(void*)&ptr_to_member - 1;
    #endif
 }
 
 template<class Parent, class Member>
-Parent *parent_from_member(Member *member, const Member Parent::* ptr_to_member)
+inline Parent *parent_from_member(Member *member, const Member Parent::* ptr_to_member)
 {
    return (Parent*)((char*)member - 
       offset_from_pointer_to_member(ptr_to_member));
 }
 
 template<class Parent, class Member>
-const Parent *parent_from_member(const Member *member, const Member Parent::* ptr_to_member)
+inline const Parent *parent_from_member(const Member *member, const Member Parent::* ptr_to_member)
 {
    return (const Parent*)((const char*)member - 
       offset_from_pointer_to_member(ptr_to_member));

include/boost/intrusive/detail/utilities.hpp

@@ -116,7 +116,7 @@ struct size_holder<false, SizeType>
 };
 
 template<class T, class DerivationHookType, typename Tag>
-struct derivation_value_traits
+struct derivation_hook_value_traits
 {
    public:
    typedef typename DerivationHookType::node_traits                  node_traits;
@@ -148,7 +148,7 @@ struct derivation_value_traits
 
 
 template<class T, class MemberHookType, MemberHookType T::* P>
-struct member_value_traits
+struct member_hook_value_traits
 {
    public:
    typedef typename MemberHookType::node_traits                      node_traits;
@@ -174,21 +174,22 @@ struct member_value_traits
       return result->to_node_ptr();
    }
 
-   //Now let's be nasty. A pointer to member is usually implemented
-   //as an offset from the start of the class.
-   //get the offset in bytes and go
-   //backwards from n to the value subtracting
-   //the needed bytes.
    static pointer to_value_ptr(node_ptr n)
    {
-      return pointer(parent_from_member<value_type, MemberHookType>
+      return pointer
-         ((MemberHookType*)detail::get_pointer(n), P));
+      (
+         parent_from_member<value_type, MemberHookType>
+            (detail::get_pointer(MemberHookType::to_hook_ptr(n)), P)
+      ); 
    }
 
    static const_pointer to_value_ptr(const_node_ptr n)
    {
-      const_pointer(parent_from_member<value_type, MemberHookType>
+      return const_pointer
-         ((const MemberHookType*)detail::get_pointer(n), P));
+      (
+         parent_from_member<value_type, MemberHookType>
+            (detail::get_pointer(MemberHookType::to_hook_ptr(n)), P)
+      ); 
    }
 };
 
@@ -252,7 +253,7 @@ struct dispatcher
 
 template<class Container>
 void destructor_impl(Container &cont, dispatcher<safe_link>)
-{  (void)cont; BOOST_INTRUSIVE_SAFE_MODE_HOOK_DESTRUCTOR_ASSERT(!cont.is_linked());  }
+{  (void)cont; BOOST_INTRUSIVE_SAFE_HOOK_DESTRUCTOR_ASSERT(!cont.is_linked());  }
 
 template<class Container>
 void destructor_impl(Container &cont, dispatcher<auto_unlink>)

include/boost/intrusive/hashtable.hpp

@@ -22,6 +22,9 @@
 #include <boost/intrusive/detail/assert.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/functional/hash.hpp>
+#ifndef BOOST_INTRUSIVE_DISABLE_EXCEPTION_HANDLING
+#include <boost/detail/no_exceptions_support.hpp>
+#endif
 //General intrusive utilities
 #include <boost/intrusive/intrusive_fwd.hpp>
 #include <boost/intrusive/detail/pointer_to_other.hpp>
@@ -179,6 +182,19 @@ class hashtable
    public:
    typedef insert_commit_data_impl insert_commit_data;
 
+   //! <b>Requires</b>: buckets must not be being used by any other resource.
+   //!
+   //! <b>Effects</b>: Constructs an empty unordered_set, storing a reference
+   //!   to the bucket array and copies of the hasher and equal functors.
+   //!   
+   //! <b>Complexity</b>: Constant. 
+   //! 
+   //! <b>Throws</b>: If value_traits::node_traits::node
+   //!   constructor throws (this does not happen with predefined Boost.Intrusive hooks)
+   //!   or the copy constructor or invocation of Hash or Equal throws. 
+   //!
+   //! <b>Notes</b>: buckets array must be disposed only after
+   //!   *this is disposed. 
    hashtable( bucket_ptr buckets
              , size_type buckets_len
              , const Hash & hasher = Hash()
@@ -193,9 +209,22 @@ class hashtable
       size_traits::set_size(size_type(0));
    }
 
+   //! <b>Effects</b>: Detaches all elements from this. The objects in the unordered_set 
+   //!   are not deleted (i.e. no destructors are called).
+   //! 
+   //! <b>Complexity</b>: Linear to the number of elements in the unordered_set, if 
+   //!   it's a safe-mode or auto-unlink value. Otherwise constant.
+   //! 
+   //! <b>Throws</b>: Nothing.
    ~hashtable() 
    {  this->clear(); }
 
+   //! <b>Effects</b>: Returns an iterator pointing to the beginning of the unordered_set.
+   //! 
+   //! <b>Complexity</b>: Amortized constant time.
+   //!   Worst case (empty unordered_set): O(this->bucket_count())
+   //! 
+   //! <b>Throws</b>: Nothing.
    iterator begin()
    {
       size_type bucket_num;
@@ -203,9 +232,23 @@ class hashtable
       return iterator(local_it, const_bucket_info_ptr(&this->priv_bucket_info()));
    }
 
+   //! <b>Effects</b>: Returns a const_iterator pointing to the beginning
+   //!   of the unordered_set.
+   //!
+   //! <b>Complexity</b>: Amortized constant time.
+   //!   Worst case (empty unordered_set): O(this->bucket_count())
+   //! 
+   //! <b>Throws</b>: Nothing.
    const_iterator begin() const
    {  return cbegin();  }
 
+   //! <b>Effects</b>: Returns a const_iterator pointing to the beginning
+   //!   of the unordered_set.
+   //!
+   //! <b>Complexity</b>: Amortized constant time.
+   //!   Worst case (empty unordered_set): O(this->bucket_count())
+   //! 
+   //! <b>Throws</b>: Nothing.
    const_iterator cbegin() const
    {
       size_type bucket_num;
@@ -213,21 +256,53 @@ class hashtable
       return const_iterator( local_it, const_bucket_info_ptr(&this->priv_bucket_info()));
    }
 
+   //! <b>Effects</b>: Returns an iterator pointing to the end of the unordered_set.
+   //! 
+   //! <b>Complexity</b>: Constant.
+   //! 
+   //! <b>Throws</b>: Nothing.
    iterator end()
    {  return iterator(invalid_local_it(this->priv_bucket_info()), 0);   }
 
+   //! <b>Effects</b>: Returns a const_iterator pointing to the end of the unordered_set.
+   //! 
+   //! <b>Complexity</b>: Constant.
+   //! 
+   //! <b>Throws</b>: Nothing.
    const_iterator end() const
    {  return cend(); }
 
+   //! <b>Effects</b>: Returns a const_iterator pointing to the end of the unordered_set.
+   //! 
+   //! <b>Complexity</b>: Constant.
+   //! 
+   //! <b>Throws</b>: Nothing.
    const_iterator cend() const
    {  return const_iterator(invalid_local_it(this->priv_bucket_info()), 0);  }
 
+   //! <b>Effects</b>: Returns the hasher object used by the unordered_set.
+   //! 
+   //! <b>Complexity</b>: Constant.
+   //! 
+   //! <b>Throws</b>: If hasher copy-constructor throws.
    hasher hash_function() const
    {  return this->priv_hasher();  }
 
+   //! <b>Effects</b>: Returns the key_equal object used by the unordered_set.
+   //! 
+   //! <b>Complexity</b>: Constant.
+   //! 
+   //! <b>Throws</b>: If key_equal copy-constructor throws.
    key_equal key_eq() const
    {  return this->priv_equal();   }
 
+   //! <b>Effects</b>: Returns true is the container is empty.
+   //! 
+   //! <b>Complexity</b>: if ConstantTimeSize is false, average constant time
+   //!   (worst case, with empty() == true): O(this->bucket_count()).
+   //!   Otherwise constant.
+   //! 
+   //! <b>Throws</b>: Nothing.
    bool empty() const
    {
       if(ConstantTimeSize){
@@ -245,6 +320,12 @@ class hashtable
       }
    }
 
+   //! <b>Effects</b>: Returns the number of elements stored in the unordered_set.
+   //! 
+   //! <b>Complexity</b>: Linear to elements contained in *this if
+   //!   ConstantTimeSize is false. Constant-time otherwise.
+   //! 
+   //! <b>Throws</b>: Nothing.
    size_type size() const
    {
       if(ConstantTimeSize)
@@ -260,6 +341,16 @@ class hashtable
       }
    }
 
+   //! <b>Requires</b>: the hasher and the equality function unqualified swap
+   //!   call should not throw.
+   //! 
+   //! <b>Effects</b>: Swaps the contents of two unordered_sets.
+   //!   Swaps also the contained bucket array and equality and hasher functors.
+   //! 
+   //! <b>Complexity</b>: Constant.
+   //!
+   //! <b>Throws</b>: If the swap() call for the comparison or hash functors
+   //!   found using ADL throw. Basic guarantee.
    void swap(hashtable& other)
    {
       using std::swap;
@@ -276,6 +367,19 @@ class hashtable
       }
    }
 
+   //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
+   //!
+   //! <b>Effects</b>: Erases all the elements from *this
+   //!   calling Disposer::operator()(pointer), clones all the 
+   //!   elements from src calling Cloner::operator()(const_reference )
+   //!   and inserts them on *this.
+   //!
+   //!   If cloner throws, all cloned elements are unlinked and disposed
+   //!   calling Disposer::operator()(pointer).
+   //!   
+   //! <b>Complexity</b>: Linear to erased plus inserted elements.
+   //! 
+   //! <b>Throws</b>: If cloner throws. Basic guarantee.
    template <class Cloner, class Disposer>
    void clone_from(const hashtable &src, Cloner cloner, Disposer disposer)
    {
@@ -290,7 +394,9 @@ class hashtable
             const bucket_ptr src_buckets = src.priv_buckets();
             const bucket_ptr dst_buckets = this->priv_buckets();
             size_type constructed;
-            try{
+            #ifndef BOOST_INTRUSIVE_DISABLE_EXCEPTION_HANDLING
+            BOOST_TRY{
+            #endif
                for( constructed = 0
                   ; constructed < dst_bucket_count
                   ; ++constructed){
@@ -310,28 +416,36 @@ class hashtable
                      }
                   }
                }
+            #ifndef BOOST_INTRUSIVE_DISABLE_EXCEPTION_HANDLING
             }
-            catch(...){
+            BOOST_CATCH(...){
                while(constructed--){
                   dst_buckets[constructed].clear_and_dispose(disposer);
                }
-               throw;
+               BOOST_RETHROW;
             }
+            BOOST_CATCH_END
+            #endif
             size_traits::set_size(src.get_size());
          }
          else{
             //Unlike previous cloning algorithm, this can throw
             //if cloner, the hasher or comparison functor throw
             const_iterator b(src.begin()), e(src.end());
-            try{
+            #ifndef BOOST_INTRUSIVE_DISABLE_EXCEPTION_HANDLING
+            BOOST_TRY{
+            #endif
                for(; b != e; ++b){
                   this->insert_equal(*cloner(*b));
                }
+            #ifndef BOOST_INTRUSIVE_DISABLE_EXCEPTION_HANDLING
             }
-            catch(...){
+            BOOST_CATCH(...){
                this->clear_and_dispose(disposer);
-               throw;
+               BOOST_RETHROW;
             }
+            BOOST_CATCH_END
+            #endif
          }
       }
    }
@@ -355,15 +469,43 @@ class hashtable
          this->insert_equal(*b);
    }
 
+   //! <b>Requires</b>: value must be an lvalue
+   //! 
+   //! <b>Effects</b>: Tries to inserts value into the unordered_set.
+   //!
+   //! <b>Returns</b>: If the value
+   //!   is not already present inserts it and returns a pair containing the
+   //!   iterator to the new value and true. If there is an equivalent value
+   //!   returns a pair containing an iterator to the already present value
+   //!   and false.
+   //! 
+   //! <b>Complexity</b>: Average case O(1), worst case O(this->size()).
+   //! 
+   //! <b>Throws</b>: If the internal hasher or the equality functor throws. Strong guarantee.
+   //! 
+   //! <b>Note</b>: Does not affect the validity of iterators and references.
+   //!   No copy-constructors are called.
    std::pair<iterator, bool> insert_unique(reference value)
    {
       insert_commit_data commit_data;
-      std::pair<iterator, bool> ret = insert_unique_check(value, commit_data);
+      std::pair<iterator, bool> ret = insert_unique_check(value, this->priv_hasher(), this->priv_equal(), commit_data);
       if(!ret.second)
          return ret;
       return std::pair<iterator, bool> (insert_unique_commit(value, commit_data), true);
    }
 
+   //! <b>Requires</b>: Dereferencing iterator must yield an lvalue 
+   //!   of type value_type.
+   //! 
+   //! <b>Effects</b>: Equivalent to this->insert(t) for each element in [b, e).
+   //! 
+   //! <b>Complexity</b>: Average case O(N), where N is std::distance(b, e).
+   //!   Worst case O(N*this->size()).
+   //! 
+   //! <b>Throws</b>: If the internal hasher or the equality functor throws. Basic guarantee.
+   //! 
+   //! <b>Note</b>: Does not affect the validity of iterators and references.
+   //!   No copy-constructors are called.
    template<class Iterator>
    void insert_unique(Iterator b, Iterator e)
    {
@@ -371,10 +513,41 @@ class hashtable
          this->insert_unique(*b);
    }
 
-   std::pair<iterator, bool> insert_unique_check
+   //! <b>Requires</b>: "hasher" must be a hash function that induces 
-      (const_reference value, insert_commit_data &commit_data)
+   //!   the same hash values as the stored hasher. The difference is that
-   {  return insert_unique_check(value, this->priv_hasher(), this->priv_equal(), commit_data); }
+   //!   "hasher" hashes the given key instead of the value_type.
-
+   //!
+   //!   "key_value_equal" must be a equality function that induces 
+   //!   the same equality as key_equal. The difference is that
+   //!   "key_value_equal" compares an arbitrary key with the contained values.
+   //! 
+   //! <b>Effects</b>: Checks if a value can be inserted in the unordered_set, using
+   //!   a user provided key instead of the value itself.
+   //!
+   //! <b>Returns</b>: If there is an equivalent value
+   //!   returns a pair containing an iterator to the already present value
+   //!   and false. If the value can be inserted returns true in the returned
+   //!   pair boolean and fills "commit_data" that is meant to be used with
+   //!   the "insert_commit" function.
+   //! 
+   //! <b>Complexity</b>: Average case O(1), worst case O(this->size()).
+   //!
+   //! <b>Throws</b>: If hasher or key_value_equal throw. Strong guarantee.
+   //! 
+   //! <b>Notes</b>: This function is used to improve performance when constructing
+   //!   a value_type is expensive: if there is an equivalent value
+   //!   the constructed object must be discarded. Many times, the part of the
+   //!   node that is used to impose the hash or the equality is much cheaper to
+   //!   construct than the value_type and this function offers the possibility to
+   //!   use that the part to check if the insertion will be successful.
+   //!
+   //!   If the check is successful, the user can construct the value_type and use
+   //!   "insert_commit" to insert the object in constant-time.
+   //!
+   //!   "commit_data" remains valid for a subsequent "insert_commit" only if no more
+   //!   objects are inserted or erased from the unordered_set.
+   //!
+   //!   After a successful rehashing insert_commit_data remains valid.
    template<class KeyType, class KeyHasher, class KeyValueEqual>
    std::pair<iterator, bool> insert_unique_check
       ( const KeyType &key
@@ -394,6 +567,25 @@ class hashtable
          ,success);
    }
 
+   //! <b>Requires</b>: value must be an lvalue of type value_type. commit_data
+   //!   must have been obtained from a previous call to "insert_check".
+   //!   No objects should have been inserted or erased from the unordered_set between
+   //!   the "insert_check" that filled "commit_data" and the call to "insert_commit".
+   //! 
+   //! <b>Effects</b>: Inserts the value in the unordered_set using the information obtained
+   //!   from the "commit_data" that a previous "insert_check" filled.
+   //!
+   //! <b>Returns</b>: An iterator to the newly inserted object.
+   //! 
+   //! <b>Complexity</b>: Constant time.
+   //!
+   //! <b>Throws</b>: Nothing.
+   //! 
+   //! <b>Notes</b>: This function has only sense if a "insert_check" has been
+   //!   previously executed to fill "commit_data". No value should be inserted or
+   //!   erased between the "insert_check" and "insert_commit" calls.
+   //!
+   //!   After a successful rehashing insert_commit_data remains valid.
    iterator insert_unique_commit(reference value, const insert_commit_data &commit_data)
    {
       size_type bucket_num = commit_data.hash % this->priv_buckets_len();
@@ -403,19 +595,78 @@ class hashtable
                      , const_bucket_info_ptr(&this->priv_bucket_info()));
    }
 
+   //! <b>Effects</b>: Erases the element pointed to by i. 
+   //! 
+   //! <b>Complexity</b>: Average case O(1), worst case O(this->size()).
+   //! 
+   //! <b>Throws</b>: Nothing.
+   //! 
+   //! <b>Note</b>: Invalidates the iterators (but not the references)
+   //!    to the erased element. No destructors are called.
    void erase(const_iterator i)
    {  erase_and_dispose(i, detail::null_disposer());  }
 
+   //! <b>Effects</b>: Erases the range pointed to by b end e. 
+   //! 
+   //! <b>Complexity</b>: Average case O(std::distance(b, e)),
+   //!   worst case O(this->size()).
+   //! 
+   //! <b>Throws</b>: Nothing.
+   //! 
+   //! <b>Note</b>: Invalidates the iterators (but not the references)
+   //!    to the erased elements. No destructors are called.
    void erase(const_iterator b, const_iterator e)
    {  erase_and_dispose(b, e, detail::null_disposer());  }
 
+   //! <b>Effects</b>: Erases all the elements with the given value.
+   //! 
+   //! <b>Returns</b>: The number of erased elements.
+   //! 
+   //! <b>Complexity</b>: Average case O(this->count(value)).
+   //!   Worst case O(this->size()).
+   //! 
+   //! <b>Throws</b>: If the internal hasher or the equality functor throws.  Basic guarantee.
+   //! 
+   //! <b>Note</b>: Invalidates the iterators (but not the references)
+   //!    to the erased elements. No destructors are called.
    size_type erase(const_reference value)
    {  return this->erase(value, this->priv_hasher(), this->priv_equal());  }
 
+   //! <b>Requires</b>: "hasher" must be a hash function that induces 
+   //!   the same hash values as the stored hasher. The difference is that
+   //!   "hasher" hashes the given key instead of the value_type.
+   //!
+   //!   "key_value_equal" must be a equality function that induces 
+   //!   the same equality as key_equal. The difference is that
+   //!   "key_value_equal" compares an arbitrary key with the contained values.
+   //!
+   //! <b>Effects</b>: Erases all the elements that have the same hash and
+   //!   compare equal with the given key.
+   //! 
+   //! <b>Returns</b>: The number of erased elements.
+   //! 
+   //! <b>Complexity</b>: Average case O(this->count(value)).
+   //!   Worst case O(this->size()).
+   //! 
+   //! <b>Throws</b>: If hasher or equal throw. Basic guarantee.
+   //! 
+   //! <b>Note</b>: Invalidates the iterators (but not the references)
+   //!    to the erased elements. No destructors are called.
    template<class KeyType, class KeyHasher, class KeyValueEqual>
    size_type erase(const KeyType& key, KeyHasher hasher, KeyValueEqual equal)
    {  return erase_and_dispose(key, hasher, equal, detail::null_disposer()); }
 
+   //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
+   //!
+   //! <b>Effects</b>: Erases the element pointed to by i. 
+   //!   Disposer::operator()(pointer) is called for the removed element.
+   //! 
+   //! <b>Complexity</b>: Average case O(1), worst case O(this->size()).
+   //! 
+   //! <b>Throws</b>: Nothing.
+   //! 
+   //! <b>Note</b>: Invalidates the iterators 
+   //!    to the erased elements.
    template<class Disposer>
    void erase_and_dispose(const_iterator i, Disposer disposer)
    {
@@ -426,6 +677,18 @@ class hashtable
       size_traits::decrement();
    }
 
+   //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
+   //!
+   //! <b>Effects</b>: Erases the range pointed to by b end e.
+   //!   Disposer::operator()(pointer) is called for the removed elements.
+   //! 
+   //! <b>Complexity</b>: Average case O(std::distance(b, e)),
+   //!   worst case O(this->size()).
+   //! 
+   //! <b>Throws</b>: Nothing.
+   //! 
+   //! <b>Note</b>: Invalidates the iterators
+   //!    to the erased elements.
    template<class Disposer>
    void erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer)
    {
@@ -489,10 +752,39 @@ class hashtable
       }
    }
 
+   //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
+   //!
+   //! <b>Effects</b>: Erases all the elements with the given value.
+   //!   Disposer::operator()(pointer) is called for the removed elements.
+   //! 
+   //! <b>Returns</b>: The number of erased elements.
+   //! 
+   //! <b>Complexity</b>: Average case O(this->count(value)).
+   //!   Worst case O(this->size()).
+   //! 
+   //! <b>Throws</b>: If the internal hasher or the equality functor throws. Basic guarantee.
+   //! 
+   //! <b>Note</b>: Invalidates the iterators (but not the references)
+   //!    to the erased elements. No destructors are called.
    template<class Disposer>
    size_type erase_and_dispose(const_reference value, Disposer disposer)
    {  return erase_and_dispose(value, priv_hasher(), priv_equal(), disposer);   }
 
+   //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
+   //!
+   //! <b>Effects</b>: Erases all the elements with the given key.
+   //!   according to the comparison functor "equal".
+   //!   Disposer::operator()(pointer) is called for the removed elements.
+   //!
+   //! <b>Returns</b>: The number of erased elements.
+   //! 
+   //! <b>Complexity</b>: Average case O(this->count(value)).
+   //!   Worst case O(this->size()).
+   //! 
+   //! <b>Throws</b>: If hasher or key_value_equal throw. Basic guarantee.
+   //! 
+   //! <b>Note</b>: Invalidates the iterators
+   //!    to the erased elements.
    template<class KeyType, class KeyHasher, class KeyValueEqual, class Disposer>
    size_type erase_and_dispose(const KeyType& key, KeyHasher hasher
                   ,KeyValueEqual equal, Disposer disposer)
@@ -529,6 +821,15 @@ class hashtable
       return count;
    }
 
+   //! <b>Effects</b>: Erases all of the elements. 
+   //! 
+   //! <b>Complexity</b>: Linear to the number of elements on the container.
+   //!   if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
+   //! 
+   //! <b>Throws</b>: Nothing.
+   //! 
+   //! <b>Note</b>: Invalidates the iterators (but not the references)
+   //!    to the erased elements. No destructors are called.
    void clear()
    {
       if(safemode_or_autounlink){
@@ -537,6 +838,17 @@ class hashtable
       size_traits::set_size(size_type(0));
    }
 
+   //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
+   //! 
+   //! <b>Effects</b>: Erases all of the elements. 
+   //! 
+   //! <b>Complexity</b>: Linear to the number of elements on the container.
+   //!   Disposer::operator()(pointer) is called for the removed elements.
+   //! 
+   //! <b>Throws</b>: Nothing.
+   //! 
+   //! <b>Note</b>: Invalidates the iterators (but not the references)
+   //!    to the erased elements. No destructors are called.
    template<class Disposer>
    void clear_and_dispose(Disposer disposer)
    {
@@ -550,9 +862,27 @@ class hashtable
       }
    }
 
+   //! <b>Effects</b>: Returns the number of contained elements with the given value
+   //! 
+   //! <b>Complexity</b>: Average case O(1), worst case O(this->size()).
+   //! 
+   //! <b>Throws</b>: If the internal hasher or the equality functor throws.
    size_type count(const_reference value) const
    {  return this->count(value, this->priv_hasher(), this->priv_equal());  }
 
+   //! <b>Requires</b>: "hasher" must be a hash function that induces 
+   //!   the same hash values as the stored hasher. The difference is that
+   //!   "hasher" hashes the given key instead of the value_type.
+   //!
+   //!   "key_value_equal" must be a equality function that induces 
+   //!   the same equality as key_equal. The difference is that
+   //!   "key_value_equal" compares an arbitrary key with the contained values.
+   //!
+   //! <b>Effects</b>: Returns the number of contained elements with the given key
+   //!
+   //! <b>Complexity</b>: Average case O(1), worst case O(this->size()).
+   //! 
+   //! <b>Throws</b>: If hasher or equal throw.
    template<class KeyType, class KeyHasher, class KeyValueEqual>
    size_type count(const KeyType &key, const KeyHasher &hasher, const KeyValueEqual &equal) const
    {
@@ -561,9 +891,34 @@ class hashtable
       return count;
    }
 
+   //! <b>Effects</b>: Finds an iterator to the first element is equal to
+   //!   "value" or end() if that element does not exist.
+   //!
+   //! <b>Complexity</b>: Average case O(1), worst case O(this->size()).
+   //! 
+   //! <b>Throws</b>: If the internal hasher or the equality functor throws.
    iterator find(const_reference value)
    {  return find(value, this->priv_hasher(), this->priv_equal());   }
 
+   //! <b>Requires</b>: "hasher" must be a hash function that induces 
+   //!   the same hash values as the stored hasher. The difference is that
+   //!   "hasher" hashes the given key instead of the value_type.
+   //!
+   //!   "key_value_equal" must be a equality function that induces 
+   //!   the same equality as key_equal. The difference is that
+   //!   "key_value_equal" compares an arbitrary key with the contained values.
+   //!
+   //! <b>Effects</b>: Finds an iterator to the first element whose key is 
+   //!   "key" according to the given hasher and equality functor or end() if
+   //!   that element does not exist.
+   //!
+   //! <b>Complexity</b>: Average case O(1), worst case O(this->size()).
+   //! 
+   //! <b>Throws</b>: If hasher or equal throw.
+   //!
+   //! <b>Note</b>: This function is used when constructing a value_type
+   //!   is expensive and the value_type can be compared with a cheaper
+   //!   key type. Usually this key is part of the value_type.
    template<class KeyType, class KeyHasher, class KeyValueEqual>
    iterator find(const KeyType &key, KeyHasher hasher, KeyValueEqual equal)
    {
@@ -573,9 +928,34 @@ class hashtable
                       , const_bucket_info_ptr(&this->priv_bucket_info()));
    }
 
+   //! <b>Effects</b>: Finds a const_iterator to the first element whose key is 
+   //!   "key" or end() if that element does not exist.
+   //! 
+   //! <b>Complexity</b>: Average case O(1), worst case O(this->size()).
+   //! 
+   //! <b>Throws</b>: If the internal hasher or the equality functor throws.
    const_iterator find(const_reference value) const
    {  return find(value, this->priv_hasher(), this->priv_equal());   }
 
+   //! <b>Requires</b>: "hasher" must be a hash function that induces 
+   //!   the same hash values as the stored hasher. The difference is that
+   //!   "hasher" hashes the given key instead of the value_type.
+   //!
+   //!   "key_value_equal" must be a equality function that induces 
+   //!   the same equality as key_equal. The difference is that
+   //!   "key_value_equal" compares an arbitrary key with the contained values.
+   //!
+   //! <b>Effects</b>: Finds an iterator to the first element whose key is 
+   //!   "key" according to the given hasher and equality functor or end() if
+   //!   that element does not exist.
+   //! 
+   //! <b>Complexity</b>: Average case O(1), worst case O(this->size()).
+   //! 
+   //! <b>Throws</b>: If hasher or equal throw.
+   //!
+   //! <b>Note</b>: This function is used when constructing a value_type
+   //!   is expensive and the value_type can be compared with a cheaper
+   //!   key type. Usually this key is part of the value_type.
    template<class KeyType, class KeyHasher, class KeyValueEqual>
    const_iterator find
       (const KeyType &key, KeyHasher hasher, KeyValueEqual equal) const
@@ -586,9 +966,35 @@ class hashtable
                            , const_bucket_info_ptr(&this->priv_bucket_info()));
    }
 
+   //! <b>Effects</b>: Returns a range containing all elements with values equivalent
+   //!   to value. Returns std::make_pair(this->end(), this->end()) if no such 
+   //!   elements exist.
+   //! 
+   //! <b>Complexity</b>: Average case O(this->count(value)). Worst case O(this->size()).
+   //! 
+   //! <b>Throws</b>: If the internal hasher or the equality functor throws.
    std::pair<iterator,iterator> equal_range(const_reference value)
    {  return this->equal_range(value, this->priv_hasher(), this->priv_equal());  }
 
+   //! <b>Requires</b>: "hasher" must be a hash function that induces 
+   //!   the same hash values as the stored hasher. The difference is that
+   //!   "hasher" hashes the given key instead of the value_type.
+   //!
+   //!   "key_value_equal" must be a equality function that induces 
+   //!   the same equality as key_equal. The difference is that
+   //!   "key_value_equal" compares an arbitrary key with the contained values.
+   //!
+   //! <b>Effects</b>: Returns a range containing all elements with equivalent
+   //!   keys. Returns std::make_pair(this->end(), this->end()) if no such 
+   //!   elements exist.
+   //! 
+   //! <b>Complexity</b>: Average case O(this->count(key, hasher, equal)). Worst case O(this->size()).
+   //! 
+   //! <b>Throws</b>: If hasher or the equal throw.
+   //!
+   //! <b>Note</b>: This function is used when constructing a value_type
+   //!   is expensive and the value_type can be compared with a cheaper
+   //!   key type. Usually this key is part of the value_type.
    template<class KeyType, class KeyHasher, class KeyValueEqual>
    std::pair<iterator,iterator> equal_range
       (const KeyType &key, KeyHasher hasher, KeyValueEqual equal)
@@ -602,10 +1008,36 @@ class hashtable
          ,  iterator( ret.second, info_ptr) );
    }
 
+   //! <b>Effects</b>: Returns a range containing all elements with values equivalent
+   //!   to value. Returns std::make_pair(this->end(), this->end()) if no such 
+   //!   elements exist.
+   //! 
+   //! <b>Complexity</b>: Average case O(this->count(value)). Worst case O(this->size()).
+   //! 
+   //! <b>Throws</b>: If the internal hasher or the equality functor throws.
    std::pair<const_iterator, const_iterator>
       equal_range(const_reference value) const
    {  return this->equal_range(value, this->priv_hasher(), this->priv_equal());  }
 
+   //! <b>Requires</b>: "hasher" must be a hash function that induces 
+   //!   the same hash values as the stored hasher. The difference is that
+   //!   "hasher" hashes the given key instead of the value_type.
+   //!
+   //!   "key_value_equal" must be a equality function that induces 
+   //!   the same equality as key_equal. The difference is that
+   //!   "key_value_equal" compares an arbitrary key with the contained values.
+   //!
+   //! <b>Effects</b>: Returns a range containing all elements with equivalent
+   //!   keys. Returns std::make_pair(this->end(), this->end()) if no such 
+   //!   elements exist.
+   //! 
+   //! <b>Complexity</b>: Average case O(this->count(key, hasher, equal)). Worst case O(this->size()).
+   //! 
+   //! <b>Throws</b>: If the hasher or equal throw.
+   //!
+   //! <b>Note</b>: This function is used when constructing a value_type
+   //!   is expensive and the value_type can be compared with a cheaper
+   //!   key type. Usually this key is part of the value_type.
    template<class KeyType, class KeyHasher, class KeyValueEqual>
    std::pair<const_iterator,const_iterator> equal_range
       (const KeyType &key, KeyHasher hasher, KeyValueEqual equal) const
@@ -619,46 +1051,217 @@ class hashtable
          , const_iterator( ret.second, info_ptr) );
    }
 
+   //! <b>Requires</b>: value must be an lvalue and shall be in a unordered_set of
+   //!   appropriate type. Otherwise the behavior is undefined.
+   //! 
+   //! <b>Effects</b>: Returns: a valid iterator belonging to the unordered_set
+   //!   that points to the value
+   //! 
+   //! <b>Complexity</b>: Constant.
+   //! 
+   //! <b>Throws</b>: If the internal hash function throws.
+   iterator iterator_to(reference value)
+   {
+      return iterator( bucket_type::iterator_to(value)
+                     , const_bucket_info_ptr(&this->priv_bucket_info()));
+   }
+
+   //! <b>Requires</b>: value must be an lvalue and shall be in a unordered_set of
+   //!   appropriate type. Otherwise the behavior is undefined.
+   //! 
+   //! <b>Effects</b>: Returns: a valid const_iterator belonging to the
+   //!   unordered_set that points to the value
+   //! 
+   //! <b>Complexity</b>: Constant.
+   //! 
+   //! <b>Throws</b>: If the internal hash function throws.
+   const_iterator iterator_to(const_reference value) const
+   {
+      return const_iterator( bucket_type::iterator_to(const_cast<reference>(value))
+                           , const_bucket_info_ptr(&this->priv_bucket_info()));
+   }
+
+   //! <b>Requires</b>: value must be an lvalue and shall be in a unordered_set of
+   //!   appropriate type. Otherwise the behavior is undefined.
+   //! 
+   //! <b>Effects</b>: Returns: a valid local_iterator belonging to the unordered_set
+   //!   that points to the value
+   //! 
+   //! <b>Complexity</b>: Constant.
+   //! 
+   //! <b>Throws</b>: Nothing.
+   static local_iterator local_iterator_to(reference value)
+   {  return bucket_type::iterator_to(value);  }
+
+   //! <b>Requires</b>: value must be an lvalue and shall be in a unordered_set of
+   //!   appropriate type. Otherwise the behavior is undefined.
+   //! 
+   //! <b>Effects</b>: Returns: a valid const_local_iterator belonging to
+   //!   the unordered_set that points to the value
+   //! 
+   //! <b>Complexity</b>: Constant.
+   //! 
+   //! <b>Throws</b>: Nothing.
+   static const_local_iterator local_iterator_to(const_reference value)
+   {  return bucket_type::iterator_to(value);  }
+
+   //! <b>Effects</b>: Returns the number of buckets passed in the constructor
+   //!   or the last rehash function.
+   //! 
+   //! <b>Complexity</b>: Constant.
+   //! 
+   //! <b>Throws</b>: Nothing.
    size_type bucket_count() const
    {  return this->priv_buckets_len();   }
 
+   //! <b>Requires</b>: n is in the range [0, this->bucket_count()).
+   //!
+   //! <b>Effects</b>: Returns the number of elements in the nth bucket.
+   //! 
+   //! <b>Complexity</b>: Constant.
+   //! 
+   //! <b>Throws</b>: Nothing.
    size_type bucket_size(size_type n) const
    {  return this->priv_buckets()[n].size();   }
 
+   //! <b>Effects</b>: Returns the index of the bucket in which elements
+   //!   with keys equivalent to k would be found, if any such element existed.
+   //! 
+   //! <b>Complexity</b>: Constant.
+   //! 
+   //! <b>Throws</b>: If the hash functor throws.
+   //!
+   //! <b>Note</b>: the return value is in the range [0, this->bucket_count()).
    size_type bucket(const key_type& k)  const
    {  return this->bucket(k, this->priv_hasher());   }
 
+   //! <b>Requires</b>: "hasher" must be a hash function that induces 
+   //!   the same hash values as the stored hasher. The difference is that
+   //!   "hasher" hashes the given key instead of the value_type.
+   //!
+   //! <b>Effects</b>: Returns the index of the bucket in which elements
+   //!   with keys equivalent to k would be found, if any such element existed.
+   //! 
+   //! <b>Complexity</b>: Constant.
+   //! 
+   //! <b>Throws</b>: If hasher throws.
+   //!
+   //! <b>Note</b>: the return value is in the range [0, this->bucket_count()).
    template<class KeyType, class KeyHasher>
    size_type bucket(const KeyType& k, const KeyHasher &hasher)  const
    {  return hasher(k) % this->priv_buckets_len();   }
 
+   //! <b>Effects</b>: Returns the bucket array pointer passed in the constructor
+   //!   or the last rehash function.
+   //! 
+   //! <b>Complexity</b>: Constant.
+   //! 
+   //! <b>Throws</b>: Nothing.
    bucket_ptr bucket_pointer() const
    {  return this->priv_buckets();   }
 
+   //! <b>Requires</b>: n is in the range [0, this->bucket_count()).
+   //!
+   //! <b>Effects</b>: Returns a local_iterator pointing to the beginning
+   //!   of the sequence stored in the bucket n.
+   //! 
+   //! <b>Complexity</b>: Constant.
+   //! 
+   //! <b>Throws</b>: Nothing.
+   //! 
+   //! <b>Note</b>:  [this->begin(n), this->end(n)) is a valid range
+   //!   containing all of the elements in the nth bucket. 
    local_iterator begin(size_type n)
    {  return this->priv_buckets()[n].begin();  }
 
+   //! <b>Requires</b>: n is in the range [0, this->bucket_count()).
+   //!
+   //! <b>Effects</b>: Returns a const_local_iterator pointing to the beginning
+   //!   of the sequence stored in the bucket n.
+   //! 
+   //! <b>Complexity</b>: Constant.
+   //! 
+   //! <b>Throws</b>: Nothing.
+   //! 
+   //! <b>Note</b>:  [this->begin(n), this->end(n)) is a valid range
+   //!   containing all of the elements in the nth bucket. 
    const_local_iterator begin(size_type n) const
    {  return this->cbegin(n);  }
 
+   //! <b>Requires</b>: n is in the range [0, this->bucket_count()).
+   //!
+   //! <b>Effects</b>: Returns a const_local_iterator pointing to the beginning
+   //!   of the sequence stored in the bucket n.
+   //! 
+   //! <b>Complexity</b>: Constant.
+   //! 
+   //! <b>Throws</b>: Nothing.
+   //! 
+   //! <b>Note</b>:  [this->begin(n), this->end(n)) is a valid range
+   //!   containing all of the elements in the nth bucket. 
    const_local_iterator cbegin(size_type n) const
    {  return const_cast<const bucket_type&>(this->priv_buckets()[n]).begin();  }
 
+   //! <b>Requires</b>: n is in the range [0, this->bucket_count()).
+   //!
+   //! <b>Effects</b>: Returns a local_iterator pointing to the end
+   //!   of the sequence stored in the bucket n.
+   //! 
+   //! <b>Complexity</b>: Constant.
+   //! 
+   //! <b>Throws</b>: Nothing.
+   //! 
+   //! <b>Note</b>:  [this->begin(n), this->end(n)) is a valid range
+   //!   containing all of the elements in the nth bucket. 
    local_iterator end(size_type n)
    {  return this->priv_buckets()[n].end();  }
 
+   //! <b>Requires</b>: n is in the range [0, this->bucket_count()).
+   //!
+   //! <b>Effects</b>: Returns a const_local_iterator pointing to the end
+   //!   of the sequence stored in the bucket n.
+   //! 
+   //! <b>Complexity</b>: Constant.
+   //! 
+   //! <b>Throws</b>: Nothing.
+   //! 
+   //! <b>Note</b>:  [this->begin(n), this->end(n)) is a valid range
+   //!   containing all of the elements in the nth bucket.
    const_local_iterator end(size_type n) const
    {  return this->cend(n);  }
 
+   //! <b>Requires</b>: n is in the range [0, this->bucket_count()).
+   //!
+   //! <b>Effects</b>: Returns a const_local_iterator pointing to the end
+   //!   of the sequence stored in the bucket n.
+   //! 
+   //! <b>Complexity</b>: Constant.
+   //! 
+   //! <b>Throws</b>: Nothing.
+   //! 
+   //! <b>Note</b>:  [this->begin(n), this->end(n)) is a valid range
+   //!   containing all of the elements in the nth bucket. 
    const_local_iterator cend(size_type n) const
    {  return const_cast<const bucket_type&>(this->priv_buckets()[n]).end();  }
 
+   //! <b>Requires</b>: new_buckets must be a pointer to a new bucket array
+   //!   or the same as the old bucket array. new_size is the length of the
+   //!   the array pointed by new_buckets. If new_buckets == this->bucket_pointer()
+   //!   n can be bigger or smaller than this->bucket_count().
+   //!
+   //! <b>Effects</b>: Updates the internal reference with the new bucket erases
+   //!   the values from the old bucket and inserts then in the new one. 
+   //! 
+   //! <b>Complexity</b>: Average case linear in this->size(), worst case quadratic.
+   //! 
+   //! <b>Throws</b>: If the hasher functor throws. Basic guarantee.
    void rehash(bucket_ptr new_buckets, size_type new_buckets_len)
    {
       bucket_ptr old_buckets     = this->priv_buckets();
       size_type  old_buckets_len = this->priv_buckets_len();
-
+      #ifndef BOOST_INTRUSIVE_DISABLE_EXCEPTION_HANDLING
-      try{
+      BOOST_TRY{
+      #endif
          size_type n = 0;
          const bool same_buffer = old_buckets == new_buckets;
          //If the new bucket length is a common factor
@@ -701,36 +1304,29 @@ class hashtable
 
          this->priv_buckets()      = new_buckets;
          this->priv_buckets_len()  = new_buckets_len;
+      #ifndef BOOST_INTRUSIVE_DISABLE_EXCEPTION_HANDLING
       }
-      catch(...){
+      BOOST_CATCH(...){
          for(size_type n = 0; n < new_buckets_len; ++n){
             new_buckets[n].clear();
             old_buckets[n].clear();
          }
          size_traits::set_size(size_type(0));
-         throw;
+         BOOST_RETHROW;
       }
+      BOOST_CATCH_END
+      #endif
    }
 
-   iterator iterator_to(reference value)
+   //! <b>Effects</b>: Returns the nearest new bucket count optimized for
-   {
+   //!   the container that is bigger than n. This suggestion can be used
-      return iterator( bucket_type::iterator_to(value)
+   //!   to create bucket arrays with a size that will usually improve
-                     , const_bucket_info_ptr(&this->priv_bucket_info()));
+   //!   container's performance. If such value does not exist, the 
-   }
+   //!   higher possible value is returned.
-
+   //! 
-   const_iterator iterator_to(const_reference value) const
+   //! <b>Complexity</b>: Amortized constant time.
-   {
+   //! 
-      return const_iterator( bucket_type::iterator_to(const_cast<reference>(value))
+   //! <b>Throws</b>: Nothing.
-                           , const_bucket_info_ptr(&this->priv_bucket_info()));
-   }
-
-   static local_iterator local_iterator_to(reference value)
-   {  return bucket_type::iterator_to(value);  }
-
-   static const_local_iterator local_iterator_to(const_reference value)
-   {  return bucket_type::iterator_to(value);  }
-
-   // no throw
    static size_type suggested_upper_bucket_count(size_type n)
    {
       const std::size_t *primes     = &detail::prime_list_holder<0>::prime_list[0];
@@ -742,7 +1338,15 @@ class hashtable
       return size_type(*bound);
    }
 
-   // no throw
+   //! <b>Effects</b>: Returns the nearest new bucket count optimized for
+   //!   the container that is smaller than n. This suggestion can be used
+   //!   to create bucket arrays with a size that will usually improve
+   //!   container's performance. If such value does not exist, the 
+   //!   lower possible value is returned.
+   //! 
+   //! <b>Complexity</b>: Amortized constant time.
+   //! 
+   //! <b>Throws</b>: Nothing.
    static size_type suggested_lower_bucket_count(size_type n)
    {
       const std::size_t *primes     = &detail::prime_list_holder<0>::prime_list[0];
@@ -783,11 +1387,11 @@ class hashtable
    template<class KeyType, class KeyHasher, class KeyValueEqual>
    local_iterator priv_find
       ( const KeyType &key,  KeyHasher hasher
-      , KeyValueEqual equal, size_type &bucket_number, size_type &hash) const
+      , KeyValueEqual equal, size_type &bucket_number, size_type &h) const
    {
       size_type b_len(this->priv_buckets_len());
-      hash = hasher(key);
+      h = hasher(key);
-      bucket_number = hash % b_len;
+      bucket_number = h % b_len;
 
       if(ConstantTimeSize && this->empty()){
          return invalid_local_it(this->priv_bucket_info());
@@ -815,11 +1419,11 @@ class hashtable
       , size_type &bucket_number_second
       , size_type &count) const
    {
-      size_type hash;
+      size_type h;
       count = 0;
       //Let's see if the element is present
       std::pair<local_iterator, local_iterator> to_return
-         ( priv_find(key, hasher, equal, bucket_number_first, hash)
+         ( priv_find(key, hasher, equal, bucket_number_first, h)
          , invalid_local_it(this->priv_bucket_info()));
       if(to_return.first == to_return.second){
          bucket_number_second = bucket_number_first;

include/boost/intrusive/list.hpp

@@ -22,6 +22,9 @@
 #include <boost/intrusive/detail/pointer_to_other.hpp>
 #include <boost/intrusive/linking_policy.hpp>
 #include <boost/static_assert.hpp>
+#ifndef BOOST_INTRUSIVE_DISABLE_EXCEPTION_HANDLING
+#include <boost/detail/no_exceptions_support.hpp>
+#endif
 #include <iterator>
 #include <algorithm>
 #include <functional>
@@ -46,10 +49,10 @@ template< class ValueTraits
         >
 class list
    :  private detail::size_holder<ConstantTimeSize, SizeType>
-   ,  private ValueTraits::node_traits::node
 {
    /// @cond
    private:
+   typename ValueTraits::node_traits::node root_;
    typedef list<ValueTraits, ConstantTimeSize, SizeType>   this_type; 
    typedef typename ValueTraits::node_traits                node_traits;
    typedef detail::size_holder<ConstantTimeSize, SizeType>  size_traits;
@@ -99,10 +102,10 @@ class list
    }
 
    node_ptr get_root_node()
-   {  return node_ptr(&static_cast<node&>(*this));  }
+   {  return node_ptr(&root_);  }
 
    const_node_ptr get_root_node() const
-   {  return const_node_ptr(&static_cast<const node&>(*this));  }
+   {  return const_node_ptr(&root_);  }
    /// @endcond
 
    public:
@@ -164,7 +167,7 @@ class list
    {
       node_ptr to_insert = ValueTraits::to_node_ptr(value);
       if(safemode_or_autounlink)
-         BOOST_INTRUSIVE_SAFE_MODE_CONTAINER_INSERTION_ASSERT(node_algorithms::unique(to_insert));
+         BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
       node_algorithms::link_before(this->get_root_node(), to_insert);
       size_traits::increment();
    }
@@ -183,7 +186,7 @@ class list
    {
       node_ptr to_insert = ValueTraits::to_node_ptr(value);
       if(safemode_or_autounlink)
-         BOOST_INTRUSIVE_SAFE_MODE_CONTAINER_INSERTION_ASSERT(node_algorithms::unique(to_insert));
+         BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
       node_algorithms::link_before(node_traits::get_next(this->get_root_node()), to_insert); 
       size_traits::increment();
    }
@@ -409,7 +412,10 @@ class list
    //! 
    //! <b>Complexity</b>: Constant.
    static list &container_from_end_iterator(iterator end_iterator)
-   {  return static_cast<list&>(*end_iterator.pointed_node());  }
+   {
+      return *detail::parent_from_member<list, node>
+         ( detail::get_pointer(end_iterator.pointed_node()), &list::root_);
+   }
 
    //! <b>Precondition</b>: end_iterator must be a valid end const_iterator
    //!   of list.
@@ -420,7 +426,10 @@ class list
    //! 
    //! <b>Complexity</b>: Constant.
    static const list &container_from_end_iterator(const_iterator end_iterator)
-   {  return static_cast<const list&>(*end_iterator.pointed_node());  }
+   {
+      return *detail::parent_from_member<list, node>
+         ( detail::get_pointer(end_iterator.pointed_node()), &list::root_);
+   }
 
    //! <b>Effects</b>: Returns the number of the elements contained in the list.
    //! 
@@ -672,16 +681,21 @@ class list
    void clone_from(const list &src, Cloner cloner, Disposer disposer)
    {
       this->clear_and_dispose(disposer);
-      try{
+      #ifndef BOOST_INTRUSIVE_DISABLE_EXCEPTION_HANDLING
+      BOOST_TRY{
+      #endif
          const_iterator b(src.begin()), e(src.end());
          for(; b != e; ++b){
             this->push_back(*cloner(*b));
          }
+      #ifndef BOOST_INTRUSIVE_DISABLE_EXCEPTION_HANDLING
       }
-      catch(...){
+      BOOST_CATCH(...){
          clear_and_dispose(disposer);
-         throw;
+         BOOST_RETHROW;
       }
+      BOOST_CATCH_END
+      #endif
    }
 
    //! <b>Requires</b>: value must be an lvalue and p must be a valid iterator of *this.
@@ -699,7 +713,7 @@ class list
    {
       node_ptr to_insert = ValueTraits::to_node_ptr(value);
       if(safemode_or_autounlink)
-         BOOST_INTRUSIVE_SAFE_MODE_CONTAINER_INSERTION_ASSERT(node_algorithms::unique(to_insert));
+         BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
       node_algorithms::link_before(p.pointed_node(), to_insert);
       size_traits::increment();
       return iterator(to_insert);

include/boost/intrusive/list_hook.hpp

@@ -53,7 +53,7 @@ class list_base_hook
 
    /// @cond
    private:
-   typedef circular_list_algorithms<node_traits>               node_algorithms;
+   typedef circular_list_algorithms<node_traits>      node_algorithms;
 
    public:
    typedef typename node_traits::node                 node;
@@ -174,7 +174,7 @@ class list_base_hook
    //! copy-constructible or assignable.
    template<class T>
    struct value_traits
-      : detail::derivation_value_traits<T, this_type, Tag>
+      : detail::derivation_hook_value_traits<T, this_type, Tag>
    {};
 
    //! <b>Effects</b>: Converts a pointer to a node into
@@ -351,7 +351,7 @@ class list_member_hook
    //! T doesn't need to be copy-constructible or assignable.
    template<class T, this_type T::* M>
    struct value_traits
-      : detail::member_value_traits<T, this_type, M>
+      : detail::member_hook_value_traits<T, this_type, M>
    {};
 
    //! <b>Effects</b>: Converts a pointer to a node into

include/boost/intrusive/member_value_traits.hpp

@@ -0,0 +1,66 @@
+/////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga  2006-2007
+//
+// 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_MEMBER_VALUE_TRAITS_HPP
+#define BOOST_INTRUSIVE_MEMBER_VALUE_TRAITS_HPP
+
+#include <boost/intrusive/linking_policy.hpp>
+#include <iterator>
+#include <boost/intrusive/detail/parent_from_member.hpp>
+
+namespace boost {
+namespace intrusive {
+
+//!This value traits template is used to create value traits
+//!from user defined node traits where value_traits::value_type will
+//!store a node_traits::node
+template< class T, class NodeTraits
+        , typename NodeTraits::node T::* PtrToMember
+        , linking_policy Policy>
+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;
+
+   enum { linking_policy = Policy };
+
+   static node_ptr to_node_ptr(reference value)
+   {  return node_ptr(&(value.*PtrToMember));   }
+
+   static const_node_ptr to_node_ptr(const_reference value)
+   {  return node_ptr(&(value.*PtrToMember));   }
+
+   static pointer to_value_ptr(node_ptr n)
+   {
+      return pointer(detail::parent_from_member<value_type, node>
+         (detail::get_pointer(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)); 
+   }
+};
+
+} //namespace intrusive 
+} //namespace boost 
+
+#endif //BOOST_INTRUSIVE_MEMBER_VALUE_TRAITS_HPP

include/boost/intrusive/rbtree.hpp

@@ -42,14 +42,14 @@ template < class ValueTraits
          >
 class rbtree
    :  private detail::size_holder<ConstantTimeSize, SizeType>
-   ,  private ValueTraits::node_traits::node
 {
    /// @cond
    private:
+   typename ValueTraits::node_traits::node root_;
    typedef rbtree<ValueTraits, Compare
                   ,ConstantTimeSize, SizeType>              this_type; 
    typedef typename ValueTraits::node_traits                node_traits;
-   typedef detail::size_holder<ConstantTimeSize, SizeType>    size_traits;
+   typedef detail::size_holder<ConstantTimeSize, SizeType>  size_traits;
 
    //noncopyable
    rbtree (const rbtree&);
@@ -352,7 +352,7 @@ class rbtree
       detail::key_node_ptr_compare<value_compare, ValueTraits> key_node_comp(priv_comp());
       node_ptr to_insert(ValueTraits::to_node_ptr(value));
       if(safemode_or_autounlink)
-         BOOST_INTRUSIVE_SAFE_MODE_CONTAINER_INSERTION_ASSERT(node_algorithms::unique(to_insert));
+         BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
       size_traits::increment();
       return iterator(node_algorithms::insert_equal_upper_bound
          (node_ptr(&priv_header()), to_insert, key_node_comp));
@@ -374,7 +374,7 @@ class rbtree
       detail::key_node_ptr_compare<value_compare, ValueTraits> key_node_comp(priv_comp());
       node_ptr to_insert(ValueTraits::to_node_ptr(value));
       if(safemode_or_autounlink)
-         BOOST_INTRUSIVE_SAFE_MODE_CONTAINER_INSERTION_ASSERT(node_algorithms::unique(to_insert));
+         BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
       size_traits::increment();
       return iterator(node_algorithms::insert_equal_lower_bound
          (node_ptr(&priv_header()), to_insert, key_node_comp));
@@ -399,7 +399,7 @@ class rbtree
       detail::key_node_ptr_compare<value_compare, ValueTraits> key_node_comp(priv_comp());
       node_ptr to_insert(ValueTraits::to_node_ptr(value));
       if(safemode_or_autounlink)
-         BOOST_INTRUSIVE_SAFE_MODE_CONTAINER_INSERTION_ASSERT(node_algorithms::unique(to_insert));
+         BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
       size_traits::increment();
       return iterator(node_algorithms::insert_equal
          (node_ptr(&priv_header()), hint.pointed_node(), to_insert, key_node_comp));
@@ -539,7 +539,7 @@ class rbtree
    {
       node_ptr to_insert(ValueTraits::to_node_ptr(value));
       if(safemode_or_autounlink)
-         BOOST_INTRUSIVE_SAFE_MODE_CONTAINER_INSERTION_ASSERT(node_algorithms::unique(to_insert));
+         BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
       size_traits::increment();
       node_algorithms::insert_unique_commit
                (node_ptr(&priv_header()), to_insert, commit_data);
@@ -560,7 +560,7 @@ class rbtree
       ++ret;
       node_ptr to_erase(i.pointed_node());
       if(safemode_or_autounlink)
-         BOOST_INTRUSIVE_SAFE_MODE_CONTAINER_INSERTION_ASSERT(!node_algorithms::unique(to_erase));
+         BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!node_algorithms::unique(to_erase));
       node_algorithms::erase(&priv_header(), to_erase);
       size_traits::decrement();
       if(safemode_or_autounlink)

include/boost/intrusive/rbtree_algorithms.hpp

@@ -43,7 +43,9 @@
 #include <boost/intrusive/detail/assert.hpp>
 #include <boost/intrusive/intrusive_fwd.hpp>
 #include <cstddef>
+#ifndef BOOST_INTRUSIVE_DISABLE_EXCEPTION_HANDLING
 #include <boost/detail/no_exceptions_support.hpp>
+#endif
 #include <boost/intrusive/detail/utilities.hpp>
 
 
@@ -1112,8 +1114,9 @@ class rbtree_algorithms
       // structural copy.  source_root and new_parent must be non-null.
       node_ptr top = cloner(source_root);
       NodeTraits::set_parent(top, new_parent);
-       
+      #ifndef BOOST_INTRUSIVE_DISABLE_EXCEPTION_HANDLING
       BOOST_TRY {
+      #endif
          if(NodeTraits::get_right(source_root)){
             NodeTraits::set_right
                (top, deep_clone_node(NodeTraits::get_right(source_root), top
@@ -1134,12 +1137,14 @@ class rbtree_algorithms
             new_parent = y;
             source_root = NodeTraits::get_left(source_root);
          }
+      #ifndef BOOST_INTRUSIVE_DISABLE_EXCEPTION_HANDLING
       }
       BOOST_CATCH(...){
          deep_dispose_node(top, disposer);
          BOOST_RETHROW;
       }
       BOOST_CATCH_END
+      #endif
       return top;
    }
 

include/boost/intrusive/set.hpp

@@ -1412,6 +1412,15 @@ class multiset
    void clear_and_dispose(Disposer disposer)
    {  return tree_.clear_and_dispose(disposer);  }
 
+   //! <b>Effects</b>: Returns the number of contained elements with the given key
+   //! 
+   //! <b>Complexity</b>: Logarithmic to the number of elements contained plus lineal
+   //!   to number of objects with the given key.
+   //! 
+   //! <b>Throws</b>: If the internal Compare ordering function throws.
+   size_type count(const_reference value) const
+   {  return tree_.count(value);  }
+
    //! <b>Effects</b>: Returns the number of contained elements with the same key
    //!   compared with the given comparison functor.
    //! 
@@ -1421,7 +1430,7 @@ class multiset
    //! <b>Throws</b>: If comp ordering function throws.
    template<class KeyType, class KeyValueCompare>
    size_type count(const KeyType& key, KeyValueCompare comp) const
-   {  return tree_.find(key, comp) != end();  }
+   {  return tree_.count(key, comp);  }
 
    //! <b>Effects</b>: Returns an iterator to the first element whose
    //!   key is not less than k or end() if that element does not exist.

include/boost/intrusive/set_hook.hpp

@@ -162,7 +162,7 @@ class set_base_hook
    //! copy-constructible or assignable.
    template<class T>
    struct value_traits
-      :  detail::derivation_value_traits<T, this_type, Tag>
+      :  detail::derivation_hook_value_traits<T, this_type, Tag>
    {};
 
    //! <b>Effects</b>: Converts a pointer to a node into
@@ -318,7 +318,7 @@ class set_member_hook
    //! T don't need to be copy-constructible or assignable.
    template<class T, this_type T::* P>
    struct value_traits
-      :  detail::member_value_traits<T, this_type, P>
+      :  detail::member_hook_value_traits<T, this_type, P>
    {};
 
    //! <b>Effects</b>: Converts a pointer to a node into

include/boost/intrusive/slist.hpp

@@ -16,6 +16,9 @@
 
 #include <boost/intrusive/detail/config_begin.hpp>
 #include <boost/static_assert.hpp>
+#ifndef BOOST_INTRUSIVE_DISABLE_EXCEPTION_HANDLING
+#include <boost/detail/no_exceptions_support.hpp>
+#endif
 #include <boost/intrusive/detail/assert.hpp>
 #include <boost/intrusive/intrusive_fwd.hpp>
 #include <boost/intrusive/slist_hook.hpp>
@@ -56,11 +59,12 @@ template < class ValueTraits
          >
 class slist
    :  private detail::size_holder<ConstantTimeSize, SizeType>
-   ,  private ValueTraits::node_traits::node
 {
    /// @cond
    private:
-   typedef slist<ValueTraits, ConstantTimeSize, SizeType>  this_type; 
+   typename ValueTraits::node_traits::node root_;
+
+   typedef slist<ValueTraits, ConstantTimeSize, SizeType>   this_type; 
    typedef typename ValueTraits::node_traits                node_traits;
    typedef detail::size_holder<ConstantTimeSize, SizeType>  size_traits;
 
@@ -102,10 +106,10 @@ class slist
    BOOST_STATIC_ASSERT(!(ConstantTimeSize && ((int)ValueTraits::linking_policy == (int)auto_unlink)));
 
    node_ptr get_root_node()
-   {  return node_ptr(&static_cast<node&>(*this));  }
+   {  return node_ptr(&root_);  }
 
    const_node_ptr get_root_node() const
-   {  return const_node_ptr(&static_cast<const node&>(*this));  }
+   {  return const_node_ptr(&root_);  }
 
    static node_ptr uncast(const_node_ptr ptr)
    {
@@ -213,7 +217,7 @@ class slist
    {
       node_ptr to_insert = ValueTraits::to_node_ptr(value);
       if(safemode_or_autounlink)
-         BOOST_INTRUSIVE_SAFE_MODE_CONTAINER_INSERTION_ASSERT(node_algorithms::unique(to_insert));
+         BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
       node_algorithms::link_after(this->get_root_node(), to_insert); 
       size_traits::increment();
    }
@@ -353,7 +357,10 @@ class slist
    //! 
    //! <b>Complexity</b>: Constant.
    static slist &container_from_end_iterator(iterator end_iterator)
-   {  return static_cast<slist&>(*end_iterator.pointed_node());  }
+   {
+      return *detail::parent_from_member<slist, node>
+         ( detail::get_pointer(end_iterator.pointed_node()), &slist::root_);
+   }
 
    //! <b>Precondition</b>: end_iterator must be a valid end const_iterator
    //!   of slist.
@@ -364,7 +371,10 @@ class slist
    //! 
    //! <b>Complexity</b>: Constant.
    static const slist &container_from_end_iterator(const_iterator end_iterator)
-   {  return static_cast<const slist&>(*end_iterator.pointed_node());  }
+   {
+      return *detail::parent_from_member<slist, node>
+         ( detail::get_pointer(end_iterator.pointed_node()), &slist::root_);
+   }
 
    //! <b>Effects</b>: Returns the number of the elements contained in the list.
    //! 
@@ -526,17 +536,22 @@ class slist
    void clone_from(const slist &src, Cloner cloner, Disposer disposer)
    {  
       this->clear_and_dispose(disposer);
-      try{
+      #ifndef BOOST_INTRUSIVE_DISABLE_EXCEPTION_HANDLING
+      BOOST_TRY{
+      #endif
          iterator prev = this->before_begin();
          const_iterator b(src.begin()), e(src.end());
          for(; b != e; ++b, ++prev){
             this->insert_after(prev, *cloner(*b));
          }
+      #ifndef BOOST_INTRUSIVE_DISABLE_EXCEPTION_HANDLING
       }
-      catch(...){
+      BOOST_CATCH(...){
-         clear_and_dispose(disposer);
+         this->clear_and_dispose(disposer);
-         throw;
+         BOOST_RETHROW;
       }
+      BOOST_CATCH_END
+      #endif
    }
 
    //! <b>Requires</b>: value must be an lvalue and prev_p must point to an element
@@ -556,7 +571,7 @@ class slist
    {
       node_ptr n = ValueTraits::to_node_ptr(value);
       if(safemode_or_autounlink)
-         BOOST_INTRUSIVE_SAFE_MODE_CONTAINER_INSERTION_ASSERT(node_algorithms::unique(n));
+         BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(n));
       node_algorithms::link_after(prev_p.pointed_node(), n);
       size_traits::increment();
       return iterator (n);

include/boost/intrusive/slist_hook.hpp

@@ -177,7 +177,7 @@ class slist_base_hook
    //! copy-constructible or assignable.
    template<class T>
    struct value_traits
-      : detail::derivation_value_traits<T, this_type, Tag>
+      : detail::derivation_hook_value_traits<T, this_type, Tag>
    {};
 
    //! <b>Effects</b>: Converts a pointer to a node into
@@ -358,7 +358,7 @@ class slist_member_hook
    //! T doesn't need to be copy-constructible or assignable.
    template<class T, this_type T::* M>
    struct value_traits
-      : detail::member_value_traits<T, this_type, M>
+      : detail::member_hook_value_traits<T, this_type, M>
    {};
 
    //! <b>Effects</b>: Converts a pointer to a node into

include/boost/intrusive/trivial_value_traits.hpp

@@ -0,0 +1,43 @@
+/////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga  2006-2007
+//
+// 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_TRIVIAL_VALUE_TRAITS_HPP
+#define BOOST_INTRUSIVE_TRIVIAL_VALUE_TRAITS_HPP
+
+#include <boost/intrusive/linking_policy.hpp>
+
+namespace boost {
+namespace intrusive {
+
+//!This value traits template is used to create value traits
+//!from user defined node traits where value_traits::value_type and
+//!node_traits::node should be equal
+template<class NodeTraits, linking_policy LinkingPolicy = safe_link>
+struct trivial_value_traits
+{
+   typedef NodeTraits                                          node_traits;
+   typedef typename node_traits::node_ptr                      node_ptr;
+   typedef typename node_traits::const_node_ptr                const_node_ptr;
+   typedef typename node_traits::node                          value_type;
+   typedef node_ptr                                            pointer;
+   typedef const_node_ptr                                      const_pointer;
+   enum {   linking_policy =  LinkingPolicy  };
+   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); }
+};
+
+} //namespace intrusive 
+} //namespace boost 
+
+#endif //BOOST_INTRUSIVE_TRIVIAL_VALUE_TRAITS_HPP

include/boost/intrusive/unordered_set.hpp

@@ -302,6 +302,22 @@ class unordered_set
    std::pair<iterator, bool> insert(reference value)
    {  return table_.insert_unique(value);  }
 
+   //! <b>Requires</b>: Dereferencing iterator must yield an lvalue 
+   //!   of type value_type.
+   //! 
+   //! <b>Effects</b>: Equivalent to this->insert(t) for each element in [b, e).
+   //! 
+   //! <b>Complexity</b>: Average case O(N), where N is std::distance(b, e).
+   //!   Worst case O(N*this->size()).
+   //! 
+   //! <b>Throws</b>: If the internal hasher or the equality functor throws. Basic guarantee.
+   //! 
+   //! <b>Note</b>: Does not affect the validity of iterators and references.
+   //!   No copy-constructors are called.
+   template<class Iterator>
+   void insert(Iterator b, Iterator e)
+   {  table_.insert_unique(b, e);  }
+
    //! <b>Requires</b>: "hasher" must be a hash function that induces 
    //!   the same hash values as the stored hasher. The difference is that
    //!   "hasher" hashes the given key instead of the value_type.
@@ -364,22 +380,6 @@ class unordered_set
    iterator insert_commit(reference value, const insert_commit_data &commit_data)
    {  return table_.insert_unique_commit(value, commit_data); }
 
-   //! <b>Requires</b>: Dereferencing iterator must yield an lvalue 
-   //!   of type value_type.
-   //! 
-   //! <b>Effects</b>: Equivalent to this->insert(t) for each element in [b, e).
-   //! 
-   //! <b>Complexity</b>: Average case O(N), where N is std::distance(b, e).
-   //!   Worst case O(N*this->size()).
-   //! 
-   //! <b>Throws</b>: If the internal hasher or the equality functor throws. Basic guarantee.
-   //! 
-   //! <b>Note</b>: Does not affect the validity of iterators and references.
-   //!   No copy-constructors are called.
-   template<class Iterator>
-   void insert(Iterator b, Iterator e)
-   {  table_.insert_unique(b, e);  }
-
    //! <b>Effects</b>: Erases the element pointed to by i. 
    //! 
    //! <b>Complexity</b>: Average case O(1), worst case O(this->size()).
@@ -696,7 +696,7 @@ class unordered_set
    //! <b>Requires</b>: value must be an lvalue and shall be in a unordered_set of
    //!   appropriate type. Otherwise the behavior is undefined.
    //! 
-   //! <b>Effects</b>: Returns: a valid iterator i belonging to the unordered_set
+   //! <b>Effects</b>: Returns: a valid iterator belonging to the unordered_set
    //!   that points to the value
    //! 
    //! <b>Complexity</b>: Constant.
@@ -708,7 +708,7 @@ class unordered_set
    //! <b>Requires</b>: value must be an lvalue and shall be in a unordered_set of
    //!   appropriate type. Otherwise the behavior is undefined.
    //! 
-   //! <b>Effects</b>: Returns: a valid const_iterator i belonging to the
+   //! <b>Effects</b>: Returns: a valid const_iterator belonging to the
    //!   unordered_set that points to the value
    //! 
    //! <b>Complexity</b>: Constant.
@@ -720,7 +720,7 @@ class unordered_set
    //! <b>Requires</b>: value must be an lvalue and shall be in a unordered_set of
    //!   appropriate type. Otherwise the behavior is undefined.
    //! 
-   //! <b>Effects</b>: Returns: a valid local_iterator i belonging to the unordered_set
+   //! <b>Effects</b>: Returns: a valid local_iterator belonging to the unordered_set
    //!   that points to the value
    //! 
    //! <b>Complexity</b>: Constant.
@@ -732,7 +732,7 @@ class unordered_set
    //! <b>Requires</b>: value must be an lvalue and shall be in a unordered_set of
    //!   appropriate type. Otherwise the behavior is undefined.
    //! 
-   //! <b>Effects</b>: Returns: a valid const_local_iterator i belonging to
+   //! <b>Effects</b>: Returns: a valid const_local_iterator belonging to
    //!   the unordered_set that points to the value
    //! 
    //! <b>Complexity</b>: Constant.
@@ -768,7 +768,7 @@ class unordered_set
    //! <b>Throws</b>: If the hash functor throws.
    //!
    //! <b>Note</b>: the return value is in the range [0, this->bucket_count()).
-   size_type bucket(const key_type& k) const
+   size_type bucket(const value_type& k) const
    {  return table_.bucket(k);   }
 
    //! <b>Requires</b>: "hasher" must be a hash function that induces 
@@ -1530,7 +1530,7 @@ class unordered_multiset
    //! <b>Requires</b>: value must be an lvalue and shall be in a unordered_multiset of
    //!   appropriate type. Otherwise the behavior is undefined.
    //! 
-   //! <b>Effects</b>: Returns: a valid iterator i belonging to the unordered_multiset
+   //! <b>Effects</b>: Returns: a valid iterator belonging to the unordered_multiset
    //!   that points to the value
    //! 
    //! <b>Complexity</b>: Constant.
@@ -1542,7 +1542,7 @@ class unordered_multiset
    //! <b>Requires</b>: value must be an lvalue and shall be in a unordered_multiset of
    //!   appropriate type. Otherwise the behavior is undefined.
    //! 
-   //! <b>Effects</b>: Returns: a valid const_iterator i belonging to the
+   //! <b>Effects</b>: Returns: a valid const_iterator belonging to the
    //!   unordered_multiset that points to the value
    //! 
    //! <b>Complexity</b>: Constant.
@@ -1554,7 +1554,7 @@ class unordered_multiset
    //! <b>Requires</b>: value must be an lvalue and shall be in a unordered_multiset of
    //!   appropriate type. Otherwise the behavior is undefined.
    //! 
-   //! <b>Effects</b>: Returns: a valid local_iterator i belonging to the unordered_multiset
+   //! <b>Effects</b>: Returns: a valid local_iterator belonging to the unordered_multiset
    //!   that points to the value
    //! 
    //! <b>Complexity</b>: Constant.
@@ -1566,7 +1566,7 @@ class unordered_multiset
    //! <b>Requires</b>: value must be an lvalue and shall be in a unordered_multiset of
    //!   appropriate type. Otherwise the behavior is undefined.
    //! 
-   //! <b>Effects</b>: Returns: a valid const_local_iterator i belonging to
+   //! <b>Effects</b>: Returns: a valid const_local_iterator belonging to
    //!   the unordered_multiset that points to the value
    //! 
    //! <b>Complexity</b>: Constant.
@@ -1602,7 +1602,7 @@ class unordered_multiset
    //! <b>Throws</b>: If the hash functor throws.
    //!
    //! <b>Note</b>: the return value is in the range [0, this->bucket_count()).
-   size_type bucket(const key_type& k) const
+   size_type bucket(const value_type& k) const
    {  return table_.bucket(k);   }
 
    //! <b>Requires</b>: "hasher" must be a hash function that induces 

include/boost/intrusive/unordered_set_hook.hpp

@@ -121,7 +121,7 @@ class unordered_set_base_hook
    //! copy-constructible or assignable.
    template<class T>
    struct value_traits
-      : detail::derivation_value_traits<T, this_type, Tag>
+      : detail::derivation_hook_value_traits<T, this_type, Tag>
    {};
 
    //! <b>Effects</b>: Converts a pointer to a node into
@@ -241,7 +241,7 @@ class unordered_set_member_hook
    //! T doesn't need to be copy-constructible or assignable.
    template<class T, this_type T::* M>
    struct value_traits
-      : detail::member_value_traits<T, this_type, M>
+      : detail::member_hook_value_traits<T, this_type, M>
    {};
 
    //! <b>Effects</b>: Removes the node if it's inserted in a container.