passenger 5.1.4 → 5.1.5

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

@@ -11,13 +11,22 @@
 #ifndef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_CALLABLE_WITH_HPP
 #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_CALLABLE_WITH_HPP
 
-//Mark that we don't support 0 arg calls due to compiler ICE in GCC 3.4/4.0/4.1 and
-//wrong SFINAE for GCC 4.2/4.3
-#if defined(__GNUC__) && !defined(__clang__) && ((__GNUC__*100 + __GNUC_MINOR__*10) >= 340) && ((__GNUC__*100 + __GNUC_MINOR__*10) <= 430)
-   #define BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED
-#elif defined(BOOST_INTEL) && (BOOST_INTEL < 1200 )
-   #define BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
 #endif
+
+//In case no decltype and no variadics, mark that we don't support 0 arg calls due to
+//compiler ICE in GCC 3.4/4.0/4.1 and, wrong SFINAE for GCC 4.2/4.3/MSVC10/MSVC11
+#if defined(BOOST_NO_CXX11_DECLTYPE) && defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#  if defined(BOOST_GCC) && (BOOST_GCC < 40400)
+#     define BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED
+#  elif defined(BOOST_INTEL) && (BOOST_INTEL < 1200)
+#     define BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED
+#  elif defined(BOOST_MSVC) && (BOOST_MSVC < 1800)
+#     define BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED
+#  endif
+#endif   //#if defined(BOOST_NO_CXX11_DECLTYPE) && defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+
 #include <cstddef>
 #include <boost/move/utility_core.hpp>
 #include <boost/move/detail/fwd_macros.hpp>
