passenger 6.0.20 → 6.0.21

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

@@ -151,8 +151,8 @@ class linear_slist_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static void init_header(node_ptr this_node) BOOST_NOEXCEPT
-   {  NodeTraits::set_next(this_node, node_ptr ());  }
+   inline static void init_header(node_ptr this_node) BOOST_NOEXCEPT
+   {  NodeTraits::set_next(this_node, node_ptr());  }
 
    //! <b>Requires</b>: 'p' is the first node of a list.
    //!
@@ -161,7 +161,7 @@ class linear_slist_algorithms
    //! <b>Complexity</b>: Constant time.
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr end_node(const_node_ptr) BOOST_NOEXCEPT
+   inline static node_ptr end_node(const_node_ptr) BOOST_NOEXCEPT
    {  return node_ptr();   }
 
    //! <b>Effects</b>: Returns true if this_node_points to an empty list.
@@ -169,7 +169,7 @@ class linear_slist_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static bool is_empty(const_node_ptr this_node) BOOST_NOEXCEPT
+   inline static bool is_empty(const_node_ptr this_node) BOOST_NOEXCEPT
    {  return !NodeTraits::get_next(this_node);  }
 
    //! <b>Effects</b>: Returns true if this_node points to a sentinel node.
@@ -177,7 +177,7 @@ class linear_slist_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static bool is_sentinel(const_node_ptr this_node) BOOST_NOEXCEPT
+   inline static bool is_sentinel(const_node_ptr this_node) BOOST_NOEXCEPT
    {  return NodeTraits::get_next(this_node) == this_node;  }
 
    //! <b>Effects</b>: Marks this node as a "sentinel" node, a special state that is different from "empty",
@@ -186,7 +186,7 @@ class linear_slist_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static void set_sentinel(node_ptr this_node) BOOST_NOEXCEPT
+   inline static void set_sentinel(node_ptr this_node) BOOST_NOEXCEPT
    {  NodeTraits::set_next(this_node, this_node);   }
 
    //! <b>Requires</b>: this_node and prev_init_node must be in the same linear list.
@@ -198,7 +198,7 @@ class linear_slist_algorithms
    //! <b>Complexity</b>: Linear to the number of elements between prev_init_node and this_node.
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr
+   inline static node_ptr
       get_previous_node(node_ptr prev_init_node, node_ptr this_node) BOOST_NOEXCEPT
    {  return base_t::get_previous_node(prev_init_node, this_node);   }
 
@@ -230,7 +230,7 @@ class linear_slist_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static void swap_trailing_nodes(node_ptr this_node, node_ptr other_node) BOOST_NOEXCEPT
+   inline static void swap_trailing_nodes(node_ptr this_node, node_ptr other_node) BOOST_NOEXCEPT
    {
       node_ptr this_nxt    = NodeTraits::get_next(this_node);
       node_ptr other_nxt   = NodeTraits::get_next(other_node);
@@ -400,7 +400,7 @@ class linear_slist_algorithms
    //!
    //! <b>Throws</b>: Nothing.
    template<class Disposer>
-   BOOST_INTRUSIVE_FORCEINLINE static std::size_t detach_and_dispose(node_ptr p, Disposer disposer) BOOST_NOEXCEPT
+   inline static std::size_t detach_and_dispose(node_ptr p, Disposer disposer) BOOST_NOEXCEPT
    {  return base_t::unlink_after_and_dispose(p, node_ptr(), disposer);   }
 };
 

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

@@ -37,7 +37,6 @@
 #include <boost/intrusive/detail/algorithm.hpp>
 
 #include <boost/move/utility_core.hpp>
-#include <boost/static_assert.hpp>
 
 #include <boost/intrusive/detail/value_functors.hpp>
 #include <cstddef>   //std::size_t, etc.
@@ -123,14 +122,14 @@ class list_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 &&
+   BOOST_INTRUSIVE_STATIC_ASSERT(!(constant_time_size &&
                         ((int)value_traits::link_mode == (int)auto_unlink)
                       ));
 
-   BOOST_INTRUSIVE_FORCEINLINE node_ptr get_root_node()
+   inline node_ptr get_root_node()
    { return data_.root_plus_size_.m_header.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_.m_header.get_node(); }
 
    struct root_plus_size : public size_traits
@@ -141,29 +140,29 @@ class list_impl
    struct data_t : public value_traits
    {
       typedef typename list_impl::value_traits value_traits;
-      BOOST_INTRUSIVE_FORCEINLINE explicit data_t(const value_traits &val_traits)
+      inline explicit data_t(const value_traits &val_traits)
          :  value_traits(val_traits)
       {}
 
       root_plus_size root_plus_size_;
    } data_;
 
