passenger 6.0.20 → 6.0.21

data/src/cxx_supportlib/vendor-modified/boost/intrusive/slist.hpp

@@ -41,7 +41,6 @@
 #include <boost/intrusive/detail/node_cloner_disposer.hpp>
 
 #include <boost/move/utility_core.hpp>
-#include <boost/static_assert.hpp>
 
 #include <cstddef>   //std::size_t
 
@@ -166,53 +165,53 @@ class slist_impl
    static const bool safemode_or_autounlink = is_safe_autounlink<value_traits::link_mode>::value;
 
    //Constant-time size is incompatible with auto-unlink hooks!
-   BOOST_STATIC_ASSERT(!(constant_time_size && ((int)value_traits::link_mode == (int)auto_unlink)));
+   BOOST_INTRUSIVE_STATIC_ASSERT(!(constant_time_size && ((int)value_traits::link_mode == (int)auto_unlink)));
    //Linear singly linked lists are incompatible with auto-unlink hooks!
-   BOOST_STATIC_ASSERT(!(linear && ((int)value_traits::link_mode == (int)auto_unlink)));
+   BOOST_INTRUSIVE_STATIC_ASSERT(!(linear && ((int)value_traits::link_mode == (int)auto_unlink)));
    //A list with cached last node is incompatible with auto-unlink hooks!
-   BOOST_STATIC_ASSERT(!(cache_last && ((int)value_traits::link_mode == (int)auto_unlink)));
+   BOOST_INTRUSIVE_STATIC_ASSERT(!(cache_last && ((int)value_traits::link_mode == (int)auto_unlink)));
 
-   BOOST_INTRUSIVE_FORCEINLINE node_ptr get_end_node()
+   inline node_ptr get_end_node()
    {  return node_algorithms::end_node(this->get_root_node());  }
 
-   BOOST_INTRUSIVE_FORCEINLINE const_node_ptr get_end_node() const
+   inline const_node_ptr get_end_node() const
    {  return node_algorithms::end_node(this->get_root_node());  }
 
-   BOOST_INTRUSIVE_FORCEINLINE node_ptr get_root_node()
+   inline node_ptr get_root_node()
    { return data_.root_plus_size_.header_holder_.get_node(); }
 
-   BOOST_INTRUSIVE_FORCEINLINE const_node_ptr get_root_node() const
+   inline const_node_ptr get_root_node() const
    { return data_.root_plus_size_.header_holder_.get_node(); }
 
-   BOOST_INTRUSIVE_FORCEINLINE node_ptr get_last_node()
+   inline node_ptr get_last_node()
    {  return this->get_last_node(detail::bool_<cache_last>());  }
 
-   BOOST_INTRUSIVE_FORCEINLINE const_node_ptr get_last_node() const
+   inline const_node_ptr get_last_node() const
    {  return this->get_last_node(detail::bool_<cache_last>());  }
 
