passenger 5.1.4 → 5.1.5

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/iterator.hpp

@@ -23,6 +23,7 @@
 
 #include <cstddef>
 #include <boost/intrusive/detail/std_fwd.hpp>
+#include <boost/intrusive/detail/workaround.hpp>
 #include <boost/move/detail/iterator_traits.hpp>
 #include <boost/move/detail/meta_utils_core.hpp>
 
@@ -34,14 +35,14 @@ using boost::movelib::iterator_traits;
 ////////////////////
 //    iterator
 ////////////////////
-template<class Category, class T, class Distance, class Pointer = T*, class Reference = T&>
+template<class Category, class T, class Difference, class Pointer, class Reference>
 struct iterator
 {
-   typedef Category  iterator_category;
-   typedef T         value_type;
-   typedef Distance  difference_type;
-   typedef Pointer   pointer;
-   typedef Reference reference;
+   typedef Category     iterator_category;
+   typedef T            value_type;
+   typedef Difference   difference_type;
+   typedef Pointer      pointer;
+   typedef Reference    reference;
 };
 
 ////////////////////////////////////////
@@ -83,7 +84,7 @@ struct iterator_disable_if_tag_difference_type
 ////////////////////
 //    advance
 ////////////////////
-template<class InputIt, class Distance> inline
+template<class InputIt, class Distance>
 typename iterator_enable_if_tag<InputIt, std::input_iterator_tag>::type
    iterator_advance(InputIt& it, Distance n)
 {
@@ -91,7 +92,7 @@ typename iterator_enable_if_tag<InputIt, std::input_iterator_tag>::type
 	   ++it;
 }
 
-template<class InputIt, class Distance> inline
+template<class InputIt, class Distance>
 typename iterator_enable_if_tag<InputIt, std::forward_iterator_tag>::type
    iterator_advance(InputIt& it, Distance n)
 {
@@ -99,7 +100,7 @@ typename iterator_enable_if_tag<InputIt, std::forward_iterator_tag>::type
 	   ++it;
 }
 
-template<class InputIt, class Distance> inline
+template<class InputIt, class Distance>
 typename iterator_enable_if_tag<InputIt, std::bidirectional_iterator_tag>::type
    iterator_advance(InputIt& it, Distance n)
 {
@@ -109,8 +110,8 @@ typename iterator_enable_if_tag<InputIt, std::bidirectional_iterator_tag>::type
 	   --it;
 }
 
-template<class InputIt, class Distance> inline
-typename iterator_enable_if_tag<InputIt, std::random_access_iterator_tag>::type
+template<class InputIt, class Distance>
+BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::random_access_iterator_tag>::type
    iterator_advance(InputIt& it, Distance n)
 {
    it += n;
@@ -132,8 +133,8 @@ typename iterator_disable_if_tag_difference_type
    return off;
 }
 
-template<class InputIt> inline
-typename iterator_enable_if_tag_difference_type
+template<class InputIt>
+BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag_difference_type
    <InputIt, std::random_access_iterator_tag>::type
       iterator_distance(InputIt first, InputIt last)
 {
@@ -142,11 +143,11 @@ typename iterator_enable_if_tag_difference_type
 }
 
 template<class I>
-typename iterator_traits<I>::pointer iterator_arrow_result(const I &i)
+BOOST_INTRUSIVE_FORCEINLINE typename iterator_traits<I>::pointer iterator_arrow_result(const I &i)
 {  return i.operator->();  }
 
 template<class T>
-T * iterator_arrow_result(T *p)
+BOOST_INTRUSIVE_FORCEINLINE T * iterator_arrow_result(T *p)
 {  return p;   }
 
 } //namespace intrusive

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/key_nodeptr_comp.hpp

@@ -23,6 +23,8 @@
 
 #include <boost/intrusive/detail/mpl.hpp>
 #include <boost/intrusive/detail/ebo_functor_holder.hpp>