@@ -27,6 +36,11 @@ namespace boost_intrusive_hmfcw {
 typedef char yes_type;
 struct no_type{ char dummy[2]; };
 
+struct dont_care
+{
+   dont_care(...);
+};
+
 #if defined(BOOST_NO_CXX11_DECLTYPE)
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
@@ -39,11 +53,6 @@ struct make_dontcare
 
 #endif
 
-struct dont_care
-{
-   dont_care(...);
-};
-
 struct private_type
 {
    static private_type p;
@@ -56,7 +65,7 @@ yes_type is_private_type(private_type const &);
 
 #endif   //#if defined(BOOST_NO_CXX11_DECLTYPE)
 
-#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_NO_CXX11_DECLTYPE)
 
 template<typename T> struct remove_cv                    {  typedef T type;   };
 template<typename T> struct remove_cv<const T>           {  typedef T type;   };
@@ -124,7 +133,31 @@ BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG
    //    declaration, special case and 0 arg specializaton
    //
    /////////////////////////////////////////////////////////
-   /////////////////////////////////////////////////////////
+
+   template <typename Type>
+   class BOOST_MOVE_CAT(has_member_function_named_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
+   {
+      struct BaseMixin
+      {
+         void BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME()
+         {} //Some compilers require the definition or linker errors happen
+      };
+
+      struct Base
+         : public boost_intrusive_hmfcw::remove_cv<Type>::type, public BaseMixin
+      {  //Declare the unneeded default constructor as some old compilers wrongly require it with is_convertible
+         Base(){}
+      };
+      template <typename T, T t> class Helper{};
+
+      template <typename U>
+      static boost_intrusive_hmfcw::no_type  deduce
+         (U*, Helper<void (BaseMixin::*)(), &U::BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME>* = 0);
+      static boost_intrusive_hmfcw::yes_type deduce(...);
+
+      public:
+      static const bool value = sizeof(boost_intrusive_hmfcw::yes_type) == sizeof(deduce((Base*)0));
+   };
 
    #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
       /////////////////////////////////////////////////////////
@@ -136,52 +169,45 @@ BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG
       /////////////////////////////////////////////////////////
 
       //defined(BOOST_NO_CXX11_DECLTYPE) must be true
-      template<class Fun, class ...DontCares>
+      template<class Fun>
       struct FunWrapTmpl : Fun
       {
          using Fun::BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME;
+         FunWrapTmpl();
+         template<class ...DontCares>
          boost_intrusive_hmfcw::private_type BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME(DontCares...) const;
       };
 
+      template<typename Fun, bool HasFunc, class ...Args>
+      struct BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME);
+
+      //No BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME member specialization
       template<typename Fun, class ...Args>
-      struct BOOST_MOVE_CAT(has_member_function_callable_with_,BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<Fun, Args...>
+      struct BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
+         <Fun, false, Args...>
       {
-         typedef FunWrapTmpl<typename boost_intrusive_hmfcw::make_dontcare<Args>::type...> FunWrap;
+         static const bool value = false;
+      };
 
-         static bool const value = (sizeof(boost_intrusive_hmfcw::no_type) ==
-                                    sizeof(boost_intrusive_hmfcw::is_private_type
-                                             ( (::boost::move_detail::declval< FunWrap<Fun> >().
+      template<typename Fun, class ...Args>
+      struct BOOST_MOVE_CAT(has_member_function_callable_with_impl_,BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<Fun, true, Args...>
+      {
+         static bool const value = (sizeof(boost_intrusive_hmfcw::no_type) == sizeof(boost_intrusive_hmfcw::is_private_type
+                                             ( (::boost::move_detail::declval
+                                                   < FunWrapTmpl<Fun> >().
                                                    BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME(::boost::move_detail::declval<Args>()...), 0) )
                                           )
                                     );
       };
-   #else //defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-
-      //Preprocessor must be used to generate specializations instead of variadic templates
 
-      template <typename Type>
-      class BOOST_MOVE_CAT(has_member_function_named_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
-      {
-         struct BaseMixin
-         {
-            void BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME();
-         };
-
-         struct Base
-            : public boost_intrusive_hmfcw::remove_cv<Type>::type, public BaseMixin
-         {  //Declare the unneeded default constructor as some old compilers wrongly require it with is_convertible
-            Base();
-         };
-         template <typename T, T t> class Helper{};
-
-         template <typename U>
-         static boost_intrusive_hmfcw::no_type  deduce
-            (U*, Helper<void (BaseMixin::*)(), &U::BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME>* = 0);
-         static boost_intrusive_hmfcw::yes_type deduce(...);
-
-         public:
-         static const bool value = sizeof(boost_intrusive_hmfcw::yes_type) == sizeof(deduce((Base*)0));
-      };
+      template<typename Fun, class ...Args>
+      struct BOOST_MOVE_CAT(has_member_function_callable_with_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
+         : public BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
+            <Fun
+            , BOOST_MOVE_CAT(has_member_function_named_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<Fun>::value
+            , Args...>
+      {};
+   #else //defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
       /////////////////////////////////////////////////////////
       /////////////////////////////////////////////////////////
@@ -221,24 +247,24 @@ BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG
 
             #if !defined(BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED)
 
-            template<class F, std::size_t N = sizeof(boost::move_detail::declval<F>().BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME(), 0)>
-            struct BOOST_MOVE_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
-            {  boost_intrusive_hmfcw::yes_type dummy[N ? 1 : 2];   };
+               template<class F, std::size_t N = sizeof(boost::move_detail::declval<F>().BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME(), 0)>
+               struct BOOST_MOVE_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
+               {  boost_intrusive_hmfcw::yes_type dummy[N ? 1 : 2];   };
 
-            template<typename Fun>
-            struct BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<Fun, true>
-            {
-               template<class U> static BOOST_MOVE_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<U>
-                  Test(BOOST_MOVE_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<U>*);
-               template<class U> static boost_intrusive_hmfcw::no_type Test(...);
-               static const bool value = sizeof(Test< Fun >(0)) == sizeof(boost_intrusive_hmfcw::yes_type);
-            };
+               template<typename Fun>
+               struct BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<Fun, true>
+               {
+                  template<class U> static BOOST_MOVE_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<U>
+                     Test(BOOST_MOVE_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<U>*);
+                  template<class U> static boost_intrusive_hmfcw::no_type Test(...);
+                  static const bool value = sizeof(Test< Fun >(0)) == sizeof(boost_intrusive_hmfcw::yes_type);
+               };
 
             #else //defined(BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED)
 
                template<typename Fun>
                struct BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<Fun, true>
-               {//GCC [3.4-4.3) gives ICE when instantiating the 0 arg version so it is not supported.
+               {  //Some compilers gives ICE when instantiating the 0 arg version so it is not supported.
                   static const bool value = true;
                };
 

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

@@ -21,6 +21,7 @@
 #  pragma once
 #endif
 
+#include <boost/intrusive/detail/workaround.hpp>
 #include <boost/intrusive/detail/assert.hpp>
 #include <boost/intrusive/pointer_traits.hpp>
 #include <boost/intrusive/detail/mpl.hpp>
@@ -39,23 +40,22 @@ template <class Slist>
 struct bucket_impl : public Slist
 {
    typedef Slist slist_type;
-   bucket_impl()
+   BOOST_INTRUSIVE_FORCEINLINE bucket_impl()
    {}
 
-   bucket_impl(const bucket_impl &)
+   BOOST_INTRUSIVE_FORCEINLINE bucket_impl(const bucket_impl &)
    {}
 
-   ~bucket_impl()
+   BOOST_INTRUSIVE_FORCEINLINE ~bucket_impl()
    {
       //This bucket is still being used!
       BOOST_INTRUSIVE_INVARIANT_ASSERT(Slist::empty());
    }
 
-   bucket_impl &operator=(const bucket_impl&)
+   BOOST_INTRUSIVE_FORCEINLINE bucket_impl &operator=(const bucket_impl&)
    {
       //This bucket is still in use!
       BOOST_INTRUSIVE_INVARIANT_ASSERT(Slist::empty());
-      //Slist::clear();
       return *this;
    }
 };
@@ -76,33 +76,33 @@ struct bucket_traits_impl
    typedef typename Slist::size_type size_type;
    /// @endcond
 
-   bucket_traits_impl(bucket_ptr buckets, size_type len)
+   BOOST_INTRUSIVE_FORCEINLINE bucket_traits_impl(bucket_ptr buckets, size_type len)
       :  buckets_(buckets), buckets_len_(len)
    {}
 
-   bucket_traits_impl(const bucket_traits_impl &x)
+   BOOST_INTRUSIVE_FORCEINLINE bucket_traits_impl(const bucket_traits_impl &x)
       : buckets_(x.buckets_), buckets_len_(x.buckets_len_)
    {}
 
-   bucket_traits_impl(BOOST_RV_REF(bucket_traits_impl) x)
+   BOOST_INTRUSIVE_FORCEINLINE bucket_traits_impl(BOOST_RV_REF(bucket_traits_impl) x)
       : buckets_(x.buckets_), buckets_len_(x.buckets_len_)
    {  x.buckets_ = bucket_ptr();   x.buckets_len_ = 0;  }
 
-   bucket_traits_impl& operator=(BOOST_RV_REF(bucket_traits_impl) x)
+   BOOST_INTRUSIVE_FORCEINLINE bucket_traits_impl& operator=(BOOST_RV_REF(bucket_traits_impl) x)
    {
       buckets_ = x.buckets_; buckets_len_ = x.buckets_len_;
       x.buckets_ = bucket_ptr();   x.buckets_len_ = 0; return *this;
    }
 
-   bucket_traits_impl& operator=(BOOST_COPY_ASSIGN_REF(bucket_traits_impl) x)
+   BOOST_INTRUSIVE_FORCEINLINE bucket_traits_impl& operator=(BOOST_COPY_ASSIGN_REF(bucket_traits_impl) x)
    {
       buckets_ = x.buckets_;  buckets_len_ = x.buckets_len_; return *this;
    }
 
-   const bucket_ptr &bucket_begin() const
+   BOOST_INTRUSIVE_FORCEINLINE const bucket_ptr &bucket_begin() const
    {  return buckets_;  }
 
-   size_type  bucket_count() const
+   BOOST_INTRUSIVE_FORCEINLINE size_type  bucket_count() const
    {  return buckets_len_;  }
 
    private:
@@ -160,11 +160,11 @@ class hashtable_iterator
    typedef iiterator< value_traits, IsConst
                     , std::forward_iterator_tag>   types_t;
    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;
 
    private:
    typedef typename value_traits::node_traits                  node_traits;
@@ -181,7 +181,7 @@ class hashtable_iterator
          < const BucketValueTraits >::type                     const_bucketvaltraits_ptr;
    typedef typename slist_impl::size_type                      size_type;
 
-   static node_ptr downcast_bucket(typename bucket_type::node_ptr p)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr downcast_bucket(typename bucket_type::node_ptr p)
    {
       return pointer_traits<node_ptr>::
          pointer_to(static_cast<typename node_traits::node&>(*p));
@@ -189,7 +189,7 @@ class hashtable_iterator
 
    public:
 
-   hashtable_iterator ()
+   BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator ()
       : slist_it_()  //Value initialization to achieve "null iterators" (N3644)
    {}
 
@@ -198,17 +198,17 @@ class hashtable_iterator
       , traitsptr_ (cont ? pointer_traits<const_bucketvaltraits_ptr>::pointer_to(*cont) : const_bucketvaltraits_ptr() )
    {}
 
-   hashtable_iterator(const hashtable_iterator<BucketValueTraits, false> &other)
+   BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator(const hashtable_iterator<BucketValueTraits, false> &other)
       :  slist_it_(other.slist_it()), traitsptr_(other.get_bucket_value_traits())
    {}
 
-   const siterator &slist_it() const
+   BOOST_INTRUSIVE_FORCEINLINE const siterator &slist_it() const
    { return slist_it_; }
 
-   hashtable_iterator<BucketValueTraits, false> unconst() const
+   BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator<BucketValueTraits, false> unconst() const
    {  return hashtable_iterator<BucketValueTraits, false>(this->slist_it(), this->get_bucket_value_traits());   }
 
-   hashtable_iterator& operator++()
+   BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator& operator++()
    {  this->increment();   return *this;   }
 
    hashtable_iterator operator++(int)
@@ -218,28 +218,28 @@ class hashtable_iterator
       return result;
    }
 
-   friend bool operator== (const hashtable_iterator& i, const hashtable_iterator& i2)
+   BOOST_INTRUSIVE_FORCEINLINE friend bool operator== (const hashtable_iterator& i, const hashtable_iterator& i2)
    { return i.slist_it_ == i2.slist_it_; }
 
-   friend bool operator!= (const hashtable_iterator& i, const hashtable_iterator& i2)
+   BOOST_INTRUSIVE_FORCEINLINE friend bool operator!= (const hashtable_iterator& i, const hashtable_iterator& i2)
    { return !(i == i2); }
 
-   reference operator*() const
+   BOOST_INTRUSIVE_FORCEINLINE reference operator*() const
    { return *this->operator ->(); }
 
-   pointer operator->() const
+   BOOST_INTRUSIVE_FORCEINLINE pointer operator->() const
    {
       return this->priv_value_traits().to_value_ptr
          (downcast_bucket(slist_it_.pointed_node()));
    }
 
-   const const_bucketvaltraits_ptr &get_bucket_value_traits() const
+   BOOST_INTRUSIVE_FORCEINLINE const const_bucketvaltraits_ptr &get_bucket_value_traits() const
    {  return traitsptr_;  }
 
-   const value_traits &priv_value_traits() const
+   BOOST_INTRUSIVE_FORCEINLINE const value_traits &priv_value_traits() const
    {  return traitsptr_->priv_value_traits();  }
 
-   const bucket_traits &priv_bucket_traits() const
+   BOOST_INTRUSIVE_FORCEINLINE const bucket_traits &priv_bucket_traits() const
    {  return traitsptr_->priv_bucket_traits();  }
 
    private:

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

@@ -21,6 +21,7 @@
 #  pragma once
 #endif
 
+#include <boost/intrusive/detail/workaround.hpp>
 #include <boost/intrusive/pointer_traits.hpp>
 #include <boost/intrusive/detail/parent_from_member.hpp>
 #include <boost/intrusive/link_mode.hpp>
@@ -54,25 +55,25 @@ struct bhtraits_base
    typedef node&                                                     node_reference;
    typedef const node &                                              const_node_reference;
 
-   static pointer to_value_ptr(const node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static pointer to_value_ptr(const node_ptr & n)
    {
       return pointer_traits<pointer>::pointer_to
          (static_cast<reference>(static_cast<node_holder_reference>(*n)));
    }
 
-   static const_pointer to_value_ptr(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static const_pointer to_value_ptr(const const_node_ptr & n)
    {
       return pointer_traits<const_pointer>::pointer_to
          (static_cast<const_reference>(static_cast<const_node_holder_reference>(*n)));
    }
 
-   static node_ptr to_node_ptr(reference value)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr to_node_ptr(reference value)
    {
       return pointer_traits<node_ptr>::pointer_to
          (static_cast<node_reference>(static_cast<node_holder_reference>(value)));
    }
 
-   static const_node_ptr to_node_ptr(const_reference value)
+   BOOST_INTRUSIVE_FORCEINLINE static const_node_ptr to_node_ptr(const_reference value)
    {
       return pointer_traits<const_node_ptr>::pointer_to
          (static_cast<const_node_reference>(static_cast<const_node_holder_reference>(value)));
@@ -111,26 +112,26 @@ struct mhtraits
 
    static const link_mode_type link_mode = Hook::hooktags::link_mode;
 
-   static node_ptr to_node_ptr(reference value)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr to_node_ptr(reference value)
    {
       return pointer_traits<node_ptr>::pointer_to
          (static_cast<node_reference>(static_cast<hook_reference>(value.*P)));
    }
 
-   static const_node_ptr to_node_ptr(const_reference value)
+   BOOST_INTRUSIVE_FORCEINLINE static const_node_ptr to_node_ptr(const_reference value)
    {
       return pointer_traits<const_node_ptr>::pointer_to
          (static_cast<const_node_reference>(static_cast<const_hook_reference>(value.*P)));
    }
 
-   static pointer to_value_ptr(const node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static pointer to_value_ptr(const node_ptr & n)
    {
       return pointer_traits<pointer>::pointer_to
          (*detail::parent_from_member<T, Hook>
             (static_cast<Hook*>(boost::intrusive::detail::to_raw_pointer(n)), P));
    }
 
-   static const_pointer to_value_ptr(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static const_pointer to_value_ptr(const const_node_ptr & n)
    {
       return pointer_traits<const_pointer>::pointer_to
          (*detail::parent_from_member<T, Hook>

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

@@ -21,6 +21,7 @@
 #  pragma once
 #endif
 
+#include <boost/intrusive/detail/workaround.hpp>
 #include <boost/intrusive/detail/iterator.hpp>
 #include <boost/intrusive/pointer_traits.hpp>
 #include <boost/intrusive/detail/mpl.hpp>
@@ -70,7 +71,7 @@ struct iiterator
          , difference_type
          , pointer
          , reference
-         > iterator_traits;
+         > iterator_type;
    typedef typename value_traits_pointers
       <ValueTraits>::value_traits_ptr                          value_traits_ptr;
    typedef typename value_traits_pointers
@@ -83,15 +84,15 @@ template<class NodePtr, class StoredPointer, bool StatefulValueTraits = true>
 struct iiterator_members
 {
 
-   iiterator_members()
+   BOOST_INTRUSIVE_FORCEINLINE iiterator_members()
       : nodeptr_()//Value initialization to achieve "null iterators" (N3644)
    {}
 
-   iiterator_members(const NodePtr &n_ptr, const StoredPointer &data)
+   BOOST_INTRUSIVE_FORCEINLINE iiterator_members(const NodePtr &n_ptr, const StoredPointer &data)
       :  nodeptr_(n_ptr), ptr_(data)
    {}
 
-   StoredPointer get_ptr() const
+   BOOST_INTRUSIVE_FORCEINLINE StoredPointer get_ptr() const
    {  return ptr_;  }
 
    NodePtr nodeptr_;
@@ -101,15 +102,15 @@ struct iiterator_members
 template<class NodePtr, class StoredPointer>
 struct iiterator_members<NodePtr, StoredPointer, false>
 {
-   iiterator_members()
+   BOOST_INTRUSIVE_FORCEINLINE iiterator_members()
       : nodeptr_()//Value initialization to achieve "null iterators" (N3644)
    {}
 
-   iiterator_members(const NodePtr &n_ptr, const StoredPointer &)
+   BOOST_INTRUSIVE_FORCEINLINE iiterator_members(const NodePtr &n_ptr, const StoredPointer &)
       : nodeptr_(n_ptr)
    {}
 
-   StoredPointer get_ptr() const
+   BOOST_INTRUSIVE_FORCEINLINE StoredPointer get_ptr() const
    {  return StoredPointer();  }
 
    NodePtr nodeptr_;