Declare more BOOST_INTRUSIVE_FORCEINLINE functions in tree and list containers.

include/boost/intrusive/avl_set.hpp

@@ -525,46 +525,46 @@ class avl_set
    //Assert if passed value traits are compatible with the type
    BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
 
-   avl_set()
+   BOOST_INTRUSIVE_FORCEINLINE avl_set()
       :  Base()
    {}
 
-   explicit avl_set( const key_compare &cmp, const value_traits &v_traits = value_traits())
+   BOOST_INTRUSIVE_FORCEINLINE explicit avl_set( const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  Base(cmp, v_traits)
    {}
 
    template<class Iterator>
-   avl_set( Iterator b, Iterator e
+   BOOST_INTRUSIVE_FORCEINLINE avl_set( Iterator b, Iterator e
       , const key_compare &cmp = key_compare()
       , const value_traits &v_traits = value_traits())
       :  Base(b, e, cmp, v_traits)
    {}
 
-   avl_set(BOOST_RV_REF(avl_set) x)
+   BOOST_INTRUSIVE_FORCEINLINE avl_set(BOOST_RV_REF(avl_set) x)
       :  Base(BOOST_MOVE_BASE(Base, x))
    {}
 
-   avl_set& operator=(BOOST_RV_REF(avl_set) x)
+   BOOST_INTRUSIVE_FORCEINLINE avl_set& operator=(BOOST_RV_REF(avl_set) x)
    {  return static_cast<avl_set &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x)));  }
 
    template <class Cloner, class Disposer>
-   void clone_from(const avl_set &src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(const avl_set &src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(src, cloner, disposer);  }
 
    template <class Cloner, class Disposer>
-   void clone_from(BOOST_RV_REF(avl_set) src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(avl_set) src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 
-   static avl_set &container_from_end_iterator(iterator end_iterator)
+   BOOST_INTRUSIVE_FORCEINLINE static avl_set &container_from_end_iterator(iterator end_iterator)
    {  return static_cast<avl_set &>(Base::container_from_end_iterator(end_iterator));   }
 
-   static const avl_set &container_from_end_iterator(const_iterator end_iterator)
+   BOOST_INTRUSIVE_FORCEINLINE static const avl_set &container_from_end_iterator(const_iterator end_iterator)
    {  return static_cast<const avl_set &>(Base::container_from_end_iterator(end_iterator));   }
 
-   static avl_set &container_from_iterator(iterator it)
+   BOOST_INTRUSIVE_FORCEINLINE static avl_set &container_from_iterator(iterator it)
    {  return static_cast<avl_set &>(Base::container_from_iterator(it));   }
 
-   static const avl_set &container_from_iterator(const_iterator it)
+   BOOST_INTRUSIVE_FORCEINLINE static const avl_set &container_from_iterator(const_iterator it)
    {  return static_cast<const avl_set &>(Base::container_from_iterator(it));   }
 };
 
@@ -1020,46 +1020,46 @@ class avl_multiset
    //Assert if passed value traits are compatible with the type
    BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
 
-   avl_multiset()
+   BOOST_INTRUSIVE_FORCEINLINE avl_multiset()
       :  Base()
    {}
 
-   explicit avl_multiset( const key_compare &cmp, const value_traits &v_traits = value_traits())
+   BOOST_INTRUSIVE_FORCEINLINE explicit avl_multiset( const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  Base(cmp, v_traits)
    {}
 
    template<class Iterator>
-   avl_multiset( Iterator b, Iterator e
+   BOOST_INTRUSIVE_FORCEINLINE avl_multiset( Iterator b, Iterator e
            , const key_compare &cmp = key_compare()
            , const value_traits &v_traits = value_traits())
       :  Base(b, e, cmp, v_traits)
    {}
 
-   avl_multiset(BOOST_RV_REF(avl_multiset) x)
+   BOOST_INTRUSIVE_FORCEINLINE avl_multiset(BOOST_RV_REF(avl_multiset) x)
       :  Base(BOOST_MOVE_BASE(Base, x))
    {}
 
-   avl_multiset& operator=(BOOST_RV_REF(avl_multiset) x)
+   BOOST_INTRUSIVE_FORCEINLINE avl_multiset& operator=(BOOST_RV_REF(avl_multiset) x)
    {  return static_cast<avl_multiset &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x)));  }
 
    template <class Cloner, class Disposer>
-   void clone_from(const avl_multiset &src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(const avl_multiset &src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(src, cloner, disposer);  }
 
    template <class Cloner, class Disposer>
-   void clone_from(BOOST_RV_REF(avl_multiset) src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(avl_multiset) src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 
-   static avl_multiset &container_from_end_iterator(iterator end_iterator)
+   BOOST_INTRUSIVE_FORCEINLINE static avl_multiset &container_from_end_iterator(iterator end_iterator)
    {  return static_cast<avl_multiset &>(Base::container_from_end_iterator(end_iterator));   }
 
-   static const avl_multiset &container_from_end_iterator(const_iterator end_iterator)
+   BOOST_INTRUSIVE_FORCEINLINE static const avl_multiset &container_from_end_iterator(const_iterator end_iterator)
    {  return static_cast<const avl_multiset &>(Base::container_from_end_iterator(end_iterator));   }
 
-   static avl_multiset &container_from_iterator(iterator it)
+   BOOST_INTRUSIVE_FORCEINLINE static avl_multiset &container_from_iterator(iterator it)
    {  return static_cast<avl_multiset &>(Base::container_from_iterator(it));   }
 
-   static const avl_multiset &container_from_iterator(const_iterator it)
+   BOOST_INTRUSIVE_FORCEINLINE static const avl_multiset &container_from_iterator(const_iterator it)
    {  return static_cast<const avl_multiset &>(Base::container_from_iterator(it));   }
 };
 

include/boost/intrusive/avltree.hpp

@@ -535,46 +535,46 @@ class avltree
    //Assert if passed value traits are compatible with the type
    BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
 
-   avltree()
+   BOOST_INTRUSIVE_FORCEINLINE avltree()
       :  Base()
    {}
 
-   explicit avltree( const key_compare &cmp, const value_traits &v_traits = value_traits())
+   BOOST_INTRUSIVE_FORCEINLINE explicit avltree( const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  Base(cmp, v_traits)
    {}
 
    template<class Iterator>
-   avltree( bool unique, Iterator b, Iterator e
+   BOOST_INTRUSIVE_FORCEINLINE avltree( bool unique, Iterator b, Iterator e
          , const key_compare &cmp = key_compare()
          , const value_traits &v_traits = value_traits())
       :  Base(unique, b, e, cmp, v_traits)
    {}
 
-   avltree(BOOST_RV_REF(avltree) x)
+   BOOST_INTRUSIVE_FORCEINLINE avltree(BOOST_RV_REF(avltree) x)
       :  Base(BOOST_MOVE_BASE(Base, x))
    {}
 
-   avltree& operator=(BOOST_RV_REF(avltree) x)
+   BOOST_INTRUSIVE_FORCEINLINE avltree& operator=(BOOST_RV_REF(avltree) x)
    {  return static_cast<avltree &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x)));  }
 
    template <class Cloner, class Disposer>
