passenger 6.0.20 → 6.0.21

data/src/cxx_supportlib/vendor-modified/boost/container/detail/advanced_insert_int.hpp

@@ -49,19 +49,19 @@ struct move_insert_range_proxy
 {
    typedef typename allocator_traits<Allocator>::value_type value_type;
 
-   BOOST_CONTAINER_FORCEINLINE explicit move_insert_range_proxy(FwdIt first)
+   inline explicit move_insert_range_proxy(FwdIt first)
       :  first_(first)
    {}
 
    template<class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
+   inline void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
    {
       this->first_ = ::boost::container::uninitialized_move_alloc_n_source
          (a, this->first_, n, p);
    }
 
    template<class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, std::size_t n)
+   inline void copy_n_and_update(Allocator &, Iterator p, std::size_t n)
    {
       this->first_ = ::boost::container::move_n_source(this->first_, n, p);
    }
@@ -75,18 +75,18 @@ struct insert_range_proxy
 {
    typedef typename allocator_traits<Allocator>::value_type value_type;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_range_proxy(FwdIt first)
+   inline explicit insert_range_proxy(FwdIt first)
       :  first_(first)
    {}
 
    template<class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
+   inline void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
    {
       this->first_ = ::boost::container::uninitialized_copy_alloc_n_source(a, this->first_, n, p);
    }
 
    template<class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, std::size_t n)
+   inline void copy_n_and_update(Allocator &, Iterator p, std::size_t n)
    {
       this->first_ = ::boost::container::copy_n_source(this->first_, n, p);
    }
@@ -100,16 +100,16 @@ struct insert_n_copies_proxy
 {
    typedef typename allocator_traits<Allocator>::value_type value_type;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_n_copies_proxy(const value_type &v)
+   inline explicit insert_n_copies_proxy(const value_type &v)
       :  v_(v)
    {}
 
    template<class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
+   inline void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
    {  boost::container::uninitialized_fill_alloc_n(a, v_, n, p);  }
 
    template<class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, std::size_t n) const
