- Modified relational operators to be friend inline definitions. This allows compilation checking when instantiating classes, avoids predeclarations and results in less verbose code.

- First to make associative containers' tree implementation configurable.

include/boost/container/detail/node_alloc_holder.hpp

@@ -31,6 +31,7 @@
 #include <boost/container/detail/allocator_version_traits.hpp>
 #include <boost/container/detail/mpl.hpp>
 #include <boost/container/detail/destroyers.hpp>
+#include <boost/container/detail/memory_util.hpp>
 #include <boost/container/detail/allocator_version_traits.hpp>
 #include <boost/detail/no_exceptions_support.hpp>
 
@@ -50,31 +51,41 @@ template<class ValueCompare, class Node>
 struct node_compare
    :  private ValueCompare
 {
-   typedef typename ValueCompare::key_type     key_type;
-   typedef typename ValueCompare::value_type   value_type;
-   typedef typename ValueCompare::key_of_value key_of_value;
+   typedef ValueCompare                                 wrapped_value_compare;
+   typedef typename wrapped_value_compare::key_type     key_type;
+   typedef typename wrapped_value_compare::value_type   value_type;
+   typedef typename wrapped_value_compare::key_of_value key_of_value;
 
-   explicit node_compare(const ValueCompare &pred)
-      :  ValueCompare(pred)
+   explicit node_compare(const wrapped_value_compare &pred)
+      :  wrapped_value_compare(pred)
    {}
 
    node_compare()
-      :  ValueCompare()
+      :  wrapped_value_compare()
    {}
 
-   ValueCompare &value_comp()
-   {  return static_cast<ValueCompare &>(*this);  }
+   wrapped_value_compare &value_comp()
+   {  return static_cast<wrapped_value_compare &>(*this);  }
 
-   ValueCompare &value_comp() const
-   {  return static_cast<const ValueCompare &>(*this);  }
+   wrapped_value_compare &value_comp() const
+   {  return static_cast<const wrapped_value_compare &>(*this);  }
 
    bool operator()(const Node &a, const Node &b) const
-   {  return ValueCompare::operator()(a.get_data(), b.get_data());  }
+   {  return wrapped_value_compare::operator()(a.get_data(), b.get_data());  }
 };
 
-template<class A, class ICont, class ValPred = container_detail::nat>
+template<class A, class ICont>
 struct node_alloc_holder
 {
+   //If the intrusive container is an associative container, obtain the predicate, which will
+   //be of type node_compare<>. If not an associative container value_compare will be a "nat" type.
+   typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::container_detail::, ICont,
+      value_compare, container_detail::nat)                       intrusive_value_compare;
+   //In that case obtain the value predicate from the node predicate via wrapped_value_compare
+   //if intrusive_value_compare is node_compare<>, nat otherwise
+   typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::container_detail::, ICont,
+      wrapped_value_compare, container_detail::nat)               value_compare;
+
    typedef allocator_traits<A>                                    allocator_traits_type;
    typedef typename allocator_traits_type::value_type             value_type;
    typedef typename ICont::value_type                             Node;
@@ -121,20 +132,20 @@ struct node_alloc_holder
    {  this->icont().swap(x.icont());  }
 
    //Constructors for associative containers
-   explicit node_alloc_holder(const ValAlloc &a, const ValPred &c)
+   explicit node_alloc_holder(const ValAlloc &a, const value_compare &c)
       : members_(a, c)
    {}
 
-   explicit node_alloc_holder(const node_alloc_holder &x, const ValPred &c)
+   explicit node_alloc_holder(const node_alloc_holder &x, const value_compare &c)
       : members_(NodeAllocTraits::select_on_container_copy_construction(x.node_alloc()), c)
    {}
 
-   explicit node_alloc_holder(const ValPred &c)
+   explicit node_alloc_holder(const value_compare &c)
       : members_(c)
    {}
 
    //helpers for move assignments
-   explicit node_alloc_holder(BOOST_RV_REF(node_alloc_holder) x, const ValPred &c)
+   explicit node_alloc_holder(BOOST_RV_REF(node_alloc_holder) x, const value_compare &c)
       : members_(boost::move(x.node_alloc()), c)
    {  this->icont().swap(x.icont());  }
 
@@ -346,12 +357,12 @@ struct node_alloc_holder
       {}
 
       template<class ConvertibleToAlloc>
-      members_holder(BOOST_FWD_REF(ConvertibleToAlloc) c2alloc, const ValPred &c)
+      members_holder(BOOST_FWD_REF(ConvertibleToAlloc) c2alloc, const value_compare &c)
          :  NodeAlloc(boost::forward<ConvertibleToAlloc>(c2alloc))
          , m_icont(typename ICont::value_compare(c))
       {}
 
-      explicit members_holder(const ValPred &c)
+      explicit members_holder(const value_compare &c)
          : NodeAlloc()
          , m_icont(typename ICont::value_compare(c))
       {}