-   void clone_from(const avltree &src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(const avltree &src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(src, cloner, disposer);  }
 
    template <class Cloner, class Disposer>
-   void clone_from(BOOST_RV_REF(avltree) src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(avltree) src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 
-   static avltree &container_from_end_iterator(iterator end_iterator)
+   BOOST_INTRUSIVE_FORCEINLINE static avltree &container_from_end_iterator(iterator end_iterator)
    {  return static_cast<avltree &>(Base::container_from_end_iterator(end_iterator));   }
 
-   static const avltree &container_from_end_iterator(const_iterator end_iterator)
+   BOOST_INTRUSIVE_FORCEINLINE static const avltree &container_from_end_iterator(const_iterator end_iterator)
    {  return static_cast<const avltree &>(Base::container_from_end_iterator(end_iterator));   }
 
-   static avltree &container_from_iterator(iterator it)
+   BOOST_INTRUSIVE_FORCEINLINE static avltree &container_from_iterator(iterator it)
    {  return static_cast<avltree &>(Base::container_from_iterator(it));   }
 
-   static const avltree &container_from_iterator(const_iterator it)
+   BOOST_INTRUSIVE_FORCEINLINE static const avltree &container_from_iterator(const_iterator it)
    {  return static_cast<const avltree &>(Base::container_from_iterator(it));   }
 };
 

include/boost/intrusive/bs_set.hpp

@@ -522,46 +522,46 @@ class bs_set
    //Assert if passed value traits are compatible with the type
    BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
 
-   bs_set()
+   BOOST_INTRUSIVE_FORCEINLINE bs_set()
       :  Base()
    {}
 
-   explicit bs_set( const key_compare &cmp, const value_traits &v_traits = value_traits())
+   BOOST_INTRUSIVE_FORCEINLINE explicit bs_set( const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  Base(cmp, v_traits)
    {}
 
    template<class Iterator>
-   bs_set( Iterator b, Iterator e
+   BOOST_INTRUSIVE_FORCEINLINE bs_set( Iterator b, Iterator e
       , const key_compare &cmp = key_compare()
       , const value_traits &v_traits = value_traits())
       :  Base(b, e, cmp, v_traits)
    {}
 
-   bs_set(BOOST_RV_REF(bs_set) x)
+   BOOST_INTRUSIVE_FORCEINLINE bs_set(BOOST_RV_REF(bs_set) x)
       :  Base(BOOST_MOVE_BASE(Base, x))
    {}
 
-   bs_set& operator=(BOOST_RV_REF(bs_set) x)
+   BOOST_INTRUSIVE_FORCEINLINE bs_set& operator=(BOOST_RV_REF(bs_set) x)
    {  return static_cast<bs_set &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x)));  }
 
    template <class Cloner, class Disposer>
-   void clone_from(const bs_set &src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(const bs_set &src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(src, cloner, disposer);  }
 
    template <class Cloner, class Disposer>
-   void clone_from(BOOST_RV_REF(bs_set) src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(bs_set) src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 
-   static bs_set &container_from_end_iterator(iterator end_iterator)
+   BOOST_INTRUSIVE_FORCEINLINE static bs_set &container_from_end_iterator(iterator end_iterator)
    {  return static_cast<bs_set &>(Base::container_from_end_iterator(end_iterator));   }
 
-   static const bs_set &container_from_end_iterator(const_iterator end_iterator)
+   BOOST_INTRUSIVE_FORCEINLINE static const bs_set &container_from_end_iterator(const_iterator end_iterator)
    {  return static_cast<const bs_set &>(Base::container_from_end_iterator(end_iterator));   }
 
-   static bs_set &container_from_iterator(iterator it)
+   BOOST_INTRUSIVE_FORCEINLINE static bs_set &container_from_iterator(iterator it)
    {  return static_cast<bs_set &>(Base::container_from_iterator(it));   }
 
-   static const bs_set &container_from_iterator(const_iterator it)
+   BOOST_INTRUSIVE_FORCEINLINE static const bs_set &container_from_iterator(const_iterator it)
    {  return static_cast<const bs_set &>(Base::container_from_iterator(it));   }
 };
 
@@ -1016,46 +1016,46 @@ class bs_multiset
    //Assert if passed value traits are compatible with the type
    BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
 
-   bs_multiset()
+   BOOST_INTRUSIVE_FORCEINLINE bs_multiset()
       :  Base()
    {}
 
-   explicit bs_multiset( const key_compare &cmp, const value_traits &v_traits = value_traits())
+   BOOST_INTRUSIVE_FORCEINLINE explicit bs_multiset( const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  Base(cmp, v_traits)
    {}
 
    template<class Iterator>
-   bs_multiset( Iterator b, Iterator e
+   BOOST_INTRUSIVE_FORCEINLINE bs_multiset( Iterator b, Iterator e
            , const key_compare &cmp = key_compare()
            , const value_traits &v_traits = value_traits())
       :  Base(b, e, cmp, v_traits)
    {}
 
-   bs_multiset(BOOST_RV_REF(bs_multiset) x)
+   BOOST_INTRUSIVE_FORCEINLINE bs_multiset(BOOST_RV_REF(bs_multiset) x)
       :  Base(BOOST_MOVE_BASE(Base, x))
    {}
 
-   bs_multiset& operator=(BOOST_RV_REF(bs_multiset) x)
+   BOOST_INTRUSIVE_FORCEINLINE bs_multiset& operator=(BOOST_RV_REF(bs_multiset) x)
    {  return static_cast<bs_multiset &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x)));  }
 
    template <class Cloner, class Disposer>
-   void clone_from(const bs_multiset &src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(const bs_multiset &src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(src, cloner, disposer);  }
 
    template <class Cloner, class Disposer>
-   void clone_from(BOOST_RV_REF(bs_multiset) src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(bs_multiset) src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 
-   static bs_multiset &container_from_end_iterator(iterator end_iterator)
+   BOOST_INTRUSIVE_FORCEINLINE static bs_multiset &container_from_end_iterator(iterator end_iterator)
    {  return static_cast<bs_multiset &>(Base::container_from_end_iterator(end_iterator));   }
 
-   static const bs_multiset &container_from_end_iterator(const_iterator end_iterator)
+   BOOST_INTRUSIVE_FORCEINLINE static const bs_multiset &container_from_end_iterator(const_iterator end_iterator)
    {  return static_cast<const bs_multiset &>(Base::container_from_end_iterator(end_iterator));   }
 
-   static bs_multiset &container_from_iterator(iterator it)
+   BOOST_INTRUSIVE_FORCEINLINE static bs_multiset &container_from_iterator(iterator it)
    {  return static_cast<bs_multiset &>(Base::container_from_iterator(it));   }
 
-   static const bs_multiset &container_from_iterator(const_iterator it)
+   BOOST_INTRUSIVE_FORCEINLINE static const bs_multiset &container_from_iterator(const_iterator it)
    {  return static_cast<const bs_multiset &>(Base::container_from_iterator(it));   }
 };
 

include/boost/intrusive/bstree.hpp

@@ -2194,46 +2194,46 @@ class bstree
    //Assert if passed value traits are compatible with the type
    BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
 
-   bstree()
+   BOOST_INTRUSIVE_FORCEINLINE bstree()
       :  Base()
    {}
 
-   explicit bstree( const key_compare &cmp, const value_traits &v_traits = value_traits())
+   BOOST_INTRUSIVE_FORCEINLINE explicit bstree( const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  Base(cmp, v_traits)
    {}
 
    template<class Iterator>
-   bstree( bool unique, Iterator b, Iterator e
+   BOOST_INTRUSIVE_FORCEINLINE bstree( bool unique, Iterator b, Iterator e
          , const key_compare &cmp = key_compare()
          , const value_traits &v_traits = value_traits())
       :  Base(unique, b, e, cmp, v_traits)
    {}
 
-   bstree(BOOST_RV_REF(bstree) x)
+   BOOST_INTRUSIVE_FORCEINLINE bstree(BOOST_RV_REF(bstree) x)
       :  Base(BOOST_MOVE_BASE(Base, x))
    {}
 
-   bstree& operator=(BOOST_RV_REF(bstree) x)
+   BOOST_INTRUSIVE_FORCEINLINE bstree& operator=(BOOST_RV_REF(bstree) x)
    {  return static_cast<bstree &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x)));  }
 
    template <class Cloner, class Disposer>