+   inline void copy_n_and_update(Allocator &, Iterator p, std::size_t n) const
    {
       while (n){
          --n;
@@ -129,7 +129,7 @@ struct insert_value_initialized_n_proxy
    typedef typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type storage_t;
 
    template<class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
+   inline void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
    {  boost::container::uninitialized_value_init_alloc_n(a, n, p);  }
 
    template<class Iterator>
@@ -155,7 +155,7 @@ struct insert_default_initialized_n_proxy
    typedef typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type storage_t;
 
    template<class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
+   inline void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
    {  boost::container::uninitialized_default_init_alloc_n(a, n, p);  }
 
    template<class Iterator>
@@ -183,19 +183,19 @@ struct insert_copy_proxy
 
    static const bool single_value = true;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_copy_proxy(const value_type &v)
+   inline explicit insert_copy_proxy(const value_type &v)
       :  v_(v)
    {}
 
    template<class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
+   inline void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
    {
       BOOST_ASSERT(n == 1);  (void)n;
       alloc_traits::construct( a, boost::movelib::iterator_to_raw_pointer(p), v_);
    }
 
    template<class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, std::size_t n) const
+   inline void copy_n_and_update(Allocator &, Iterator p, std::size_t n) const
    {
       BOOST_ASSERT(n == 1);  (void)n;
       *p = v_;
@@ -213,19 +213,19 @@ struct insert_move_proxy
 
    static const bool single_value = true;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_move_proxy(value_type &v)
+   inline explicit insert_move_proxy(value_type &v)
       :  v_(v)
    {}
 
    template<class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
+   inline void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
    {
       BOOST_ASSERT(n == 1);  (void)n;
       alloc_traits::construct( a, boost::movelib::iterator_to_raw_pointer(p), ::boost::move(v_) );
    }
 
    template<class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, std::size_t n) const
+   inline void copy_n_and_update(Allocator &, Iterator p, std::size_t n) const
    {
       BOOST_ASSERT(n == 1);  (void)n;
       *p = ::boost::move(v_);
@@ -235,13 +235,13 @@ struct insert_move_proxy
 };
 
 template<class It, class Allocator>
-BOOST_CONTAINER_FORCEINLINE insert_move_proxy<Allocator> get_insert_value_proxy(BOOST_RV_REF(typename boost::container::iterator_traits<It>::value_type) v)
+inline insert_move_proxy<Allocator> get_insert_value_proxy(BOOST_RV_REF(typename boost::container::iterator_traits<It>::value_type) v)
 {
    return insert_move_proxy<Allocator>(v);
 }
 
 template<class It, class Allocator>
-BOOST_CONTAINER_FORCEINLINE insert_copy_proxy<Allocator> get_insert_value_proxy(const typename boost::container::iterator_traits<It>::value_type &v)
+inline insert_copy_proxy<Allocator> get_insert_value_proxy(const typename boost::container::iterator_traits<It>::value_type &v)
 {
    return insert_copy_proxy<Allocator>(v);
 }
@@ -266,17 +266,17 @@ struct insert_nonmovable_emplace_proxy
 
    static const bool single_value = true;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_nonmovable_emplace_proxy(BOOST_FWD_REF(Args)... args)
+   inline explicit insert_nonmovable_emplace_proxy(BOOST_FWD_REF(Args)... args)
       : args_(args...)
    {}
 
    template<class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
+   inline void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
    {  this->priv_uninitialized_copy_some_and_update(a, index_tuple_t(), p, n);  }
 
    private:
    template<std::size_t ...IdxPack, class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void priv_uninitialized_copy_some_and_update(Allocator &a, const index_tuple<IdxPack...>&, Iterator p, std::size_t n)
+   inline void priv_uninitialized_copy_some_and_update(Allocator &a, const index_tuple<IdxPack...>&, Iterator p, std::size_t n)
    {
       BOOST_ASSERT(n == 1); (void)n;
       alloc_traits::construct( a, boost::movelib::iterator_to_raw_pointer(p), ::boost::forward<Args>(get<IdxPack>(this->args_))... );
@@ -297,18 +297,18 @@ struct insert_emplace_proxy
 
    static const bool single_value = true;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy(BOOST_FWD_REF(Args)... args)
+   inline explicit insert_emplace_proxy(BOOST_FWD_REF(Args)... args)
       : base_t(::boost::forward<Args>(args)...)
    {}
 
    template<class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
+   inline void copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
    {  this->priv_copy_some_and_update(a, index_tuple_t(), p, n);  }
 
    private:
 
    template<std::size_t ...IdxPack, class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void priv_copy_some_and_update(Allocator &a, const index_tuple<IdxPack...>&, Iterator p, std::size_t n)
+   inline void priv_copy_some_and_update(Allocator &a, const index_tuple<IdxPack...>&, Iterator p, std::size_t n)
    {
       BOOST_ASSERT(n ==1); (void)n;
       typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;
@@ -333,7 +333,7 @@ struct insert_emplace_proxy<Allocator, typename boost::container::allocator_trai
 {
    static const bool single_value = true;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy(typename boost::container::allocator_traits<Allocator>::value_type &&v)
+   inline explicit insert_emplace_proxy(typename boost::container::allocator_traits<Allocator>::value_type &&v)
    : insert_move_proxy<Allocator>(v)
    {}
 };
@@ -350,7 +350,7 @@ struct insert_emplace_proxy<Allocator
 
    static const bool single_value = true;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy(const typename boost::container::allocator_traits<Allocator>::value_type &v)
+   inline explicit insert_emplace_proxy(const typename boost::container::allocator_traits<Allocator>::value_type &v)
    : insert_copy_proxy<Allocator>(v)
    {}
 };
@@ -361,7 +361,7 @@ struct insert_emplace_proxy<Allocator, typename boost::container::allocator_trai
 {
    static const bool single_value = true;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy(const typename boost::container::allocator_traits<Allocator>::value_type &v)
+   inline explicit insert_emplace_proxy(const typename boost::container::allocator_traits<Allocator>::value_type &v)
    : insert_copy_proxy<Allocator>(v)
    {}
 };
@@ -374,7 +374,7 @@ struct insert_emplace_proxy<Allocator
 {
    static const bool single_value = true;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy(const typename boost::container::allocator_traits<Allocator>::value_type &v)
+   inline explicit insert_emplace_proxy(const typename boost::container::allocator_traits<Allocator>::value_type &v)
    : insert_copy_proxy<Allocator>(v)
    {}
 };
@@ -398,18 +398,18 @@ struct insert_nonmovable_emplace_proxy##N\
    \
    static const bool single_value = true;\
    \
-   BOOST_CONTAINER_FORCEINLINE explicit insert_nonmovable_emplace_proxy##N(BOOST_MOVE_UREF##N)\
+   inline explicit insert_nonmovable_emplace_proxy##N(BOOST_MOVE_UREF##N)\
       BOOST_MOVE_COLON##N BOOST_MOVE_FWD_INIT##N {}\
    \
    template<class Iterator>\
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)\
+   inline void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)\
    {\
       BOOST_ASSERT(n == 1); (void)n;\
       alloc_traits::construct(a, boost::movelib::iterator_to_raw_pointer(p) BOOST_MOVE_I##N BOOST_MOVE_MFWD##N);\
    }\
    \
    template<class Iterator>\
-   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator, std::size_t)\
+   inline void copy_n_and_update(Allocator &, Iterator, std::size_t)\
    {  BOOST_ASSERT(false);   }\
    \
    protected:\