+#include <boost/intrusive/detail/tree_value_compare.hpp>
+
 
 namespace boost {
 namespace intrusive {
@@ -30,64 +32,88 @@ namespace detail {
 
 template < class KeyTypeKeyCompare
          , class ValueTraits
-         , class KeyOfValue = void
+         , class KeyOfValue
          >
-struct key_nodeptr_comp
-   //Use public inheritance to avoid MSVC bugs with closures
-   :  public ebo_functor_holder<KeyTypeKeyCompare>
+struct key_nodeptr_comp_types
 {
-   typedef ValueTraits                             value_traits;
-   typedef typename value_traits::value_type       value_type;
-   typedef typename value_traits::node_ptr         node_ptr;
-   typedef typename value_traits::const_node_ptr   const_node_ptr;
-   typedef ebo_functor_holder<KeyTypeKeyCompare>   base_t;
+   typedef ValueTraits                                   value_traits;
+   typedef typename value_traits::value_type             value_type;
+   typedef typename value_traits::node_ptr               node_ptr;
+   typedef typename value_traits::const_node_ptr         const_node_ptr;
    typedef typename detail::if_c
             < detail::is_same<KeyOfValue, void>::value
             , detail::identity<value_type>
             , KeyOfValue
-            >::type                                key_of_value;
-   typedef typename key_of_value::type         key_type;
-
-   key_nodeptr_comp(KeyTypeKeyCompare kcomp, const ValueTraits *traits)
-      :  base_t(kcomp), traits_(traits)
-   {}
+            >::type                                      key_of_value;
+   typedef tree_value_compare
+      <typename ValueTraits::pointer, KeyTypeKeyCompare, key_of_value>      base_t;
+};
 
-   template<class T>
-   struct is_node_ptr
+//This function object transforms a key comparison type to
+//a function that can compare nodes or nodes with nodes or keys.
+template < class KeyTypeKeyCompare
+         , class ValueTraits
+         , class KeyOfValue = void
+         >
+struct key_nodeptr_comp
+   //Use public inheritance to avoid MSVC bugs with closures
+   :  public key_nodeptr_comp_types<KeyTypeKeyCompare, ValueTraits, KeyOfValue>::base_t
+{
+private:
+   struct sfinae_type;
+
+public:
+   typedef key_nodeptr_comp_types<KeyTypeKeyCompare, ValueTraits, KeyOfValue> types_t;
+   typedef typename types_t::value_traits          value_traits;
+   typedef typename types_t::value_type            value_type;
+   typedef typename types_t::node_ptr              node_ptr;
+   typedef typename types_t::const_node_ptr        const_node_ptr;
+   typedef typename types_t::base_t                base_t;
+   typedef typename types_t::key_of_value          key_of_value;
+
+   template <class P1>
+   struct is_same_or_nodeptr_convertible
    {
-      static const bool value = is_same<T, const_node_ptr>::value || is_same<T, node_ptr>::value;
+      static const bool same_type = is_same<P1,const_node_ptr>::value || is_same<P1,node_ptr>::value;
+      static const bool value = same_type || is_convertible<P1, const_node_ptr>::value;
    };
 
-   //key_forward
-   template<class T>
-   typename enable_if<is_node_ptr<T>, const key_type &>::type key_forward(const T &node) const
-   {  return key_of_value()(*traits_->to_value_ptr(node));  }
+   base_t base() const
+   {  return static_cast<const base_t&>(*this); }
 
-   template<class T>
-   #if defined(BOOST_MOVE_HELPERS_RETURN_SFINAE_BROKEN)
-   const T &key_forward (const T &key, typename disable_if<is_node_ptr<T> >::type* =0) const
-   #else
-   typename disable_if<is_node_ptr<T>, const T &>::type key_forward(const T &key) const
-   #endif
-   {  return key;  }
-
-   //operator() 1 arg
-   template<class KeyType>
-   bool operator()(const KeyType &key1) const
-   {  return base_t::get()(this->key_forward(key1));  }
+   BOOST_INTRUSIVE_FORCEINLINE key_nodeptr_comp(KeyTypeKeyCompare kcomp, const ValueTraits *traits)
+      :  base_t(kcomp), traits_(traits)
+   {}
 
-   template<class KeyType>
-   bool operator()(const KeyType &key1)
-   {  return base_t::get()(this->key_forward(key1));  }
+   //pred(pnode)
+   template<class T1>
+   BOOST_INTRUSIVE_FORCEINLINE bool operator()(const T1 &t1, typename enable_if_c< is_same_or_nodeptr_convertible<T1>::value, sfinae_type* >::type = 0) const
+   {  return base().get()(key_of_value()(*traits_->to_value_ptr(t1)));  }
 
    //operator() 2 arg
-   template<class KeyType, class KeyType2>
-   bool operator()(const KeyType &key1, const KeyType2 &key2) const
-   {  return base_t::get()(this->key_forward(key1), this->key_forward(key2));  }
-
-   template<class KeyType, class KeyType2>
-   bool operator()(const KeyType &key1, const KeyType2 &key2)
-   {  return base_t::get()(this->key_forward(key1), this->key_forward(key2));  }
+   //pred(pnode, pnode)
+   template<class T1, class T2>
+   BOOST_INTRUSIVE_FORCEINLINE bool operator()
+      (const T1 &t1, const T2 &t2, typename enable_if_c< is_same_or_nodeptr_convertible<T1>::value && is_same_or_nodeptr_convertible<T2>::value, sfinae_type* >::type = 0) const
+   {  return base()(*traits_->to_value_ptr(t1), *traits_->to_value_ptr(t2));  }
+
+   //pred(pnode, key)
+   template<class T1, class T2>
+   BOOST_INTRUSIVE_FORCEINLINE bool operator()
+      (const T1 &t1, const T2 &t2, typename enable_if_c< is_same_or_nodeptr_convertible<T1>::value && !is_same_or_nodeptr_convertible<T2>::value, sfinae_type* >::type = 0) const
+   {  return base()(*traits_->to_value_ptr(t1), t2);  }
+
+   //pred(key, pnode)
+   template<class T1, class T2>
+   BOOST_INTRUSIVE_FORCEINLINE bool operator()
+      (const T1 &t1, const T2 &t2, typename enable_if_c< !is_same_or_nodeptr_convertible<T1>::value && is_same_or_nodeptr_convertible<T2>::value, sfinae_type* >::type = 0) const
+   {  return base()(t1, *traits_->to_value_ptr(t2));  }
+
+   //pred(key, key)
+   template<class T1, class T2>
+   BOOST_INTRUSIVE_FORCEINLINE bool operator()
+      (const T1 &t1, const T2 &t2, typename enable_if_c< !is_same_or_nodeptr_convertible<T1>::value && !is_same_or_nodeptr_convertible<T2>::value, sfinae_type* >::type = 0) const
+   {  return base()(t1, t2);  }
 
    const ValueTraits *const traits_;
 };

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/list_iterator.hpp

@@ -22,6 +22,7 @@
 #  pragma once
 #endif
 
+#include <boost/intrusive/detail/workaround.hpp>
 #include <boost/intrusive/detail/std_fwd.hpp>
 #include <boost/intrusive/detail/iiterator.hpp>
 #include <boost/intrusive/detail/mpl.hpp>
@@ -48,80 +49,80 @@ class list_iterator
    typedef typename types_t::const_value_traits_ptr         const_value_traits_ptr;
 
    public:
-   typedef typename types_t::iterator_traits::difference_type    difference_type;
-   typedef typename types_t::iterator_traits::value_type         value_type;
-   typedef typename types_t::iterator_traits::pointer            pointer;
-   typedef typename types_t::iterator_traits::reference          reference;
-   typedef typename types_t::iterator_traits::iterator_category  iterator_category;
+   typedef typename types_t::iterator_type::difference_type    difference_type;
+   typedef typename types_t::iterator_type::value_type         value_type;
+   typedef typename types_t::iterator_type::pointer            pointer;
+   typedef typename types_t::iterator_type::reference          reference;
+   typedef typename types_t::iterator_type::iterator_category  iterator_category;
 
-   list_iterator()
+   BOOST_INTRUSIVE_FORCEINLINE list_iterator()
    {}
 
-   explicit list_iterator(const node_ptr & nodeptr, const const_value_traits_ptr &traits_ptr)
+   BOOST_INTRUSIVE_FORCEINLINE explicit list_iterator(const node_ptr & nodeptr, const const_value_traits_ptr &traits_ptr)
       : members_(nodeptr, traits_ptr)
    {}
 
-   list_iterator(list_iterator<ValueTraits, false> const& other)
+   BOOST_INTRUSIVE_FORCEINLINE list_iterator(list_iterator<ValueTraits, false> const& other)
       :  members_(other.pointed_node(), other.get_value_traits())
    {}
 
-   const node_ptr &pointed_node() const
+   BOOST_INTRUSIVE_FORCEINLINE const node_ptr &pointed_node() const
    { return members_.nodeptr_; }
 
-   list_iterator &operator=(const node_ptr &node)
+   BOOST_INTRUSIVE_FORCEINLINE list_iterator &operator=(const node_ptr &node)
    {  members_.nodeptr_ = node;  return static_cast<list_iterator&>(*this);  }
 
-   const_value_traits_ptr get_value_traits() const
+   BOOST_INTRUSIVE_FORCEINLINE const_value_traits_ptr get_value_traits() const
    {  return members_.get_ptr(); }
 
    public:
-   list_iterator& operator++()
+   BOOST_INTRUSIVE_FORCEINLINE list_iterator& operator++()
    {
       node_ptr p = node_traits::get_next(members_.nodeptr_);
       members_.nodeptr_ = p;
       return static_cast<list_iterator&> (*this);
    }
 
-   list_iterator operator++(int)
+   BOOST_INTRUSIVE_FORCEINLINE list_iterator operator++(int)
    {
       list_iterator result (*this);
       members_.nodeptr_ = node_traits::get_next(members_.nodeptr_);
       return result;
    }
 
-   list_iterator& operator--()
+   BOOST_INTRUSIVE_FORCEINLINE list_iterator& operator--()
    {
       members_.nodeptr_ = node_traits::get_previous(members_.nodeptr_);
       return static_cast<list_iterator&> (*this);
    }
 
-   list_iterator operator--(int)
+   BOOST_INTRUSIVE_FORCEINLINE list_iterator operator--(int)
    {
       list_iterator result (*this);
       members_.nodeptr_ = node_traits::get_previous(members_.nodeptr_);
       return result;
    }
 
-   friend bool operator== (const list_iterator& l, const list_iterator& r)
+   BOOST_INTRUSIVE_FORCEINLINE friend bool operator== (const list_iterator& l, const list_iterator& r)
    {  return l.pointed_node() == r.pointed_node();   }
 
-   friend bool operator!= (const list_iterator& l, const list_iterator& r)
+   BOOST_INTRUSIVE_FORCEINLINE friend bool operator!= (const list_iterator& l, const list_iterator& r)
    {  return !(l == r); }
 
-   reference operator*() const
+   BOOST_INTRUSIVE_FORCEINLINE reference operator*() const
    {  return *operator->();   }
 
-   pointer operator->() const
+   BOOST_INTRUSIVE_FORCEINLINE pointer operator->() const
    { return this->operator_arrow(detail::bool_<stateful_value_traits>()); }
 
    list_iterator<ValueTraits, false> unconst() const
    {  return list_iterator<ValueTraits, false>(this->pointed_node(), this->get_value_traits());   }
 
    private:
-   pointer operator_arrow(detail::false_) const
+   BOOST_INTRUSIVE_FORCEINLINE pointer operator_arrow(detail::false_) const
    { return ValueTraits::to_value_ptr(members_.nodeptr_); }
 
-   pointer operator_arrow(detail::true_) const
+   BOOST_INTRUSIVE_FORCEINLINE pointer operator_arrow(detail::true_) const
    { return this->get_value_traits()->to_value_ptr(members_.nodeptr_); }
 
    iiterator_members<node_ptr, const_value_traits_ptr, stateful_value_traits> members_;

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/list_node.hpp

@@ -22,6 +22,7 @@
 #  pragma once
 #endif
 
+#include <boost/intrusive/detail/workaround.hpp>
 #include <boost/intrusive/pointer_rebind.hpp>
 
 namespace boost {
@@ -46,22 +47,22 @@ struct list_node_traits
    typedef typename node::node_ptr     node_ptr;
    typedef typename pointer_rebind<VoidPointer, const node>::type   const_node_ptr;
 
-   static node_ptr get_previous(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_previous(const const_node_ptr & n)
    {  return n->prev_;  }
 
-   static node_ptr get_previous(const node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_previous(const node_ptr & n)
    {  return n->prev_;  }
 
-   static void set_previous(const node_ptr & n, const node_ptr & prev)
+   BOOST_INTRUSIVE_FORCEINLINE static void set_previous(const node_ptr & n, const node_ptr & prev)
    {  n->prev_ = prev;  }
 
-   static node_ptr get_next(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_next(const const_node_ptr & n)
    {  return n->next_;  }
 
-   static node_ptr get_next(const node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_next(const node_ptr & n)
    {  return n->next_;  }
 
-   static void set_next(const node_ptr & n, const node_ptr & next)
+   BOOST_INTRUSIVE_FORCEINLINE static void set_next(const node_ptr & n, const node_ptr & next)
    {  n->next_ = next;  }
 };
 

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/parent_from_member.hpp

@@ -21,9 +21,10 @@
 #endif
 
 #include <boost/intrusive/detail/config_begin.hpp>
+#include <boost/intrusive/detail/workaround.hpp>
 #include <cstddef>
 
-#if defined(BOOST_MSVC) || ((defined(_WIN32) || defined(__WIN32__) || defined(WIN32)) && defined(BOOST_INTEL))
+#if defined(_MSC_VER)
    #define BOOST_INTRUSIVE_MSVC_ABI_PTR_TO_MEMBER
    #include <boost/static_assert.hpp>
 #endif
@@ -33,7 +34,7 @@ namespace intrusive {
 namespace detail {
 
 template<class Parent, class Member>
-inline std::ptrdiff_t offset_from_pointer_to_member(const Member Parent::* ptr_to_member)
+BOOST_INTRUSIVE_FORCEINLINE std::ptrdiff_t offset_from_pointer_to_member(const Member Parent::* ptr_to_member)
 {
    //The implementation of a pointer to member is compiler dependent.
    #if defined(BOOST_INTRUSIVE_MSVC_ABI_PTR_TO_MEMBER)
@@ -88,7 +89,7 @@ inline std::ptrdiff_t offset_from_pointer_to_member(const Member Parent::* ptr_t
 }
 
 template<class Parent, class Member>
-inline Parent *parent_from_member(Member *member, const Member Parent::* ptr_to_member)
+BOOST_INTRUSIVE_FORCEINLINE Parent *parent_from_member(Member *member, const Member Parent::* ptr_to_member)
 {
    return static_cast<Parent*>
       (
@@ -100,7 +101,7 @@ inline Parent *parent_from_member(Member *member, const Member Parent::* ptr_to_
 }
 
 template<class Parent, class Member>
-inline const Parent *parent_from_member(const Member *member, const Member Parent::* ptr_to_member)
+BOOST_INTRUSIVE_FORCEINLINE const Parent *parent_from_member(const Member *member, const Member Parent::* ptr_to_member)
 {
    return static_cast<const Parent*>
       (

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/rbtree_node.hpp

@@ -23,6 +23,7 @@
 #endif
 
 #include <boost/intrusive/detail/config_begin.hpp>
+#include <boost/intrusive/detail/workaround.hpp>
 #include <boost/intrusive/pointer_rebind.hpp>
 #include <boost/intrusive/rbtree_algorithms.hpp>
 #include <boost/intrusive/pointer_plus_bits.hpp>
@@ -73,46 +74,46 @@ struct default_rbtree_node_traits_impl
 
    typedef typename node::color color;
 
-   static node_ptr get_parent(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_parent(const const_node_ptr & n)
    {  return n->parent_;  }
 
-   static node_ptr get_parent(const node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_parent(const node_ptr & n)
    {  return n->parent_;  }
 
-   static void set_parent(const node_ptr & n, const node_ptr & p)
+   BOOST_INTRUSIVE_FORCEINLINE static void set_parent(const node_ptr & n, const node_ptr & p)
    {  n->parent_ = p;  }
 
-   static node_ptr get_left(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_left(const const_node_ptr & n)
    {  return n->left_;  }
 
-   static node_ptr get_left(const node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_left(const node_ptr & n)
    {  return n->left_;  }
 
-   static void set_left(const node_ptr & n, const node_ptr & l)
+   BOOST_INTRUSIVE_FORCEINLINE static void set_left(const node_ptr & n, const node_ptr & l)
    {  n->left_ = l;  }
 
-   static node_ptr get_right(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_right(const const_node_ptr & n)
    {  return n->right_;  }
 
-   static node_ptr get_right(const node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_right(const node_ptr & n)
    {  return n->right_;  }
 
-   static void set_right(const node_ptr & n, const node_ptr & r)
+   BOOST_INTRUSIVE_FORCEINLINE static void set_right(const node_ptr & n, const node_ptr & r)
    {  n->right_ = r;  }
 
-   static color get_color(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static color get_color(const const_node_ptr & n)
    {  return n->color_;  }
 
-   static color get_color(const node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static color get_color(const node_ptr & n)
    {  return n->color_;  }
 
-   static void set_color(const node_ptr & n, color c)
+   BOOST_INTRUSIVE_FORCEINLINE static void set_color(const node_ptr & n, color c)
    {  n->color_ = c;  }
 
-   static color black()
+   BOOST_INTRUSIVE_FORCEINLINE static color black()
    {  return node::black_t;  }
 
-   static color red()
+   BOOST_INTRUSIVE_FORCEINLINE static color red()
    {  return node::red_t;  }
 };
 
@@ -129,46 +130,46 @@ struct compact_rbtree_node_traits_impl
 
    typedef typename node::color color;
 
-   static node_ptr get_parent(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_parent(const const_node_ptr & n)
    {  return ptr_bit::get_pointer(n->parent_);  }
 
-   static node_ptr get_parent(const node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_parent(const node_ptr & n)
    {  return ptr_bit::get_pointer(n->parent_);  }
 
-   static void set_parent(const node_ptr & n, const node_ptr & p)
+   BOOST_INTRUSIVE_FORCEINLINE static void set_parent(const node_ptr & n, const node_ptr & p)
    {  ptr_bit::set_pointer(n->parent_, p);  }
 
-   static node_ptr get_left(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_left(const const_node_ptr & n)
    {  return n->left_;  }
 
-   static node_ptr get_left(const node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_left(const node_ptr & n)
    {  return n->left_;  }
 
-   static void set_left(const node_ptr & n, const node_ptr & l)
+   BOOST_INTRUSIVE_FORCEINLINE static void set_left(const node_ptr & n, const node_ptr & l)
    {  n->left_ = l;  }
 
-   static node_ptr get_right(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_right(const const_node_ptr & n)
    {  return n->right_;  }
 
-   static node_ptr get_right(const node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_right(const node_ptr & n)
    {  return n->right_;  }
 
-   static void set_right(const node_ptr & n, const node_ptr & r)
+   BOOST_INTRUSIVE_FORCEINLINE static void set_right(const node_ptr & n, const node_ptr & r)
    {  n->right_ = r;  }
 
-   static color get_color(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static color get_color(const const_node_ptr & n)
    {  return (color)ptr_bit::get_bits(n->parent_);  }
 
-   static color get_color(const node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static color get_color(const node_ptr & n)
    {  return (color)ptr_bit::get_bits(n->parent_);  }
 
-   static void set_color(const node_ptr & n, color c)
+   BOOST_INTRUSIVE_FORCEINLINE static void set_color(const node_ptr & n, color c)
    {  ptr_bit::set_bits(n->parent_, c != 0);  }
 
-   static color black()
+   BOOST_INTRUSIVE_FORCEINLINE static color black()
    {  return node::black_t;  }
 
-   static color red()
+   BOOST_INTRUSIVE_FORCEINLINE static color red()
    {  return node::red_t;  }
 };