-   void clone_from(const bstree &src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(const bstree &src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(src, cloner, disposer);  }
 
    template <class Cloner, class Disposer>
-   void clone_from(BOOST_RV_REF(bstree) src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(bstree) src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 
-   static bstree &container_from_end_iterator(iterator end_iterator)
+   BOOST_INTRUSIVE_FORCEINLINE static bstree &container_from_end_iterator(iterator end_iterator)
    {  return static_cast<bstree &>(Base::container_from_end_iterator(end_iterator));   }
 
-   static const bstree &container_from_end_iterator(const_iterator end_iterator)
+   BOOST_INTRUSIVE_FORCEINLINE static const bstree &container_from_end_iterator(const_iterator end_iterator)
    {  return static_cast<const bstree &>(Base::container_from_end_iterator(end_iterator));   }
 
-   static bstree &container_from_iterator(iterator it)
+   BOOST_INTRUSIVE_FORCEINLINE static bstree &container_from_iterator(iterator it)
    {  return static_cast<bstree &>(Base::container_from_iterator(it));   }
 
-   static const bstree &container_from_iterator(const_iterator it)
+   BOOST_INTRUSIVE_FORCEINLINE static const bstree &container_from_iterator(const_iterator it)
    {  return static_cast<const bstree &>(Base::container_from_iterator(it));   }
 };
 

include/boost/intrusive/detail/generic_hook.hpp

@@ -161,52 +161,52 @@ class generic_hook
       < NodeTraits
       , Tag, LinkMode, BaseHookType>                  hooktags;
 
-   node_ptr this_ptr()
+   BOOST_INTRUSIVE_FORCEINLINE node_ptr this_ptr()
    {  return pointer_traits<node_ptr>::pointer_to(static_cast<node&>(*this)); }
 
-   const_node_ptr this_ptr() const
+   BOOST_INTRUSIVE_FORCEINLINE const_node_ptr this_ptr() const
    {  return pointer_traits<const_node_ptr>::pointer_to(static_cast<const node&>(*this)); }
 
    public:
    /// @endcond
 
-   generic_hook()
+   BOOST_INTRUSIVE_FORCEINLINE generic_hook()
    {
       if(hooktags::safemode_or_autounlink){
          node_algorithms::init(this->this_ptr());
       }
    }
 
-   generic_hook(const generic_hook& )
+   BOOST_INTRUSIVE_FORCEINLINE generic_hook(const generic_hook& )
    {
       if(hooktags::safemode_or_autounlink){
          node_algorithms::init(this->this_ptr());
       }
    }
 
-   generic_hook& operator=(const generic_hook& )
+   BOOST_INTRUSIVE_FORCEINLINE generic_hook& operator=(const generic_hook& )
    {  return *this;  }
 
-   ~generic_hook()
+   BOOST_INTRUSIVE_FORCEINLINE ~generic_hook()
    {
       destructor_impl
          (*this, detail::link_dispatch<hooktags::link_mode>());
    }
 
-   void swap_nodes(generic_hook &other)
+   BOOST_INTRUSIVE_FORCEINLINE void swap_nodes(generic_hook &other)
    {
       node_algorithms::swap_nodes
          (this->this_ptr(), other.this_ptr());
    }
 
-   bool is_linked() const
+   BOOST_INTRUSIVE_FORCEINLINE bool is_linked() const
    {
       //is_linked() can be only used in safe-mode or auto-unlink
       BOOST_STATIC_ASSERT(( hooktags::safemode_or_autounlink ));
       return !node_algorithms::unique(this->this_ptr());
    }
 
-   void unlink()
+   BOOST_INTRUSIVE_FORCEINLINE void unlink()
    {
       BOOST_STATIC_ASSERT(( (int)hooktags::link_mode == (int)auto_unlink ));
       node_ptr n(this->this_ptr());

include/boost/intrusive/detail/workaround.hpp

@@ -34,7 +34,7 @@
 #define BOOST_INTRUSIVE_I ,
 #define BOOST_INTRUSIVE_DOCIGN(T1) T1
 
-#define BOOST_INTRUSIVE_DISABLE_FORCEINLINE
+//#define BOOST_INTRUSIVE_DISABLE_FORCEINLINE
 
 #if defined(BOOST_INTRUSIVE_DISABLE_FORCEINLINE)
    #define BOOST_INTRUSIVE_FORCEINLINE inline

include/boost/intrusive/list.hpp

@@ -1471,38 +1471,38 @@ class list
    typedef typename Base::iterator              iterator;
    typedef typename Base::const_iterator        const_iterator;
 
-   list()
+   BOOST_INTRUSIVE_FORCEINLINE list()
       :  Base()
    {}
 
-   explicit list(const value_traits &v_traits)
+   BOOST_INTRUSIVE_FORCEINLINE explicit list(const value_traits &v_traits)
       :  Base(v_traits)
    {}
 
    template<class Iterator>
-   list(Iterator b, Iterator e, const value_traits &v_traits = value_traits())
+   BOOST_INTRUSIVE_FORCEINLINE list(Iterator b, Iterator e, const value_traits &v_traits = value_traits())
       :  Base(b, e, v_traits)
    {}
 
-   list(BOOST_RV_REF(list) x)
+   BOOST_INTRUSIVE_FORCEINLINE list(BOOST_RV_REF(list) x)
       :  Base(BOOST_MOVE_BASE(Base, x))
    {}
 
-   list& operator=(BOOST_RV_REF(list) x)
+   BOOST_INTRUSIVE_FORCEINLINE list& operator=(BOOST_RV_REF(list) x)
    {  return static_cast<list &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x)));  }
 
    template <class Cloner, class Disposer>