@@ -427,11 +427,11 @@ struct insert_emplace_proxy_arg##N\
    \
    static const bool single_value = true;\
    \
-   BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy_arg##N(BOOST_MOVE_UREF##N)\
+   inline explicit insert_emplace_proxy_arg##N(BOOST_MOVE_UREF##N)\
       : base_t(BOOST_MOVE_FWD##N){}\
    \
    template<class Iterator>\
-   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &a, Iterator p, std::size_t n)\
+   inline void copy_n_and_update(Allocator &a, Iterator p, std::size_t n)\
    {\
       BOOST_ASSERT(n == 1); (void)n;\
       typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;\
@@ -461,7 +461,7 @@ struct insert_emplace_proxy_arg1<Allocator, ::boost::rv<typename boost::containe
 {
    static const bool single_value = true;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy_arg1(typename boost::container::allocator_traits<Allocator>::value_type &v)
+   inline explicit insert_emplace_proxy_arg1(typename boost::container::allocator_traits<Allocator>::value_type &v)
    : insert_move_proxy<Allocator>(v)
    {}
 };
@@ -472,7 +472,7 @@ struct insert_emplace_proxy_arg1<Allocator, typename boost::container::allocator
 {
    static const bool single_value = true;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy_arg1(const typename boost::container::allocator_traits<Allocator>::value_type &v)
+   inline explicit insert_emplace_proxy_arg1(const typename boost::container::allocator_traits<Allocator>::value_type &v)
    : insert_copy_proxy<Allocator>(v)
    {}
 };
@@ -486,7 +486,7 @@ struct insert_emplace_proxy_arg1<Allocator, typename boost::container::allocator
 {
    static const bool single_value = true;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy_arg1(typename boost::container::allocator_traits<Allocator>::value_type &&v)
+   inline explicit insert_emplace_proxy_arg1(typename boost::container::allocator_traits<Allocator>::value_type &&v)
    : insert_move_proxy<Allocator>(v)
    {}
 };
@@ -502,7 +502,7 @@ struct insert_emplace_proxy_arg1<Allocator
 {
    static const bool single_value = true;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy_arg1(const typename boost::container::allocator_traits<Allocator>::value_type &v)
+   inline explicit insert_emplace_proxy_arg1(const typename boost::container::allocator_traits<Allocator>::value_type &v)
    : insert_copy_proxy<Allocator>(v)
    {}
 };
@@ -513,7 +513,7 @@ struct insert_emplace_proxy_arg1<Allocator, typename boost::container::allocator
 {
    static const bool single_value = true;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy_arg1(const typename boost::container::allocator_traits<Allocator>::value_type &v)
+   inline explicit insert_emplace_proxy_arg1(const typename boost::container::allocator_traits<Allocator>::value_type &v)
    : insert_copy_proxy<Allocator>(v)
    {}
 };
@@ -526,7 +526,7 @@ struct insert_emplace_proxy_arg1<Allocator
 {
    static const bool single_value = true;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy_arg1(const typename boost::container::allocator_traits<Allocator>::value_type &v)
+   inline explicit insert_emplace_proxy_arg1(const typename boost::container::allocator_traits<Allocator>::value_type &v)
    : insert_copy_proxy<Allocator>(v)
    {}
 };

data/src/cxx_supportlib/vendor-modified/boost/container/detail/alloc_helpers.hpp

@@ -27,30 +27,30 @@ namespace container {
 namespace dtl {
 
 template<class AllocatorType>
-BOOST_CONTAINER_FORCEINLINE void swap_alloc(AllocatorType &, AllocatorType &, dtl::false_type)
+inline void swap_alloc(AllocatorType &, AllocatorType &, dtl::false_type)
    BOOST_NOEXCEPT_OR_NOTHROW
 {}
 
 template<class AllocatorType>
-BOOST_CONTAINER_FORCEINLINE void swap_alloc(AllocatorType &l, AllocatorType &r, dtl::true_type)
+inline void swap_alloc(AllocatorType &l, AllocatorType &r, dtl::true_type)
 {  boost::adl_move_swap(l, r);   }
 
 template<class AllocatorType>
-BOOST_CONTAINER_FORCEINLINE void assign_alloc(AllocatorType &, const AllocatorType &, dtl::false_type)
+inline void assign_alloc(AllocatorType &, const AllocatorType &, dtl::false_type)
    BOOST_NOEXCEPT_OR_NOTHROW
 {}
 
 template<class AllocatorType>
-BOOST_CONTAINER_FORCEINLINE void assign_alloc(AllocatorType &l, const AllocatorType &r, dtl::true_type)
+inline void assign_alloc(AllocatorType &l, const AllocatorType &r, dtl::true_type)
 {  l = r;   }
 
 template<class AllocatorType>
-BOOST_CONTAINER_FORCEINLINE void move_alloc(AllocatorType &, AllocatorType &, dtl::false_type)
+inline void move_alloc(AllocatorType &, AllocatorType &, dtl::false_type)
    BOOST_NOEXCEPT_OR_NOTHROW
 {}
 
 template<class AllocatorType>
-BOOST_CONTAINER_FORCEINLINE void move_alloc(AllocatorType &l, AllocatorType &r, dtl::true_type)
+inline void move_alloc(AllocatorType &l, AllocatorType &r, dtl::true_type)
 {  l = ::boost::move(r);   }
 
 }  //namespace dtl {

data/src/cxx_supportlib/vendor-modified/boost/container/detail/allocator_version_traits.hpp

@@ -46,19 +46,19 @@ struct allocator_version_traits
    typedef typename boost::container::allocator_traits<Allocator>::size_type  size_type;
 
    //Node allocation interface
-   BOOST_CONTAINER_FORCEINLINE static pointer allocate_one(Allocator &a)
+   inline static pointer allocate_one(Allocator &a)
    {  return a.allocate_one();   }
 
-   BOOST_CONTAINER_FORCEINLINE static void deallocate_one(Allocator &a, const pointer &p)
+   inline static void deallocate_one(Allocator &a, const pointer &p)
    {  a.deallocate_one(p);   }
 
-   BOOST_CONTAINER_FORCEINLINE static void allocate_individual(Allocator &a, size_type n, multiallocation_chain &m)
+   inline static void allocate_individual(Allocator &a, size_type n, multiallocation_chain &m)
    {  return a.allocate_individual(n, m);   }
 
-   BOOST_CONTAINER_FORCEINLINE static void deallocate_individual(Allocator &a, multiallocation_chain &holder)
+   inline static void deallocate_individual(Allocator &a, multiallocation_chain &holder)
    {  a.deallocate_individual(holder);   }
 
-   BOOST_CONTAINER_FORCEINLINE static pointer allocation_command(Allocator &a, allocation_type command,
+   inline static pointer allocation_command(Allocator &a, allocation_type command,
                          size_type limit_size, size_type &prefer_in_recvd_out_size, pointer &reuse)
    {  return a.allocation_command(command, limit_size, prefer_in_recvd_out_size, reuse);  }
 };
@@ -82,10 +82,10 @@ struct allocator_version_traits<Allocator, 1>
          < multialloc_cached_counted, value_type>           multiallocation_chain;
 
    //Node allocation interface
-   BOOST_CONTAINER_FORCEINLINE static pointer allocate_one(Allocator &a)
+   inline static pointer allocate_one(Allocator &a)
    {  return a.allocate(1);   }
 
-   BOOST_CONTAINER_FORCEINLINE static void deallocate_one(Allocator &a, const pointer &p)
+   inline static void deallocate_one(Allocator &a, const pointer &p)
    {  a.deallocate(p, 1);   }
 
    static void deallocate_individual(Allocator &a, multiallocation_chain &holder)
@@ -102,17 +102,17 @@ struct allocator_version_traits<Allocator, 1>
 
    struct allocate_individual_rollback
    {
-      BOOST_CONTAINER_FORCEINLINE allocate_individual_rollback(Allocator &a, multiallocation_chain &chain)
+      inline allocate_individual_rollback(Allocator &a, multiallocation_chain &chain)
          : mr_a(a), mp_chain(&chain)
       {}
 
-      BOOST_CONTAINER_FORCEINLINE ~allocate_individual_rollback()
+      inline ~allocate_individual_rollback()
       {
          if(mp_chain)
             allocator_version_traits::deallocate_individual(mr_a, *mp_chain);
       }
 
-      BOOST_CONTAINER_FORCEINLINE void release()
+      inline void release()
       {
          mp_chain = 0;
       }

data/src/cxx_supportlib/vendor-modified/boost/container/detail/compare_functors.hpp

@@ -32,11 +32,11 @@ class equal_to_value
    const value_type &t_;
 
    public:
-   BOOST_CONTAINER_FORCEINLINE explicit equal_to_value(const value_type &t)
+   inline explicit equal_to_value(const value_type &t)
       :  t_(t)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE bool operator()(const value_type &t)const
+   inline bool operator()(const value_type &t)const
    {  return t_ == t;   }
 };
 
@@ -47,39 +47,39 @@ struct value_to_node_compare
    typedef Pred predicate_type;
    typedef Node node_type;
 
-   BOOST_CONTAINER_FORCEINLINE value_to_node_compare()
+   inline value_to_node_compare()
       : Pred()
    {}
 
-   BOOST_CONTAINER_FORCEINLINE explicit value_to_node_compare(Pred pred)
+   inline explicit value_to_node_compare(Pred pred)
       :  Pred(pred)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE Ret operator()(const Node &a, const Node &b) const
+   inline Ret operator()(const Node &a, const Node &b) const
    {  return static_cast<const Pred&>(*this)(a.get_data(), b.get_data());  }
 
-   BOOST_CONTAINER_FORCEINLINE Ret operator()(const Node &a) const
+   inline Ret operator()(const Node &a) const
    {  return static_cast<const Pred&>(*this)(a.get_data());  }
 
-   BOOST_CONTAINER_FORCEINLINE Ret operator()(const Node &a, const Node &b)
+   inline Ret operator()(const Node &a, const Node &b)
    {  return static_cast<Pred&>(*this)(a.get_data(), b.get_data());  }
 
-   BOOST_CONTAINER_FORCEINLINE Ret operator()(const Node &a)
+   inline Ret operator()(const Node &a)
    {  return static_cast<Pred&>(*this)(a.get_data());  }
 
-   BOOST_CONTAINER_FORCEINLINE predicate_type &       predicate()        { return static_cast<predicate_type&>(*this); }
-   BOOST_CONTAINER_FORCEINLINE const predicate_type & predicate()  const { return static_cast<predicate_type&>(*this); }
+   inline predicate_type &       predicate()        { return static_cast<predicate_type&>(*this); }
+   inline const predicate_type & predicate()  const { return static_cast<predicate_type&>(*this); }
 };
 
 template<class KeyPred, class KeyOfValue, class Node, class Ret = bool>
 struct key_node_pred
    :  public boost::intrusive::detail::ebo_functor_holder<KeyPred>
 {
-   BOOST_CONTAINER_FORCEINLINE explicit key_node_pred(const KeyPred &comp)
+   inline explicit key_node_pred(const KeyPred &comp)
       :  base_t(comp)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE explicit key_node_pred()
+   inline explicit key_node_pred()
    {}
 
    typedef boost::intrusive::detail::ebo_functor_holder<KeyPred> base_t;
@@ -88,42 +88,42 @@ struct key_node_pred
    typedef typename KeyOfValue::type   key_type;
 
 
-   BOOST_CONTAINER_FORCEINLINE static const key_type &key_from(const Node &n)
+   inline static const key_type &key_from(const Node &n)
    {
       return key_of_value()(n.get_data());
    }
 
    template <class T>
-   BOOST_CONTAINER_FORCEINLINE static const T &
+   inline static const T &
       key_from(const T &t)
    {  return t;  }
 
-   BOOST_CONTAINER_FORCEINLINE const key_predicate &key_pred() const
+   inline const key_predicate &key_pred() const
    {  return static_cast<const key_predicate &>(*this);  }
 
-   BOOST_CONTAINER_FORCEINLINE key_predicate &key_pred()
+   inline key_predicate &key_pred()
    {  return static_cast<key_predicate &>(*this);  }
 
-   BOOST_CONTAINER_FORCEINLINE Ret operator()(const key_type &key) const
+   inline Ret operator()(const key_type &key) const
    {  return this->key_pred()(key);  }
 
    template<class U>
-   BOOST_CONTAINER_FORCEINLINE Ret operator()(const U &nonkey) const
+   inline Ret operator()(const U &nonkey) const
    {  return this->key_pred()(this->key_from(nonkey));  }
 
-   BOOST_CONTAINER_FORCEINLINE bool operator()(const key_type &key1, const key_type &key2) const
+   inline bool operator()(const key_type &key1, const key_type &key2) const
    {  return this->key_pred()(key1, key2);  }
 
    template<class U>
-   BOOST_CONTAINER_FORCEINLINE bool operator()(const key_type &key1, const U &nonkey2) const
+   inline bool operator()(const key_type &key1, const U &nonkey2) const
    {  return this->key_pred()(key1, this->key_from(nonkey2));  }
 
    template<class U>
-   BOOST_CONTAINER_FORCEINLINE bool operator()(const U &nonkey1, const key_type &key2) const
+   inline bool operator()(const U &nonkey1, const key_type &key2) const
    {  return this->key_pred()(this->key_from(nonkey1), key2);  }
 
    template<class U, class V>
-   BOOST_CONTAINER_FORCEINLINE bool operator()(const U &nonkey1, const V &nonkey2) const
+   inline bool operator()(const U &nonkey1, const V &nonkey2) const
    {  return this->key_pred()(this->key_from(nonkey1), this->key_from(nonkey2));  }
 };