-   BOOST_INTRUSIVE_FORCEINLINE void set_last_node(node_ptr n)
+   inline void set_last_node(node_ptr n)
    {  return this->set_last_node(n, detail::bool_<cache_last>());  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_last_node(detail::bool_<false>)
+   inline static node_ptr get_last_node(detail::bool_<false>)
    {
       //This function shall not be used if cache_last is not true
       BOOST_INTRUSIVE_INVARIANT_ASSERT(cache_last);
       return node_ptr();
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE static void set_last_node(node_ptr , detail::bool_<false>)
+   inline static void set_last_node(node_ptr , detail::bool_<false>)
    {
       //This function shall not be used if cache_last is not true
       BOOST_INTRUSIVE_INVARIANT_ASSERT(cache_last);
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE node_ptr get_last_node(detail::bool_<true>)
+   inline node_ptr get_last_node(detail::bool_<true>)
    {  return node_ptr(data_.root_plus_size_.last_);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE const_node_ptr get_last_node(detail::bool_<true>) const
+   inline const_node_ptr get_last_node(detail::bool_<true>) const
    {  return const_node_ptr(data_.root_plus_size_.last_);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE void set_last_node(node_ptr n, detail::bool_<true>)
+   inline void set_last_node(node_ptr n, detail::bool_<true>)
    {  data_.root_plus_size_.last_ = n;  }
 
    void set_default_constructed_state()
@@ -241,22 +240,22 @@ class slist_impl
       root_plus_size root_plus_size_;
    } data_;
 
-   BOOST_INTRUSIVE_FORCEINLINE size_traits &priv_size_traits()
+   inline size_traits &priv_size_traits()
    {  return data_.root_plus_size_;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE const size_traits &priv_size_traits() const
+   inline const size_traits &priv_size_traits() const
    {  return data_.root_plus_size_;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE const value_traits &priv_value_traits() const
+   inline const value_traits &priv_value_traits() const
    {  return data_;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE value_traits &priv_value_traits()
+   inline value_traits &priv_value_traits()
    {  return data_;  }
 
    typedef typename boost::intrusive::value_traits_pointers
       <ValueTraits>::const_value_traits_ptr const_value_traits_ptr;
 
-   BOOST_INTRUSIVE_FORCEINLINE const_value_traits_ptr priv_value_traits_ptr() const
+   inline const_value_traits_ptr priv_value_traits_ptr() const
    {  return pointer_traits<const_value_traits_ptr>::pointer_to(this->priv_value_traits());  }
 
    /// @endcond
@@ -449,7 +448,7 @@ class slist_impl
    //!   This function is only available is cache_last<> is true.
    void push_back(reference value) BOOST_NOEXCEPT
    {
-      BOOST_STATIC_ASSERT((cache_last));
+      BOOST_INTRUSIVE_STATIC_ASSERT((cache_last));
       node_ptr n = priv_value_traits().to_node_ptr(value);
       BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!safemode_or_autounlink || node_algorithms::inited(n));
       node_algorithms::link_after(this->get_last_node(), n);
@@ -501,7 +500,7 @@ class slist_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE reference front() BOOST_NOEXCEPT
+   inline reference front() BOOST_NOEXCEPT
    { return *this->priv_value_traits().to_value_ptr(node_traits::get_next(this->get_root_node())); }
 
    //! <b>Effects</b>: Returns a const_reference to the first element of the list.
@@ -509,7 +508,7 @@ class slist_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE const_reference front() const BOOST_NOEXCEPT
+   inline const_reference front() const BOOST_NOEXCEPT
    { return *this->priv_value_traits().to_value_ptr(detail::uncast(node_traits::get_next(this->get_root_node()))); }
 
    //! <b>Effects</b>: Returns a reference to the last element of the list.
@@ -522,7 +521,7 @@ class slist_impl
    //!   This function is only available is cache_last<> is true.
    reference back() BOOST_NOEXCEPT
    {
-      BOOST_STATIC_ASSERT((cache_last));
+      BOOST_INTRUSIVE_STATIC_ASSERT((cache_last));
       return *this->priv_value_traits().to_value_ptr(this->get_last_node());
    }
 
@@ -534,9 +533,9 @@ class slist_impl
    //!
    //! <b>Note</b>: Does not affect the validity of iterators and references.
    //!   This function is only available is cache_last<> is true.
-   BOOST_INTRUSIVE_FORCEINLINE const_reference back() const BOOST_NOEXCEPT
+   inline const_reference back() const BOOST_NOEXCEPT
    {
-      BOOST_STATIC_ASSERT((cache_last));
+      BOOST_INTRUSIVE_STATIC_ASSERT((cache_last));
       return *this->priv_value_traits().to_value_ptr(this->get_last_node());
    }
 
@@ -545,7 +544,7 @@ class slist_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE iterator begin() BOOST_NOEXCEPT
+   inline iterator begin() BOOST_NOEXCEPT
    { return iterator (node_traits::get_next(this->get_root_node()), this->priv_value_traits_ptr()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the list.
@@ -553,7 +552,7 @@ class slist_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE const_iterator begin() const BOOST_NOEXCEPT
+   inline const_iterator begin() const BOOST_NOEXCEPT
    { return const_iterator (node_traits::get_next(this->get_root_node()), this->priv_value_traits_ptr()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the list.
@@ -561,7 +560,7 @@ class slist_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE const_iterator cbegin() const BOOST_NOEXCEPT
+   inline const_iterator cbegin() const BOOST_NOEXCEPT
    { return const_iterator(node_traits::get_next(this->get_root_node()), this->priv_value_traits_ptr()); }
 
    //! <b>Effects</b>: Returns an iterator to the end of the list.
@@ -569,7 +568,7 @@ class slist_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE iterator end() BOOST_NOEXCEPT
+   inline iterator end() BOOST_NOEXCEPT
    { return iterator(this->get_end_node(), this->priv_value_traits_ptr()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the list.
@@ -577,7 +576,7 @@ class slist_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE const_iterator end() const BOOST_NOEXCEPT
+   inline const_iterator end() const BOOST_NOEXCEPT
    { return const_iterator(detail::uncast(this->get_end_node()), this->priv_value_traits_ptr()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the list.
@@ -585,7 +584,7 @@ class slist_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE const_iterator cend() const BOOST_NOEXCEPT
+   inline const_iterator cend() const BOOST_NOEXCEPT
    { return this->end(); }
 
    //! <b>Effects</b>: Returns an iterator that points to a position
@@ -594,7 +593,7 @@ class slist_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE iterator before_begin() BOOST_NOEXCEPT
+   inline iterator before_begin() BOOST_NOEXCEPT
    { return iterator(this->get_root_node(), this->priv_value_traits_ptr()); }
 
    //! <b>Effects</b>: Returns an iterator that points to a position
@@ -603,7 +602,7 @@ class slist_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE const_iterator before_begin() const BOOST_NOEXCEPT
+   inline const_iterator before_begin() const BOOST_NOEXCEPT
    { return const_iterator(detail::uncast(this->get_root_node()), this->priv_value_traits_ptr()); }
 
    //! <b>Effects</b>: Returns an iterator that points to a position
@@ -612,7 +611,7 @@ class slist_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE const_iterator cbefore_begin() const BOOST_NOEXCEPT
+   inline const_iterator cbefore_begin() const BOOST_NOEXCEPT
    { return this->before_begin(); }
 
    //! <b>Effects</b>: Returns an iterator to the last element contained in the list.
@@ -622,7 +621,7 @@ class slist_impl
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Note</b>: This function is present only if cached_last<> option is true.
-   BOOST_INTRUSIVE_FORCEINLINE iterator last() BOOST_NOEXCEPT
+   inline iterator last() BOOST_NOEXCEPT
    {
       //This function shall not be used if cache_last is not true
       BOOST_INTRUSIVE_INVARIANT_ASSERT(cache_last);
@@ -636,7 +635,7 @@ class slist_impl
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Note</b>: This function is present only if cached_last<> option is true.
-   BOOST_INTRUSIVE_FORCEINLINE const_iterator last() const BOOST_NOEXCEPT
+   inline const_iterator last() const BOOST_NOEXCEPT
    {
       //This function shall not be used if cache_last is not true
       BOOST_INTRUSIVE_INVARIANT_ASSERT(cache_last);
@@ -650,7 +649,7 @@ class slist_impl
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Note</b>: This function is present only if cached_last<> option is true.
-   BOOST_INTRUSIVE_FORCEINLINE const_iterator clast() const BOOST_NOEXCEPT
+   inline const_iterator clast() const BOOST_NOEXCEPT
    { return const_iterator(this->get_last_node(), this->priv_value_traits_ptr()); }
 
    //! <b>Precondition</b>: end_iterator must be a valid end iterator
@@ -661,7 +660,7 @@ class slist_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE static slist_impl &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
+   inline static slist_impl &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
    {  return slist_impl::priv_container_from_end_iterator(end_iterator);   }
 
    //! <b>Precondition</b>: end_iterator must be a valid end const_iterator
@@ -672,7 +671,7 @@ class slist_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE static const slist_impl &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
+   inline static const slist_impl &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
    {  return slist_impl::priv_container_from_end_iterator(end_iterator);   }
 
    //! <b>Effects</b>: Returns the number of the elements contained in the list.
@@ -683,7 +682,7 @@ class slist_impl
    //!   if constant_time_size is false. Constant time otherwise.
    //!
    //! <b>Note</b>: Does not affect the validity of iterators and references.
-   BOOST_INTRUSIVE_FORCEINLINE size_type size() const BOOST_NOEXCEPT
+   inline size_type size() const BOOST_NOEXCEPT
    {
       BOOST_IF_CONSTEXPR(constant_time_size)
          return this->priv_size_traits().get_size();
@@ -698,7 +697,7 @@ class slist_impl
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Note</b>: Does not affect the validity of iterators and references.
-   BOOST_INTRUSIVE_FORCEINLINE bool empty() const BOOST_NOEXCEPT
+   inline bool empty() const BOOST_NOEXCEPT
    {  return node_algorithms::is_empty(this->get_root_node()); }
 
    //! <b>Effects</b>: Swaps the elements of x and *this.
@@ -1061,7 +1060,7 @@ class slist_impl
 
    static iterator s_insert_after(const_iterator const prev_p, reference value) BOOST_NOEXCEPT
    {
-      BOOST_STATIC_ASSERT(((!cache_last)&&(!constant_time_size)&&(!stateful_value_traits)));
+      BOOST_INTRUSIVE_STATIC_ASSERT(((!cache_last)&&(!constant_time_size)&&(!stateful_value_traits)));
       node_ptr const n = value_traits::to_node_ptr(value);
       BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!safemode_or_autounlink || node_algorithms::inited(n));
       node_algorithms::link_after(prev_p.pointed_node(), n);
@@ -1071,7 +1070,7 @@ class slist_impl
    template<class Disposer>
    static iterator s_erase_after_and_dispose(const_iterator prev, Disposer disposer) BOOST_NOEXCEPT
    {
-      BOOST_STATIC_ASSERT(((!cache_last)&&(!constant_time_size)&&(!stateful_value_traits)));
+      BOOST_INTRUSIVE_STATIC_ASSERT(((!cache_last)&&(!constant_time_size)&&(!stateful_value_traits)));
       const_iterator it(prev);
       ++it;
       node_ptr to_erase(it.pointed_node());
@@ -1087,7 +1086,7 @@ class slist_impl
    template<class Disposer>
    static iterator s_erase_after_and_dispose(const_iterator before_f, const_iterator l, Disposer disposer) BOOST_NOEXCEPT
    {
-      BOOST_STATIC_ASSERT(((!cache_last)&&(!constant_time_size)&&(!stateful_value_traits)));
+      BOOST_INTRUSIVE_STATIC_ASSERT(((!cache_last)&&(!constant_time_size)&&(!stateful_value_traits)));
       node_ptr bfp(before_f.pointed_node()), lp(l.pointed_node());
       node_ptr fp(node_traits::get_next(bfp));
       node_algorithms::unlink_after(bfp, lp);
@@ -1754,7 +1753,7 @@ class slist_impl
    //!   is stateless.
    static iterator s_iterator_to(reference value) BOOST_NOEXCEPT
    {
-      BOOST_STATIC_ASSERT((!stateful_value_traits));
+      BOOST_INTRUSIVE_STATIC_ASSERT((!stateful_value_traits));
       return iterator (value_traits::to_node_ptr(value), const_value_traits_ptr());
    }
 
@@ -1771,7 +1770,7 @@ class slist_impl
    //!   is stateless.
    static const_iterator s_iterator_to(const_reference value) BOOST_NOEXCEPT
    {
-      BOOST_STATIC_ASSERT((!stateful_value_traits));
+      BOOST_INTRUSIVE_STATIC_ASSERT((!stateful_value_traits));
       reference r =*detail::uncast(pointer_traits<const_pointer>::pointer_to(value));
       return const_iterator(value_traits::to_node_ptr(r), const_value_traits_ptr());
    }
@@ -2112,8 +2111,8 @@ class slist_impl
    {
       //Obtaining the container from the end iterator is not possible with linear
       //singly linked lists (because "end" is represented by the null pointer)
-      BOOST_STATIC_ASSERT(!linear);
-      BOOST_STATIC_ASSERT((has_container_from_iterator));
+      BOOST_INTRUSIVE_STATIC_ASSERT(!linear);
+      BOOST_INTRUSIVE_STATIC_ASSERT((has_container_from_iterator));
       node_ptr p = end_iterator.pointed_node();
       header_holder_type* h = header_holder_type::get_holder(p);
       header_holder_plus_last_t* hpl = detail::parent_from_member< header_holder_plus_last_t, header_holder_type>
@@ -2185,7 +2184,7 @@ class slist
       #endif
       >::type   Base;
    //Assert if passed value traits are compatible with the type
-   BOOST_STATIC_ASSERT((detail::is_same<typename Base::value_traits::value_type, T>::value));
+   BOOST_INTRUSIVE_STATIC_ASSERT((detail::is_same<typename Base::value_traits::value_type, T>::value));
    BOOST_MOVABLE_BUT_NOT_COPYABLE(slist)
 
    public:
@@ -2195,45 +2194,45 @@ class slist
    typedef typename Base::size_type          size_type;
    typedef typename Base::node_ptr           node_ptr;
 
-   BOOST_INTRUSIVE_FORCEINLINE slist()
+   inline slist()
       :  Base()
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE explicit slist(const value_traits &v_traits)
+   inline explicit slist(const value_traits &v_traits)
       :  Base(v_traits)
    {}
 
    struct incorporate_t{};
 
-   BOOST_INTRUSIVE_FORCEINLINE slist( node_ptr f, node_ptr before_l
+   inline slist( node_ptr f, node_ptr before_l
              , size_type n, const value_traits &v_traits = value_traits())
       :  Base(f, before_l, n, v_traits)
    {}
 
    template<class Iterator>
-   BOOST_INTRUSIVE_FORCEINLINE slist(Iterator b, Iterator e, const value_traits &v_traits = value_traits())
+   inline slist(Iterator b, Iterator e, const value_traits &v_traits = value_traits())
       :  Base(b, e, v_traits)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE slist(BOOST_RV_REF(slist) x)
+   inline slist(BOOST_RV_REF(slist) x)
       :  Base(BOOST_MOVE_BASE(Base, x))
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE slist& operator=(BOOST_RV_REF(slist) x)
+   inline slist& operator=(BOOST_RV_REF(slist) x)
    {  return static_cast<slist &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x)));  }
 
    template <class Cloner, class Disposer>
-   BOOST_INTRUSIVE_FORCEINLINE void clone_from(const slist &src, Cloner cloner, Disposer disposer)
+   inline void clone_from(const slist &src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(src, cloner, disposer);  }
 
    template <class Cloner, class Disposer>
-   BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(slist) src, Cloner cloner, Disposer disposer)
+   inline void clone_from(BOOST_RV_REF(slist) src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static slist &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
+   inline static slist &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
    {  return static_cast<slist &>(Base::container_from_end_iterator(end_iterator));   }
 
-   BOOST_INTRUSIVE_FORCEINLINE static const slist &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
+   inline static const slist &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
    {  return static_cast<const slist &>(Base::container_from_end_iterator(end_iterator));   }
 };
 

data/src/cxx_supportlib/vendor-modified/boost/intrusive/splay_set.hpp

@@ -17,7 +17,6 @@
 #include <boost/intrusive/splaytree.hpp>
 #include <boost/intrusive/detail/mpl.hpp>
 #include <boost/move/utility_core.hpp>
-#include <boost/static_assert.hpp>
 
 #if defined(BOOST_HAS_PRAGMA_ONCE)
 #  pragma once
@@ -544,48 +543,48 @@ class splay_set
    typedef typename Base::const_iterator     const_iterator;
 
    //Assert if passed value traits are compatible with the type
-   BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
+   BOOST_INTRUSIVE_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
 
-   BOOST_INTRUSIVE_FORCEINLINE splay_set()
+   inline splay_set()
       :  Base()
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE explicit splay_set( const key_compare &cmp, const value_traits &v_traits = value_traits())
+   inline explicit splay_set( const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  Base(cmp, v_traits)
    {}
 
    template<class Iterator>
-   BOOST_INTRUSIVE_FORCEINLINE splay_set( Iterator b, Iterator e
+   inline 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)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE splay_set(BOOST_RV_REF(splay_set) x)
+   inline splay_set(BOOST_RV_REF(splay_set) x)
       :  Base(::boost::move(static_cast<Base&>(x)))
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE splay_set& operator=(BOOST_RV_REF(splay_set) x)
+   inline 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>
-   BOOST_INTRUSIVE_FORCEINLINE void clone_from(const splay_set &src, Cloner cloner, Disposer disposer)
+   inline void clone_from(const splay_set &src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(src, cloner, disposer);  }
 
    template <class Cloner, class Disposer>
-   BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(splay_set) src, Cloner cloner, Disposer disposer)
+   inline void clone_from(BOOST_RV_REF(splay_set) src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static splay_set &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
+   inline static splay_set &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
    {  return static_cast<splay_set &>(Base::container_from_end_iterator(end_iterator));   }
 
-   BOOST_INTRUSIVE_FORCEINLINE static const splay_set &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
+   inline static const splay_set &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
    {  return static_cast<const splay_set &>(Base::container_from_end_iterator(end_iterator));   }
 
-   BOOST_INTRUSIVE_FORCEINLINE static splay_set &container_from_iterator(iterator it) BOOST_NOEXCEPT
+   inline static splay_set &container_from_iterator(iterator it) BOOST_NOEXCEPT
    {  return static_cast<splay_set &>(Base::container_from_iterator(it));   }
 
-   BOOST_INTRUSIVE_FORCEINLINE static const splay_set &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
+   inline static const splay_set &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
    {  return static_cast<const splay_set &>(Base::container_from_iterator(it));   }
 };
 
@@ -1055,48 +1054,48 @@ class splay_multiset
    typedef typename Base::const_iterator     const_iterator;
 
    //Assert if passed value traits are compatible with the type
-   BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
+   BOOST_INTRUSIVE_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
 
-   BOOST_INTRUSIVE_FORCEINLINE splay_multiset()
+   inline splay_multiset()
       :  Base()
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE explicit splay_multiset( const key_compare &cmp, const value_traits &v_traits = value_traits())
+   inline explicit splay_multiset( const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  Base(cmp, v_traits)
    {}
 
    template<class Iterator>
-   BOOST_INTRUSIVE_FORCEINLINE splay_multiset( Iterator b, Iterator e
+   inline 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)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE splay_multiset(BOOST_RV_REF(splay_multiset) x)
+   inline splay_multiset(BOOST_RV_REF(splay_multiset) x)
       :  Base(::boost::move(static_cast<Base&>(x)))
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE splay_multiset& operator=(BOOST_RV_REF(splay_multiset) x)
+   inline 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>
-   BOOST_INTRUSIVE_FORCEINLINE void clone_from(const splay_multiset &src, Cloner cloner, Disposer disposer)
+   inline void clone_from(const splay_multiset &src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(src, cloner, disposer);  }
 
    template <class Cloner, class Disposer>
-   BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(splay_multiset) src, Cloner cloner, Disposer disposer)
+   inline void clone_from(BOOST_RV_REF(splay_multiset) src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static splay_multiset &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
+   inline static splay_multiset &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
    {  return static_cast<splay_multiset &>(Base::container_from_end_iterator(end_iterator));   }
 
-   BOOST_INTRUSIVE_FORCEINLINE static const splay_multiset &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
+   inline static const splay_multiset &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
    {  return static_cast<const splay_multiset &>(Base::container_from_end_iterator(end_iterator));   }
 
-   BOOST_INTRUSIVE_FORCEINLINE static splay_multiset &container_from_iterator(iterator it) BOOST_NOEXCEPT
+   inline static splay_multiset &container_from_iterator(iterator it) BOOST_NOEXCEPT
    {  return static_cast<splay_multiset &>(Base::container_from_iterator(it));   }
 
-   BOOST_INTRUSIVE_FORCEINLINE static const splay_multiset &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
+   inline static const splay_multiset &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
    {  return static_cast<const splay_multiset &>(Base::container_from_iterator(it));   }
 };
 

data/src/cxx_supportlib/vendor-modified/boost/intrusive/splaytree.hpp

@@ -18,7 +18,6 @@
 #include <boost/intrusive/detail/minimal_less_equal_header.hpp>
 #include <boost/intrusive/detail/minimal_pair_header.hpp>   //std::pair
 
-#include <boost/static_assert.hpp>
 #include <boost/intrusive/bstree.hpp>
 #include <boost/intrusive/detail/tree_node.hpp>
 #include <boost/intrusive/detail/mpl.hpp>
@@ -611,48 +610,48 @@ class splaytree
    typedef typename Base::const_reverse_iterator     const_reverse_iterator;
 
    //Assert if passed value traits are compatible with the type
-   BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
+   BOOST_INTRUSIVE_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
 
-   BOOST_INTRUSIVE_FORCEINLINE splaytree()
+   inline splaytree()
       :  Base()
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE explicit splaytree( const key_compare &cmp, const value_traits &v_traits = value_traits())
+   inline explicit splaytree( const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  Base(cmp, v_traits)
    {}
 
    template<class Iterator>
-   BOOST_INTRUSIVE_FORCEINLINE splaytree( bool unique, Iterator b, Iterator e
+   inline 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)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE splaytree(BOOST_RV_REF(splaytree) x)
+   inline splaytree(BOOST_RV_REF(splaytree) x)
       :  Base(BOOST_MOVE_BASE(Base, x))
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE splaytree& operator=(BOOST_RV_REF(splaytree) x)
+   inline splaytree& operator=(BOOST_RV_REF(splaytree) x)
    {  return static_cast<splaytree &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x)));  }
 
    template <class Cloner, class Disposer>
-   BOOST_INTRUSIVE_FORCEINLINE void clone_from(const splaytree &src, Cloner cloner, Disposer disposer)
+   inline void clone_from(const splaytree &src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(src, cloner, disposer);  }
 
    template <class Cloner, class Disposer>
-   BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(splaytree) src, Cloner cloner, Disposer disposer)
+   inline void clone_from(BOOST_RV_REF(splaytree) src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static splaytree &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
+   inline static splaytree &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
    {  return static_cast<splaytree &>(Base::container_from_end_iterator(end_iterator));   }
 
-   BOOST_INTRUSIVE_FORCEINLINE static const splaytree &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
+   inline static const splaytree &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
    {  return static_cast<const splaytree &>(Base::container_from_end_iterator(end_iterator));   }
 
-   BOOST_INTRUSIVE_FORCEINLINE static splaytree &container_from_iterator(iterator it) BOOST_NOEXCEPT
+   inline static splaytree &container_from_iterator(iterator it) BOOST_NOEXCEPT
    {  return static_cast<splaytree &>(Base::container_from_iterator(it));   }
 
-   BOOST_INTRUSIVE_FORCEINLINE static const splaytree &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
+   inline static const splaytree &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
    {  return static_cast<const splaytree &>(Base::container_from_iterator(it));   }
 };