-   void clone_from(const list &src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(const list &src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(src, cloner, disposer);  }
 
    template <class Cloner, class Disposer>
-   void clone_from(BOOST_RV_REF(list) src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(list) src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 
-   static list &container_from_end_iterator(iterator end_iterator)
+   BOOST_INTRUSIVE_FORCEINLINE static list &container_from_end_iterator(iterator end_iterator)
    {  return static_cast<list &>(Base::container_from_end_iterator(end_iterator));   }
 
-   static const list &container_from_end_iterator(const_iterator end_iterator)
+   BOOST_INTRUSIVE_FORCEINLINE static const list &container_from_end_iterator(const_iterator end_iterator)
    {  return static_cast<const list &>(Base::container_from_end_iterator(end_iterator));   }
 };
 

include/boost/intrusive/pointer_traits.hpp

@@ -123,7 +123,7 @@ struct pointer_traits
    //!
    //! <b>Note</b>: For non-conforming compilers only the existence of a member function called
    //!   <code>pointer_to</code> is checked.
-   static pointer pointer_to(reference r)
+   BOOST_INTRUSIVE_FORCEINLINE static pointer pointer_to(reference r)
    {
       //Non-standard extension, it does not require Ptr::pointer_to. If not present
       //tries to converts &r to pointer.
@@ -143,7 +143,7 @@ struct pointer_traits
    //! <b>Note</b>: For non-conforming compilers only the existence of a member function called
    //!   <code>static_cast_from</code> is checked.
    template<class UPtr>
-   static pointer static_cast_from(const UPtr &uptr)
+   BOOST_INTRUSIVE_FORCEINLINE static pointer static_cast_from(const UPtr &uptr)
    {
       typedef const UPtr &RefArg;
       const bool value = boost::intrusive::detail::
@@ -164,7 +164,7 @@ struct pointer_traits
    //! <b>Note</b>: For non-conforming compilers only the existence of a member function called
    //!   <code>const_cast_from</code> is checked.
    template<class UPtr>
-   static pointer const_cast_from(const UPtr &uptr)
+   BOOST_INTRUSIVE_FORCEINLINE static pointer const_cast_from(const UPtr &uptr)
    {
       typedef const UPtr &RefArg;
       const bool value = boost::intrusive::detail::
@@ -185,7 +185,7 @@ struct pointer_traits
    //! <b>Note</b>: For non-conforming compilers only the existence of a member function called
    //!   <code>dynamic_cast_from</code> is checked.
    template<class UPtr>
-   static pointer dynamic_cast_from(const UPtr &uptr)
+   BOOST_INTRUSIVE_FORCEINLINE static pointer dynamic_cast_from(const UPtr &uptr)
    {
       typedef const UPtr &RefArg;
       const bool value = boost::intrusive::detail::
@@ -201,46 +201,46 @@ struct pointer_traits
    private:
    //priv_to_raw_pointer
    template <class T>
-   static T* to_raw_pointer(T* p)
+   BOOST_INTRUSIVE_FORCEINLINE static T* to_raw_pointer(T* p)
    {  return p; }
 
    template <class Pointer>
-   static typename pointer_traits<Pointer>::element_type*
+   BOOST_INTRUSIVE_FORCEINLINE static typename pointer_traits<Pointer>::element_type*
       to_raw_pointer(const Pointer &p)
    {  return pointer_traits::to_raw_pointer(p.operator->());  }
 
    //priv_pointer_to
-   static pointer priv_pointer_to(boost::intrusive::detail::true_, reference r)
+   BOOST_INTRUSIVE_FORCEINLINE static pointer priv_pointer_to(boost::intrusive::detail::true_, reference r)
    { return Ptr::pointer_to(r); }
 
-   static pointer priv_pointer_to(boost::intrusive::detail::false_, reference r)
+   BOOST_INTRUSIVE_FORCEINLINE static pointer priv_pointer_to(boost::intrusive::detail::false_, reference r)
    { return pointer(boost::intrusive::detail::addressof(r)); }
 
    //priv_static_cast_from
    template<class UPtr>
-   static pointer priv_static_cast_from(boost::intrusive::detail::true_, const UPtr &uptr)
+   BOOST_INTRUSIVE_FORCEINLINE static pointer priv_static_cast_from(boost::intrusive::detail::true_, const UPtr &uptr)
    { return Ptr::static_cast_from(uptr); }
 
    template<class UPtr>
-   static pointer priv_static_cast_from(boost::intrusive::detail::false_, const UPtr &uptr)
+   BOOST_INTRUSIVE_FORCEINLINE static pointer priv_static_cast_from(boost::intrusive::detail::false_, const UPtr &uptr)
    {  return uptr ? pointer_to(*static_cast<element_type*>(to_raw_pointer(uptr))) : pointer();  }
 
    //priv_const_cast_from
    template<class UPtr>
-   static pointer priv_const_cast_from(boost::intrusive::detail::true_, const UPtr &uptr)
+   BOOST_INTRUSIVE_FORCEINLINE static pointer priv_const_cast_from(boost::intrusive::detail::true_, const UPtr &uptr)
    { return Ptr::const_cast_from(uptr); }
 
    template<class UPtr>
-   static pointer priv_const_cast_from(boost::intrusive::detail::false_, const UPtr &uptr)
+   BOOST_INTRUSIVE_FORCEINLINE static pointer priv_const_cast_from(boost::intrusive::detail::false_, const UPtr &uptr)
    {  return uptr ? pointer_to(const_cast<element_type&>(*uptr)) : pointer();  }
 
    //priv_dynamic_cast_from
    template<class UPtr>
-   static pointer priv_dynamic_cast_from(boost::intrusive::detail::true_, const UPtr &uptr)
+   BOOST_INTRUSIVE_FORCEINLINE static pointer priv_dynamic_cast_from(boost::intrusive::detail::true_, const UPtr &uptr)
    { return Ptr::dynamic_cast_from(uptr); }
 
    template<class UPtr>
-   static pointer priv_dynamic_cast_from(boost::intrusive::detail::false_, const UPtr &uptr)
+   BOOST_INTRUSIVE_FORCEINLINE static pointer priv_dynamic_cast_from(boost::intrusive::detail::false_, const UPtr &uptr)
    {  return uptr ? pointer_to(dynamic_cast<element_type&>(*uptr)) : pointer();  }
    ///@endcond
 };

include/boost/intrusive/rbtree.hpp

@@ -538,46 +538,46 @@ class rbtree
    //Assert if passed value traits are compatible with the type
    BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
 
-   rbtree()
+   BOOST_INTRUSIVE_FORCEINLINE rbtree()
       :  Base()
    {}
 
-   explicit rbtree( const key_compare &cmp, const value_traits &v_traits = value_traits())
+   BOOST_INTRUSIVE_FORCEINLINE explicit rbtree( const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  Base(cmp, v_traits)
    {}
 
    template<class Iterator>
-   rbtree( bool unique, Iterator b, Iterator e
+   BOOST_INTRUSIVE_FORCEINLINE rbtree( bool unique, Iterator b, Iterator e
          , const key_compare &cmp = key_compare()
          , const value_traits &v_traits = value_traits())
       :  Base(unique, b, e, cmp, v_traits)
    {}
 
-   rbtree(BOOST_RV_REF(rbtree) x)
+   BOOST_INTRUSIVE_FORCEINLINE rbtree(BOOST_RV_REF(rbtree) x)
       :  Base(BOOST_MOVE_BASE(Base, x))
    {}
 
-   rbtree& operator=(BOOST_RV_REF(rbtree) x)
+   BOOST_INTRUSIVE_FORCEINLINE rbtree& operator=(BOOST_RV_REF(rbtree) x)
    {  return static_cast<rbtree &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x)));  }
 
    template <class Cloner, class Disposer>
-   void clone_from(const rbtree &src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(const rbtree &src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(src, cloner, disposer);  }
 
    template <class Cloner, class Disposer>
-   void clone_from(BOOST_RV_REF(rbtree) src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(rbtree) src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 
-   static rbtree &container_from_end_iterator(iterator end_iterator)
+   BOOST_INTRUSIVE_FORCEINLINE static rbtree &container_from_end_iterator(iterator end_iterator)
    {  return static_cast<rbtree &>(Base::container_from_end_iterator(end_iterator));   }
 
-   static const rbtree &container_from_end_iterator(const_iterator end_iterator)
+   BOOST_INTRUSIVE_FORCEINLINE static const rbtree &container_from_end_iterator(const_iterator end_iterator)
    {  return static_cast<const rbtree &>(Base::container_from_end_iterator(end_iterator));   }
 
-   static rbtree &container_from_iterator(iterator it)
+   BOOST_INTRUSIVE_FORCEINLINE static rbtree &container_from_iterator(iterator it)
    {  return static_cast<rbtree &>(Base::container_from_iterator(it));   }
 
-   static const rbtree &container_from_iterator(const_iterator it)
+   BOOST_INTRUSIVE_FORCEINLINE static const rbtree &container_from_iterator(const_iterator it)
    {  return static_cast<const rbtree &>(Base::container_from_iterator(it));   }
 };
 

include/boost/intrusive/rbtree_algorithms.hpp

@@ -273,7 +273,7 @@ class rbtree_algorithms
    #endif   //#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
 
    //! @copydoc ::boost::intrusive::bstree_algorithms::init_header(node_ptr)
-   static void init_header(node_ptr header)
+   BOOST_INTRUSIVE_FORCEINLINE static void init_header(node_ptr header)
    {
       bstree_algo::init_header(header);
       NodeTraits::set_color(header, NodeTraits::red());

include/boost/intrusive/set.hpp

@@ -525,46 +525,46 @@ class set
    //Assert if passed value traits are compatible with the type
    BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
 
-   set()
+   BOOST_INTRUSIVE_FORCEINLINE set()
       :  Base()
    {}
 
-   explicit set( const key_compare &cmp, const value_traits &v_traits = value_traits())
+   BOOST_INTRUSIVE_FORCEINLINE explicit set( const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  Base(cmp, v_traits)
    {}
 
    template<class Iterator>
-   set( Iterator b, Iterator e
+   BOOST_INTRUSIVE_FORCEINLINE set( Iterator b, Iterator e
       , const key_compare &cmp = key_compare()
       , const value_traits &v_traits = value_traits())
       :  Base(b, e, cmp, v_traits)
    {}
 
-   set(BOOST_RV_REF(set) x)
+   BOOST_INTRUSIVE_FORCEINLINE set(BOOST_RV_REF(set) x)
       :  Base(BOOST_MOVE_BASE(Base, x))
    {}
 
-   set& operator=(BOOST_RV_REF(set) x)
+   BOOST_INTRUSIVE_FORCEINLINE set& operator=(BOOST_RV_REF(set) x)
    {  return static_cast<set &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x)));  }
 
    template <class Cloner, class Disposer>
-   void clone_from(const set &src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(const set &src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(src, cloner, disposer);  }
 
    template <class Cloner, class Disposer>
-   void clone_from(BOOST_RV_REF(set) src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(set) src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 
-   static set &container_from_end_iterator(iterator end_iterator)
+   BOOST_INTRUSIVE_FORCEINLINE static set &container_from_end_iterator(iterator end_iterator)
    {  return static_cast<set &>(Base::container_from_end_iterator(end_iterator));   }
 
-   static const set &container_from_end_iterator(const_iterator end_iterator)
+   BOOST_INTRUSIVE_FORCEINLINE static const set &container_from_end_iterator(const_iterator end_iterator)
    {  return static_cast<const set &>(Base::container_from_end_iterator(end_iterator));   }
 
-   static set &container_from_iterator(iterator it)
+   BOOST_INTRUSIVE_FORCEINLINE static set &container_from_iterator(iterator it)
    {  return static_cast<set &>(Base::container_from_iterator(it));   }
 
-   static const set &container_from_iterator(const_iterator it)
+   BOOST_INTRUSIVE_FORCEINLINE static const set &container_from_iterator(const_iterator it)
    {  return static_cast<const set &>(Base::container_from_iterator(it));   }
 };
 
@@ -1020,46 +1020,46 @@ class multiset
    //Assert if passed value traits are compatible with the type
    BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
 
-   multiset()
+   BOOST_INTRUSIVE_FORCEINLINE multiset()
       :  Base()
    {}
 
-   explicit multiset( const key_compare &cmp, const value_traits &v_traits = value_traits())
+   BOOST_INTRUSIVE_FORCEINLINE explicit multiset( const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  Base(cmp, v_traits)
    {}
 
    template<class Iterator>
-   multiset( Iterator b, Iterator e
+   BOOST_INTRUSIVE_FORCEINLINE multiset( Iterator b, Iterator e
            , const key_compare &cmp = key_compare()
            , const value_traits &v_traits = value_traits())
       :  Base(b, e, cmp, v_traits)
    {}
 
-   multiset(BOOST_RV_REF(multiset) x)
+   BOOST_INTRUSIVE_FORCEINLINE multiset(BOOST_RV_REF(multiset) x)
       :  Base(BOOST_MOVE_BASE(Base, x))
    {}
 
-   multiset& operator=(BOOST_RV_REF(multiset) x)
+   BOOST_INTRUSIVE_FORCEINLINE multiset& operator=(BOOST_RV_REF(multiset) x)
    {  return static_cast<multiset &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x)));  }
 
    template <class Cloner, class Disposer>
-   void clone_from(const multiset &src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(const multiset &src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(src, cloner, disposer);  }
 
    template <class Cloner, class Disposer>
-   void clone_from(BOOST_RV_REF(multiset) src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(multiset) src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 
-   static multiset &container_from_end_iterator(iterator end_iterator)
+   BOOST_INTRUSIVE_FORCEINLINE static multiset &container_from_end_iterator(iterator end_iterator)
    {  return static_cast<multiset &>(Base::container_from_end_iterator(end_iterator));   }
 
-   static const multiset &container_from_end_iterator(const_iterator end_iterator)
+   BOOST_INTRUSIVE_FORCEINLINE static const multiset &container_from_end_iterator(const_iterator end_iterator)
    {  return static_cast<const multiset &>(Base::container_from_end_iterator(end_iterator));   }
 
-   static multiset &container_from_iterator(iterator it)
+   BOOST_INTRUSIVE_FORCEINLINE static multiset &container_from_iterator(iterator it)
    {  return static_cast<multiset &>(Base::container_from_iterator(it));   }
 
-   static const multiset &container_from_iterator(const_iterator it)
+   BOOST_INTRUSIVE_FORCEINLINE static const multiset &container_from_iterator(const_iterator it)
    {  return static_cast<const multiset &>(Base::container_from_iterator(it));   }
 };
 

include/boost/intrusive/sg_set.hpp

@@ -534,46 +534,46 @@ class sg_set
    //Assert if passed value traits are compatible with the type
    BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
 
-   sg_set()
+   BOOST_INTRUSIVE_FORCEINLINE sg_set()
       :  Base()
    {}
 
-   explicit sg_set( const key_compare &cmp, const value_traits &v_traits = value_traits())
+   BOOST_INTRUSIVE_FORCEINLINE explicit sg_set( const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  Base(cmp, v_traits)
    {}
 
    template<class Iterator>
-   sg_set( Iterator b, Iterator e
+   BOOST_INTRUSIVE_FORCEINLINE sg_set( Iterator b, Iterator e
       , const key_compare &cmp = key_compare()
       , const value_traits &v_traits = value_traits())
       :  Base(b, e, cmp, v_traits)
    {}
 
-   sg_set(BOOST_RV_REF(sg_set) x)
+   BOOST_INTRUSIVE_FORCEINLINE sg_set(BOOST_RV_REF(sg_set) x)
       :  Base(BOOST_MOVE_BASE(Base, x))
    {}
 
-   sg_set& operator=(BOOST_RV_REF(sg_set) x)
+   BOOST_INTRUSIVE_FORCEINLINE sg_set& operator=(BOOST_RV_REF(sg_set) x)
    {  return static_cast<sg_set &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x)));  }
 
    template <class Cloner, class Disposer>
-   void clone_from(const sg_set &src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(const sg_set &src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(src, cloner, disposer);  }
 
    template <class Cloner, class Disposer>
-   void clone_from(BOOST_RV_REF(sg_set) src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(sg_set) src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 
-   static sg_set &container_from_end_iterator(iterator end_iterator)
+   BOOST_INTRUSIVE_FORCEINLINE static sg_set &container_from_end_iterator(iterator end_iterator)
    {  return static_cast<sg_set &>(Base::container_from_end_iterator(end_iterator));   }
 
-   static const sg_set &container_from_end_iterator(const_iterator end_iterator)
+   BOOST_INTRUSIVE_FORCEINLINE static const sg_set &container_from_end_iterator(const_iterator end_iterator)
    {  return static_cast<const sg_set &>(Base::container_from_end_iterator(end_iterator));   }
 
-   static sg_set &container_from_iterator(iterator it)
+   BOOST_INTRUSIVE_FORCEINLINE static sg_set &container_from_iterator(iterator it)
    {  return static_cast<sg_set &>(Base::container_from_iterator(it));   }
 
-   static const sg_set &container_from_iterator(const_iterator it)
+   BOOST_INTRUSIVE_FORCEINLINE static const sg_set &container_from_iterator(const_iterator it)
    {  return static_cast<const sg_set &>(Base::container_from_iterator(it));   }
 };
 
@@ -1041,46 +1041,46 @@ class sg_multiset
    //Assert if passed value traits are compatible with the type
    BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
 
-   sg_multiset()
+   BOOST_INTRUSIVE_FORCEINLINE sg_multiset()
       :  Base()
    {}
 
-   explicit sg_multiset( const key_compare &cmp, const value_traits &v_traits = value_traits())
+   BOOST_INTRUSIVE_FORCEINLINE explicit sg_multiset( const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  Base(cmp, v_traits)
    {}
 
    template<class Iterator>
-   sg_multiset( Iterator b, Iterator e
+   BOOST_INTRUSIVE_FORCEINLINE sg_multiset( Iterator b, Iterator e
            , const key_compare &cmp = key_compare()
            , const value_traits &v_traits = value_traits())
       :  Base(b, e, cmp, v_traits)
    {}
 
-   sg_multiset(BOOST_RV_REF(sg_multiset) x)
+   BOOST_INTRUSIVE_FORCEINLINE sg_multiset(BOOST_RV_REF(sg_multiset) x)
       :  Base(BOOST_MOVE_BASE(Base, x))
    {}
 
-   sg_multiset& operator=(BOOST_RV_REF(sg_multiset) x)
+   BOOST_INTRUSIVE_FORCEINLINE sg_multiset& operator=(BOOST_RV_REF(sg_multiset) x)
    {  return static_cast<sg_multiset &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x)));  }
 
    template <class Cloner, class Disposer>
-   void clone_from(const sg_multiset &src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(const sg_multiset &src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(src, cloner, disposer);  }
 
    template <class Cloner, class Disposer>
-   void clone_from(BOOST_RV_REF(sg_multiset) src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(sg_multiset) src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 
-   static sg_multiset &container_from_end_iterator(iterator end_iterator)
+   BOOST_INTRUSIVE_FORCEINLINE static sg_multiset &container_from_end_iterator(iterator end_iterator)
    {  return static_cast<sg_multiset &>(Base::container_from_end_iterator(end_iterator));   }
 
-   static const sg_multiset &container_from_end_iterator(const_iterator end_iterator)
+   BOOST_INTRUSIVE_FORCEINLINE static const sg_multiset &container_from_end_iterator(const_iterator end_iterator)
    {  return static_cast<const sg_multiset &>(Base::container_from_end_iterator(end_iterator));   }
 
-   static sg_multiset &container_from_iterator(iterator it)
+   BOOST_INTRUSIVE_FORCEINLINE static sg_multiset &container_from_iterator(iterator it)
    {  return static_cast<sg_multiset &>(Base::container_from_iterator(it));   }
 
-   static const sg_multiset &container_from_iterator(const_iterator it)
+   BOOST_INTRUSIVE_FORCEINLINE static const sg_multiset &container_from_iterator(const_iterator it)
    {  return static_cast<const sg_multiset &>(Base::container_from_iterator(it));   }
 };
 

include/boost/intrusive/sgtree.hpp

@@ -1028,46 +1028,46 @@ class sgtree
    //Assert if passed value traits are compatible with the type
    BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
 
-   sgtree()
+   BOOST_INTRUSIVE_FORCEINLINE sgtree()
       :  Base()
    {}
 
-   explicit sgtree(const key_compare &cmp, const value_traits &v_traits = value_traits())
+   BOOST_INTRUSIVE_FORCEINLINE explicit sgtree(const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  Base(cmp, v_traits)
    {}
 
    template<class Iterator>
-   sgtree( bool unique, Iterator b, Iterator e
+   BOOST_INTRUSIVE_FORCEINLINE sgtree( bool unique, Iterator b, Iterator e
          , const key_compare &cmp = key_compare()
          , const value_traits &v_traits = value_traits())
       :  Base(unique, b, e, cmp, v_traits)
    {}
 
-   sgtree(BOOST_RV_REF(sgtree) x)
+   BOOST_INTRUSIVE_FORCEINLINE sgtree(BOOST_RV_REF(sgtree) x)
       :  Base(BOOST_MOVE_BASE(Base, x))
    {}
 
-   sgtree& operator=(BOOST_RV_REF(sgtree) x)
+   BOOST_INTRUSIVE_FORCEINLINE sgtree& operator=(BOOST_RV_REF(sgtree) x)
    {  return static_cast<sgtree &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x)));  }
 
    template <class Cloner, class Disposer>
-   void clone_from(const sgtree &src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(const sgtree &src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(src, cloner, disposer);  }
 
    template <class Cloner, class Disposer>
-   void clone_from(BOOST_RV_REF(sgtree) src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(sgtree) src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 
-   static sgtree &container_from_end_iterator(iterator end_iterator)
+   BOOST_INTRUSIVE_FORCEINLINE static sgtree &container_from_end_iterator(iterator end_iterator)
    {  return static_cast<sgtree &>(Base::container_from_end_iterator(end_iterator));   }
 
-   static const sgtree &container_from_end_iterator(const_iterator end_iterator)
+   BOOST_INTRUSIVE_FORCEINLINE static const sgtree &container_from_end_iterator(const_iterator end_iterator)
    {  return static_cast<const sgtree &>(Base::container_from_end_iterator(end_iterator));   }
 
-   static sgtree &container_from_iterator(iterator it)
+   BOOST_INTRUSIVE_FORCEINLINE static sgtree &container_from_iterator(iterator it)
    {  return static_cast<sgtree &>(Base::container_from_iterator(it));   }
 
-   static const sgtree &container_from_iterator(const_iterator it)
+   BOOST_INTRUSIVE_FORCEINLINE static const sgtree &container_from_iterator(const_iterator it)
    {  return static_cast<const sgtree &>(Base::container_from_iterator(it));   }
 };
 

include/boost/intrusive/slist.hpp

@@ -233,7 +233,7 @@ class slist_impl
    {};
 
    struct data_t
-      :  public slist_impl::value_traits
+      :  public value_traits
    {
       typedef typename slist_impl::value_traits value_traits;
       explicit data_t(const value_traits &val_traits)
@@ -2202,45 +2202,45 @@ class slist
    typedef typename Base::size_type          size_type;
    typedef typename Base::node_ptr           node_ptr;
 
-   slist()
+   BOOST_INTRUSIVE_FORCEINLINE slist()
       :  Base()
    {}
 
-   explicit slist(const value_traits &v_traits)
+   BOOST_INTRUSIVE_FORCEINLINE explicit slist(const value_traits &v_traits)
       :  Base(v_traits)
    {}
 
    struct incorporate_t{};
 
-   slist( const node_ptr & f, const node_ptr & before_l
+   BOOST_INTRUSIVE_FORCEINLINE slist( const node_ptr & f, const node_ptr & before_l
              , size_type n, const value_traits &v_traits = value_traits())
       :  Base(f, before_l, n, v_traits)
    {}
 
    template<class Iterator>
-   slist(Iterator b, Iterator e, const value_traits &v_traits = value_traits())
+   BOOST_INTRUSIVE_FORCEINLINE slist(Iterator b, Iterator e, const value_traits &v_traits = value_traits())
       :  Base(b, e, v_traits)
    {}
 
-   slist(BOOST_RV_REF(slist) x)
+   BOOST_INTRUSIVE_FORCEINLINE slist(BOOST_RV_REF(slist) x)
       :  Base(BOOST_MOVE_BASE(Base, x))
    {}
 
-   slist& operator=(BOOST_RV_REF(slist) x)
+   BOOST_INTRUSIVE_FORCEINLINE slist& operator=(BOOST_RV_REF(slist) x)
    {  return static_cast<slist &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x)));  }
 
    template <class Cloner, class Disposer>
-   void clone_from(const slist &src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(const slist &src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(src, cloner, disposer);  }
 
    template <class Cloner, class Disposer>
-   void clone_from(BOOST_RV_REF(slist) src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(slist) src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 
-   static slist &container_from_end_iterator(iterator end_iterator)
+   BOOST_INTRUSIVE_FORCEINLINE static slist &container_from_end_iterator(iterator end_iterator)
    {  return static_cast<slist &>(Base::container_from_end_iterator(end_iterator));   }
 
-   static const slist &container_from_end_iterator(const_iterator end_iterator)
+   BOOST_INTRUSIVE_FORCEINLINE static const slist &container_from_end_iterator(const_iterator end_iterator)
    {  return static_cast<const slist &>(Base::container_from_end_iterator(end_iterator));   }
 };
 

include/boost/intrusive/splay_set.hpp

@@ -546,46 +546,46 @@ class splay_set
    //Assert if passed value traits are compatible with the type
    BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
 
-   splay_set()
+   BOOST_INTRUSIVE_FORCEINLINE splay_set()
       :  Base()
    {}
 
-   explicit splay_set( const key_compare &cmp, const value_traits &v_traits = value_traits())
+   BOOST_INTRUSIVE_FORCEINLINE explicit splay_set( const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  Base(cmp, v_traits)
    {}
 
    template<class Iterator>
-   splay_set( Iterator b, Iterator e
+   BOOST_INTRUSIVE_FORCEINLINE splay_set( Iterator b, Iterator e
       , const key_compare &cmp = key_compare()
       , const value_traits &v_traits = value_traits())
       :  Base(b, e, cmp, v_traits)
    {}
 
-   splay_set(BOOST_RV_REF(splay_set) x)
+   BOOST_INTRUSIVE_FORCEINLINE splay_set(BOOST_RV_REF(splay_set) x)
       :  Base(::boost::move(static_cast<Base&>(x)))
    {}
 
-   splay_set& operator=(BOOST_RV_REF(splay_set) x)
+   BOOST_INTRUSIVE_FORCEINLINE splay_set& operator=(BOOST_RV_REF(splay_set) x)
    {  return static_cast<splay_set &>(this->Base::operator=(::boost::move(static_cast<Base&>(x))));  }
 
    template <class Cloner, class Disposer>
-   void clone_from(const splay_set &src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(const splay_set &src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(src, cloner, disposer);  }
 
    template <class Cloner, class Disposer>
-   void clone_from(BOOST_RV_REF(splay_set) src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(splay_set) src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 
-   static splay_set &container_from_end_iterator(iterator end_iterator)
+   BOOST_INTRUSIVE_FORCEINLINE static splay_set &container_from_end_iterator(iterator end_iterator)
    {  return static_cast<splay_set &>(Base::container_from_end_iterator(end_iterator));   }
 
-   static const splay_set &container_from_end_iterator(const_iterator end_iterator)
+   BOOST_INTRUSIVE_FORCEINLINE static const splay_set &container_from_end_iterator(const_iterator end_iterator)
    {  return static_cast<const splay_set &>(Base::container_from_end_iterator(end_iterator));   }
 
-   static splay_set &container_from_iterator(iterator it)
+   BOOST_INTRUSIVE_FORCEINLINE static splay_set &container_from_iterator(iterator it)
    {  return static_cast<splay_set &>(Base::container_from_iterator(it));   }
 
-   static const splay_set &container_from_iterator(const_iterator it)
+   BOOST_INTRUSIVE_FORCEINLINE static const splay_set &container_from_iterator(const_iterator it)
    {  return static_cast<const splay_set &>(Base::container_from_iterator(it));   }
 };
 
@@ -1057,46 +1057,46 @@ class splay_multiset
    //Assert if passed value traits are compatible with the type
    BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
 
-   splay_multiset()
+   BOOST_INTRUSIVE_FORCEINLINE splay_multiset()
       :  Base()
    {}
 
-   explicit splay_multiset( const key_compare &cmp, const value_traits &v_traits = value_traits())
+   BOOST_INTRUSIVE_FORCEINLINE explicit splay_multiset( const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  Base(cmp, v_traits)
    {}
 
    template<class Iterator>
-   splay_multiset( Iterator b, Iterator e
+   BOOST_INTRUSIVE_FORCEINLINE splay_multiset( Iterator b, Iterator e
            , const key_compare &cmp = key_compare()
            , const value_traits &v_traits = value_traits())
       :  Base(b, e, cmp, v_traits)
    {}
 
-   splay_multiset(BOOST_RV_REF(splay_multiset) x)
+   BOOST_INTRUSIVE_FORCEINLINE splay_multiset(BOOST_RV_REF(splay_multiset) x)
       :  Base(::boost::move(static_cast<Base&>(x)))
    {}
 
-   splay_multiset& operator=(BOOST_RV_REF(splay_multiset) x)
+   BOOST_INTRUSIVE_FORCEINLINE splay_multiset& operator=(BOOST_RV_REF(splay_multiset) x)
    {  return static_cast<splay_multiset &>(this->Base::operator=(::boost::move(static_cast<Base&>(x))));  }
 
    template <class Cloner, class Disposer>
-   void clone_from(const splay_multiset &src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(const splay_multiset &src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(src, cloner, disposer);  }
 
    template <class Cloner, class Disposer>
-   void clone_from(BOOST_RV_REF(splay_multiset) src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(splay_multiset) src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 
-   static splay_multiset &container_from_end_iterator(iterator end_iterator)
+   BOOST_INTRUSIVE_FORCEINLINE static splay_multiset &container_from_end_iterator(iterator end_iterator)
    {  return static_cast<splay_multiset &>(Base::container_from_end_iterator(end_iterator));   }
 
-   static const splay_multiset &container_from_end_iterator(const_iterator end_iterator)
+   BOOST_INTRUSIVE_FORCEINLINE static const splay_multiset &container_from_end_iterator(const_iterator end_iterator)
    {  return static_cast<const splay_multiset &>(Base::container_from_end_iterator(end_iterator));   }
 
-   static splay_multiset &container_from_iterator(iterator it)
+   BOOST_INTRUSIVE_FORCEINLINE static splay_multiset &container_from_iterator(iterator it)
    {  return static_cast<splay_multiset &>(Base::container_from_iterator(it));   }
 
-   static const splay_multiset &container_from_iterator(const_iterator it)
+   BOOST_INTRUSIVE_FORCEINLINE static const splay_multiset &container_from_iterator(const_iterator it)
    {  return static_cast<const splay_multiset &>(Base::container_from_iterator(it));   }
 };
 

include/boost/intrusive/splaytree.hpp

@@ -613,46 +613,46 @@ class splaytree
    //Assert if passed value traits are compatible with the type
    BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
 
-   splaytree()
+   BOOST_INTRUSIVE_FORCEINLINE splaytree()
       :  Base()
    {}
 
-   explicit splaytree( const key_compare &cmp, const value_traits &v_traits = value_traits())
+   BOOST_INTRUSIVE_FORCEINLINE explicit splaytree( const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  Base(cmp, v_traits)
    {}
 
    template<class Iterator>
-   splaytree( bool unique, Iterator b, Iterator e
+   BOOST_INTRUSIVE_FORCEINLINE splaytree( bool unique, Iterator b, Iterator e
          , const key_compare &cmp = key_compare()
          , const value_traits &v_traits = value_traits())
       :  Base(unique, b, e, cmp, v_traits)
    {}
 
-   splaytree(BOOST_RV_REF(splaytree) x)
+   BOOST_INTRUSIVE_FORCEINLINE splaytree(BOOST_RV_REF(splaytree) x)
       :  Base(BOOST_MOVE_BASE(Base, x))
    {}
 
-   splaytree& operator=(BOOST_RV_REF(splaytree) x)
+   BOOST_INTRUSIVE_FORCEINLINE splaytree& operator=(BOOST_RV_REF(splaytree) x)
    {  return static_cast<splaytree &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x)));  }
 
    template <class Cloner, class Disposer>
-   void clone_from(const splaytree &src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(const splaytree &src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(src, cloner, disposer);  }
 
    template <class Cloner, class Disposer>
-   void clone_from(BOOST_RV_REF(splaytree) src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(splaytree) src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 
-   static splaytree &container_from_end_iterator(iterator end_iterator)
+   BOOST_INTRUSIVE_FORCEINLINE static splaytree &container_from_end_iterator(iterator end_iterator)
    {  return static_cast<splaytree &>(Base::container_from_end_iterator(end_iterator));   }
 
-   static const splaytree &container_from_end_iterator(const_iterator end_iterator)
+   BOOST_INTRUSIVE_FORCEINLINE static const splaytree &container_from_end_iterator(const_iterator end_iterator)
    {  return static_cast<const splaytree &>(Base::container_from_end_iterator(end_iterator));   }
 
-   static splaytree &container_from_iterator(iterator it)
+   BOOST_INTRUSIVE_FORCEINLINE static splaytree &container_from_iterator(iterator it)
    {  return static_cast<splaytree &>(Base::container_from_iterator(it));   }
 
-   static const splaytree &container_from_iterator(const_iterator it)
+   BOOST_INTRUSIVE_FORCEINLINE static const splaytree &container_from_iterator(const_iterator it)
    {  return static_cast<const splaytree &>(Base::container_from_iterator(it));   }
 };
 

include/boost/intrusive/unordered_set_hook.hpp

@@ -82,22 +82,22 @@ struct unordered_node_traits
    static const bool store_hash        = StoreHash;
    static const bool optimize_multikey = OptimizeMultiKey;
 
-   static node_ptr get_next(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_next(const const_node_ptr & n)
    {  return pointer_traits<node_ptr>::static_cast_from(n->next_);  }
 
-   static void set_next(node_ptr n, node_ptr next)
+   BOOST_INTRUSIVE_FORCEINLINE static void set_next(node_ptr n, node_ptr next)
    {  n->next_ = next;  }
 
-   static node_ptr get_prev_in_group(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_prev_in_group(const const_node_ptr & n)
    {  return n->prev_in_group_;  }
 
-   static void set_prev_in_group(node_ptr n, node_ptr prev)
+   BOOST_INTRUSIVE_FORCEINLINE static void set_prev_in_group(node_ptr n, node_ptr prev)
    {  n->prev_in_group_ = prev;  }
 
-   static std::size_t get_hash(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static std::size_t get_hash(const const_node_ptr & n)
    {  return n->hash_;  }
 
-   static void set_hash(const node_ptr & n, std::size_t h)
+   BOOST_INTRUSIVE_FORCEINLINE static void set_hash(const node_ptr & n, std::size_t h)
    {  n->hash_ = h;  }
 };
 
@@ -127,19 +127,19 @@ struct unordered_algorithms
    typedef typename NodeTraits::node_ptr           node_ptr;
    typedef typename NodeTraits::const_node_ptr     const_node_ptr;
 
-   static void init(typename base_type::node_ptr n)
+   BOOST_INTRUSIVE_FORCEINLINE static void init(typename base_type::node_ptr n)
    {
       base_type::init(n);
       group_algorithms::init(n);
    }
 
-   static void init_header(typename base_type::node_ptr n)
+   BOOST_INTRUSIVE_FORCEINLINE static void init_header(typename base_type::node_ptr n)
    {
       base_type::init_header(n);
       group_algorithms::init_header(n);
    }
 
-   static void unlink(typename base_type::node_ptr n)
+   BOOST_INTRUSIVE_FORCEINLINE static void unlink(typename base_type::node_ptr n)
    {
       base_type::unlink(n);
       group_algorithms::unlink(n);