-   BOOST_INTRUSIVE_FORCEINLINE size_traits &priv_size_traits() BOOST_NOEXCEPT
+   inline size_traits &priv_size_traits() BOOST_NOEXCEPT
    {  return data_.root_plus_size_;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE const size_traits &priv_size_traits() const BOOST_NOEXCEPT
+   inline const size_traits &priv_size_traits() const BOOST_NOEXCEPT
    {  return data_.root_plus_size_;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE const value_traits &priv_value_traits() const BOOST_NOEXCEPT
+   inline const value_traits &priv_value_traits() const BOOST_NOEXCEPT
    {  return data_;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE value_traits &priv_value_traits() BOOST_NOEXCEPT
+   inline value_traits &priv_value_traits() BOOST_NOEXCEPT
    {  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 BOOST_NOEXCEPT
+   inline const_value_traits_ptr priv_value_traits_ptr() const BOOST_NOEXCEPT
    {  return pointer_traits<const_value_traits_ptr>::pointer_to(this->priv_value_traits());  }
 
    /// @endcond
@@ -364,7 +363,7 @@ class list_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE reference front() BOOST_NOEXCEPT
+   inline reference front() BOOST_NOEXCEPT
    { return *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.
@@ -372,7 +371,7 @@ class list_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 *priv_value_traits().to_value_ptr(node_traits::get_next(this->get_root_node())); }
 
    //! <b>Effects</b>: Returns a reference to the last element of the list.
@@ -380,7 +379,7 @@ class list_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE reference back() BOOST_NOEXCEPT
+   inline reference back() BOOST_NOEXCEPT
    { return *priv_value_traits().to_value_ptr(node_traits::get_previous(this->get_root_node())); }
 
    //! <b>Effects</b>: Returns a const_reference to the last element of the list.
@@ -388,7 +387,7 @@ class list_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE const_reference back() const BOOST_NOEXCEPT
+   inline const_reference back() const BOOST_NOEXCEPT
    { return *priv_value_traits().to_value_ptr(detail::uncast(node_traits::get_previous(this->get_root_node()))); }
 
    //! <b>Effects</b>: Returns an iterator to the first element contained in the list.
@@ -396,7 +395,7 @@ class list_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.
@@ -404,7 +403,7 @@ class list_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 this->cbegin(); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the list.
@@ -412,7 +411,7 @@ class list_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.
@@ -420,7 +419,7 @@ class list_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_root_node(), this->priv_value_traits_ptr()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the list.
@@ -428,7 +427,7 @@ class list_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 this->cend(); }
 
    //! <b>Effects</b>: Returns a constant iterator to the end of the list.
@@ -436,7 +435,7 @@ class list_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 const_iterator(detail::uncast(this->get_root_node()), this->priv_value_traits_ptr()); }
 
    //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning
@@ -445,7 +444,7 @@ class list_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE reverse_iterator rbegin() BOOST_NOEXCEPT
+   inline reverse_iterator rbegin() BOOST_NOEXCEPT
    { return reverse_iterator(this->end()); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
@@ -454,7 +453,7 @@ class list_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator rbegin() const BOOST_NOEXCEPT
+   inline const_reverse_iterator rbegin() const BOOST_NOEXCEPT
    { return this->crbegin(); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
@@ -463,7 +462,7 @@ class list_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator crbegin() const BOOST_NOEXCEPT
+   inline const_reverse_iterator crbegin() const BOOST_NOEXCEPT
    { return const_reverse_iterator(end()); }
 
    //! <b>Effects</b>: Returns a reverse_iterator pointing to the end
@@ -472,7 +471,7 @@ class list_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE reverse_iterator rend() BOOST_NOEXCEPT
+   inline reverse_iterator rend() BOOST_NOEXCEPT
    { return reverse_iterator(begin()); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
@@ -481,7 +480,7 @@ class list_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator rend() const BOOST_NOEXCEPT
+   inline const_reverse_iterator rend() const BOOST_NOEXCEPT
    { return this->crend(); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
@@ -490,7 +489,7 @@ class list_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator crend() const BOOST_NOEXCEPT
+   inline const_reverse_iterator crend() const BOOST_NOEXCEPT
    { return const_reverse_iterator(this->begin()); }
 
    //! <b>Precondition</b>: end_iterator must be a valid end iterator
@@ -501,7 +500,7 @@ class list_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE static list_impl &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
+   inline static list_impl &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
    {  return list_impl::priv_container_from_end_iterator(end_iterator);   }
 
    //! <b>Precondition</b>: end_iterator must be a valid end const_iterator
@@ -512,7 +511,7 @@ class list_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE static const list_impl &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
+   inline static const list_impl &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
    {  return list_impl::priv_container_from_end_iterator(end_iterator);   }
 
    //! <b>Effects</b>: Returns the number of the elements contained in the list.
@@ -523,7 +522,7 @@ class list_impl
    //!   if constant-time size option is disabled. 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();
@@ -538,7 +537,7 @@ class list_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::unique(this->get_root_node());   }
 
    //! <b>Effects</b>: Swaps the elements of x and *this.
@@ -563,7 +562,7 @@ class list_impl
    //! <b>Complexity</b>: Linear to the number of shifts.
    //!
    //! <b>Note</b>: Does not affect the validity of iterators and references.
-   BOOST_INTRUSIVE_FORCEINLINE void shift_backwards(size_type n = 1) BOOST_NOEXCEPT
+   inline void shift_backwards(size_type n = 1) BOOST_NOEXCEPT
    {  node_algorithms::move_forward(this->get_root_node(), n);  }
 
    //! <b>Effects</b>: Moves forward all the elements, so that the second
@@ -575,7 +574,7 @@ class list_impl
    //! <b>Complexity</b>: Linear to the number of shifts.
    //!
    //! <b>Note</b>: Does not affect the validity of iterators and references.
-   BOOST_INTRUSIVE_FORCEINLINE void shift_forward(size_type n = 1) BOOST_NOEXCEPT
+   inline void shift_forward(size_type n = 1) BOOST_NOEXCEPT
    {  node_algorithms::move_backwards(this->get_root_node(), n);  }
 
    //! <b>Effects</b>: Erases the element pointed by i of the list.
@@ -590,7 +589,7 @@ class list_impl
    //!
    //! <b>Note</b>: Invalidates the iterators (but not the references) to the
    //!   erased element.
-   BOOST_INTRUSIVE_FORCEINLINE iterator erase(const_iterator i) BOOST_NOEXCEPT
+   inline iterator erase(const_iterator i) BOOST_NOEXCEPT
    {  return this->erase_and_dispose(i, detail::null_disposer());  }
 
    //! <b>Requires</b>: b and e must be valid iterators to elements in *this.
@@ -608,7 +607,7 @@ class list_impl
    //!
    //! <b>Note</b>: Invalidates the iterators (but not the references) to the
    //!   erased elements.
-   BOOST_INTRUSIVE_FORCEINLINE iterator erase(const_iterator b, const_iterator e) BOOST_NOEXCEPT
+   inline iterator erase(const_iterator b, const_iterator e) BOOST_NOEXCEPT
    {
       BOOST_IF_CONSTEXPR(safemode_or_autounlink || constant_time_size){
          return this->erase_and_dispose(b, e, detail::null_disposer());
@@ -1187,14 +1186,14 @@ class list_impl
    //! <b>Effects</b>: Removes adjacent duplicate elements or adjacent
    //!   elements that are equal from the list. No destructors are called.
    //!
-   //! <b>Throws</b>: If std::equal_to<value_type throws. Basic guarantee.
+   //! <b>Throws</b>: If the comparison operator throws. Basic guarantee.
    //!
    //! <b>Complexity</b>: Linear time (size()-1 comparisons calls to pred()).
    //!
    //! <b>Note</b>: The relative order of elements that are not removed is unchanged,
    //!   and iterators to elements that are not removed remain valid.
    void unique()
-   {  this->unique_and_dispose(std::equal_to<value_type>(), detail::null_disposer());  }
+   {  this->unique_and_dispose(value_equal<value_type>(), detail::null_disposer());  }
 
    //! <b>Effects</b>: Removes adjacent duplicate elements or adjacent
    //!   elements that satisfy some binary predicate from the list.
@@ -1216,7 +1215,7 @@ class list_impl
    //!   elements that are equal from the list.
    //!   Disposer::operator()(pointer) is called for every removed element.
    //!
-   //! <b>Throws</b>: If std::equal_to<value_type throws. Basic guarantee.
+   //! <b>Throws</b>: If the equality operator throws. Basic guarantee.
    //!
    //! <b>Complexity</b>: Linear time (size()-1) comparisons equality comparisons.
    //!
@@ -1224,7 +1223,7 @@ class list_impl
    //!   and iterators to elements that are not removed remain valid.
    template<class Disposer>
    void unique_and_dispose(Disposer disposer)
-   {  this->unique_and_dispose(std::equal_to<value_type>(), disposer);  }
+   {  this->unique_and_dispose(value_equal<value_type>(), disposer);  }
 
    //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
    //!
@@ -1272,7 +1271,7 @@ class list_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));
       BOOST_INTRUSIVE_INVARIANT_ASSERT(!node_algorithms::inited(value_traits::to_node_ptr(value)));
       return iterator(value_traits::to_node_ptr(value), const_value_traits_ptr());
    }
@@ -1290,7 +1289,7 @@ class list_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));
       BOOST_INTRUSIVE_INVARIANT_ASSERT(!node_algorithms::inited(value_traits::to_node_ptr(r)));
       return const_iterator(value_traits::to_node_ptr(r), const_value_traits_ptr());
@@ -1371,22 +1370,22 @@ class list_impl
       return ::boost::intrusive::algo_equal(x.cbegin(), x.cend(), y.cbegin(), y.cend());
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE friend bool operator!=(const list_impl &x, const list_impl &y)
+   inline friend bool operator!=(const list_impl &x, const list_impl &y)
    {  return !(x == y); }
 
-   BOOST_INTRUSIVE_FORCEINLINE friend bool operator<(const list_impl &x, const list_impl &y)
+   inline friend bool operator<(const list_impl &x, const list_impl &y)
    {  return ::boost::intrusive::algo_lexicographical_compare(x.begin(), x.end(), y.begin(), y.end());  }
 
-   BOOST_INTRUSIVE_FORCEINLINE friend bool operator>(const list_impl &x, const list_impl &y)
+   inline friend bool operator>(const list_impl &x, const list_impl &y)
    {  return y < x;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE friend bool operator<=(const list_impl &x, const list_impl &y)
+   inline friend bool operator<=(const list_impl &x, const list_impl &y)
    {  return !(y < x);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE friend bool operator>=(const list_impl &x, const list_impl &y)
+   inline friend bool operator>=(const list_impl &x, const list_impl &y)
    {  return !(x < y);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE friend void swap(list_impl &x, list_impl &y) BOOST_NOEXCEPT
+   inline friend void swap(list_impl &x, list_impl &y) BOOST_NOEXCEPT
    {  x.swap(y);  }
 
    /// @cond
@@ -1394,7 +1393,7 @@ class list_impl
    private:
    static list_impl &priv_container_from_end_iterator(const const_iterator &end_iterator) BOOST_NOEXCEPT
    {
-      BOOST_STATIC_ASSERT((has_container_from_iterator));
+      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);
       root_plus_size* r = detail::parent_from_member
@@ -1466,7 +1465,7 @@ class list
       #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(list)
 
    public:
@@ -1474,38 +1473,38 @@ class list
    typedef typename Base::iterator              iterator;
    typedef typename Base::const_iterator        const_iterator;
 
-   BOOST_INTRUSIVE_FORCEINLINE list()
+   inline list()
       :  Base()
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE explicit list(const value_traits &v_traits)
+   inline explicit list(const value_traits &v_traits)
       :  Base(v_traits)
    {}
 
    template<class Iterator>
-   BOOST_INTRUSIVE_FORCEINLINE list(Iterator b, Iterator e, const value_traits &v_traits = value_traits())
+   inline list(Iterator b, Iterator e, const value_traits &v_traits = value_traits())
       :  Base(b, e, v_traits)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE list(BOOST_RV_REF(list) x)
+   inline list(BOOST_RV_REF(list) x)
       :  Base(BOOST_MOVE_BASE(Base, x))
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE list& operator=(BOOST_RV_REF(list) x)
+   inline list& operator=(BOOST_RV_REF(list) x)
    {  return static_cast<list &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x)));  }
 
    template <class Cloner, class Disposer>
-   BOOST_INTRUSIVE_FORCEINLINE void clone_from(const list &src, Cloner cloner, Disposer disposer)
+   inline void clone_from(const list &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(list) src, Cloner cloner, Disposer disposer)
+   inline void clone_from(BOOST_RV_REF(list) src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static list &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
+   inline static list &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
    {  return static_cast<list &>(Base::container_from_end_iterator(end_iterator));   }
 
-   BOOST_INTRUSIVE_FORCEINLINE static const list &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
+   inline static const list &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
    {  return static_cast<const list &>(Base::container_from_end_iterator(end_iterator));   }
 };
 

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

@@ -14,7 +14,7 @@
 #define BOOST_INTRUSIVE_PACK_OPTIONS_HPP
 
 #include <boost/intrusive/detail/config_begin.hpp>
-
+#include <boost/intrusive/detail/workaround.hpp>
 #if defined(BOOST_HAS_PRAGMA_ONCE)
 #  pragma once
 #endif
@@ -338,7 +338,7 @@ struct pack_options
 //!
 //!   typedef pack_options< empty_default, typename my_pointer<void*> >::type::my_pointer_type type;
 //!
-//!   BOOST_STATIC_ASSERT(( boost::is_same<type, void>::value ));
+//!   BOOST_INTRUSIVE_STATIC_ASSERT(( boost::is_same<type, void>::value ));
 //!
 //! \endcode
 #define BOOST_INTRUSIVE_OPTION_TYPE(OPTION_NAME, TYPE, TYPEDEF_EXPR, TYPEDEF_NAME)
@@ -368,7 +368,7 @@ struct pack_options
 //!
 //!   const bool is_incremental = pack_options< empty_default, incremental<true> >::type::is_incremental;
 //!
-//!   BOOST_STATIC_ASSERT(( is_incremental == true ));
+//!   BOOST_INTRUSIVE_STATIC_ASSERT(( is_incremental == true ));
 //!
 //! \endcode
 #define BOOST_INTRUSIVE_OPTION_CONSTANT(OPTION_NAME, TYPE, VALUE, CONSTANT_NAME)

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

@@ -130,7 +130,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.
-   BOOST_INTRUSIVE_FORCEINLINE static pointer pointer_to(reference r) BOOST_NOEXCEPT
+   inline static pointer pointer_to(reference r) BOOST_NOEXCEPT
    {
       //Non-standard extension, it does not require Ptr::pointer_to. If not present
       //tries to converts &r to pointer.
@@ -150,7 +150,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>
-   BOOST_INTRUSIVE_FORCEINLINE static pointer static_cast_from(const UPtr &uptr) BOOST_NOEXCEPT
+   inline static pointer static_cast_from(const UPtr &uptr) BOOST_NOEXCEPT
    {
       typedef const UPtr &RefArg;
       const bool value = boost::intrusive::detail::
@@ -171,7 +171,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>
-   BOOST_INTRUSIVE_FORCEINLINE static pointer const_cast_from(const UPtr &uptr) BOOST_NOEXCEPT
+   inline static pointer const_cast_from(const UPtr &uptr) BOOST_NOEXCEPT
    {
       typedef const UPtr &RefArg;
       const bool value = boost::intrusive::detail::
@@ -192,7 +192,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>
-   BOOST_INTRUSIVE_FORCEINLINE static pointer dynamic_cast_from(const UPtr &uptr) BOOST_NOEXCEPT
+   inline static pointer dynamic_cast_from(const UPtr &uptr) BOOST_NOEXCEPT
    {
       typedef const UPtr &RefArg;
       const bool value = boost::intrusive::detail::
@@ -208,46 +208,46 @@ struct pointer_traits
    private:
    //priv_to_raw_pointer
    template <class T>
-   BOOST_INTRUSIVE_FORCEINLINE static T* to_raw_pointer(T* p) BOOST_NOEXCEPT
+   inline static T* to_raw_pointer(T* p) BOOST_NOEXCEPT
    {  return p; }
 
    template <class Pointer>
-   BOOST_INTRUSIVE_FORCEINLINE static typename pointer_traits<Pointer>::element_type*
+   inline static typename pointer_traits<Pointer>::element_type*
       to_raw_pointer(const Pointer &p) BOOST_NOEXCEPT
    {  return pointer_traits::to_raw_pointer(p.operator->());  }
 
    //priv_pointer_to
-   BOOST_INTRUSIVE_FORCEINLINE static pointer priv_pointer_to(boost::intrusive::detail::true_, reference r) BOOST_NOEXCEPT
+   inline static pointer priv_pointer_to(boost::intrusive::detail::true_, reference r) BOOST_NOEXCEPT
    { return Ptr::pointer_to(r); }
 
-   BOOST_INTRUSIVE_FORCEINLINE static pointer priv_pointer_to(boost::intrusive::detail::false_, reference r) BOOST_NOEXCEPT
+   inline static pointer priv_pointer_to(boost::intrusive::detail::false_, reference r) BOOST_NOEXCEPT
    { return pointer(boost::intrusive::detail::addressof(r)); }
 
    //priv_static_cast_from
    template<class UPtr>
-   BOOST_INTRUSIVE_FORCEINLINE static pointer priv_static_cast_from(boost::intrusive::detail::true_, const UPtr &uptr) BOOST_NOEXCEPT
+   inline static pointer priv_static_cast_from(boost::intrusive::detail::true_, const UPtr &uptr) BOOST_NOEXCEPT
    { return Ptr::static_cast_from(uptr); }
 
    template<class UPtr>
-   BOOST_INTRUSIVE_FORCEINLINE static pointer priv_static_cast_from(boost::intrusive::detail::false_, const UPtr &uptr) BOOST_NOEXCEPT
+   inline static pointer priv_static_cast_from(boost::intrusive::detail::false_, const UPtr &uptr) BOOST_NOEXCEPT
    {  return uptr ? pointer_to(*static_cast<element_type*>(to_raw_pointer(uptr))) : pointer();  }
 
    //priv_const_cast_from
    template<class UPtr>
-   BOOST_INTRUSIVE_FORCEINLINE static pointer priv_const_cast_from(boost::intrusive::detail::true_, const UPtr &uptr) BOOST_NOEXCEPT
+   inline static pointer priv_const_cast_from(boost::intrusive::detail::true_, const UPtr &uptr) BOOST_NOEXCEPT
    { return Ptr::const_cast_from(uptr); }
 
    template<class UPtr>
-   BOOST_INTRUSIVE_FORCEINLINE static pointer priv_const_cast_from(boost::intrusive::detail::false_, const UPtr &uptr) BOOST_NOEXCEPT
+   inline static pointer priv_const_cast_from(boost::intrusive::detail::false_, const UPtr &uptr) BOOST_NOEXCEPT
    {  return uptr ? pointer_to(const_cast<element_type&>(*uptr)) : pointer();  }
 
    //priv_dynamic_cast_from
    template<class UPtr>
-   BOOST_INTRUSIVE_FORCEINLINE static pointer priv_dynamic_cast_from(boost::intrusive::detail::true_, const UPtr &uptr) BOOST_NOEXCEPT
+   inline static pointer priv_dynamic_cast_from(boost::intrusive::detail::true_, const UPtr &uptr) BOOST_NOEXCEPT
    { return Ptr::dynamic_cast_from(uptr); }
 
    template<class UPtr>
-   BOOST_INTRUSIVE_FORCEINLINE static pointer priv_dynamic_cast_from(boost::intrusive::detail::false_, const UPtr &uptr) BOOST_NOEXCEPT
+   inline static pointer priv_dynamic_cast_from(boost::intrusive::detail::false_, const UPtr &uptr) BOOST_NOEXCEPT
    {  return uptr ? pointer_to(dynamic_cast<element_type&>(*uptr)) : pointer();  }
    ///@endcond
 };
@@ -296,25 +296,25 @@ struct pointer_traits<T*>
 
    //! <b>Returns</b>: addressof(r)
    //!
-   BOOST_INTRUSIVE_FORCEINLINE static pointer pointer_to(reference r) BOOST_NOEXCEPT
+   inline static pointer pointer_to(reference r) BOOST_NOEXCEPT
    { return boost::intrusive::detail::addressof(r); }
 
    //! <b>Returns</b>: static_cast<pointer>(uptr)
    //!
    template<class U>
-   BOOST_INTRUSIVE_FORCEINLINE static pointer static_cast_from(U *uptr) BOOST_NOEXCEPT
+   inline static pointer static_cast_from(U *uptr) BOOST_NOEXCEPT
    {  return static_cast<pointer>(uptr);  }
 
    //! <b>Returns</b>: const_cast<pointer>(uptr)
    //!
    template<class U>
-   BOOST_INTRUSIVE_FORCEINLINE static pointer const_cast_from(U *uptr) BOOST_NOEXCEPT
+   inline static pointer const_cast_from(U *uptr) BOOST_NOEXCEPT
    {  return const_cast<pointer>(uptr);  }
 
    //! <b>Returns</b>: dynamic_cast<pointer>(uptr)
    //!
    template<class U>
-   BOOST_INTRUSIVE_FORCEINLINE static pointer dynamic_cast_from(U *uptr) BOOST_NOEXCEPT
+   inline static pointer dynamic_cast_from(U *uptr) BOOST_NOEXCEPT
    {  return dynamic_cast<pointer>(uptr);  }
 };