passenger 6.0.20 → 6.0.21

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

@@ -28,7 +28,6 @@
 #include <boost/container/detail/workaround.hpp>
 
 #include <climits>
-#include <boost/static_assert.hpp>
 
 namespace boost {
 namespace container {
@@ -128,7 +127,7 @@ inline std::size_t floor_log2 (std::size_t x)
 {
    const std::size_t Bits = sizeof(std::size_t)*CHAR_BIT;
    const bool Size_t_Bits_Power_2= !(Bits & (Bits-1));
-   BOOST_STATIC_ASSERT(((Size_t_Bits_Power_2)== true));
+   BOOST_CONTAINER_STATIC_ASSERT(((Size_t_Bits_Power_2)== true));
 
    std::size_t n = x;
    std::size_t log2 = 0;

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

@@ -26,8 +26,6 @@
 // container/detail
 #include <boost/container/detail/min_max.hpp>
 
-#include <boost/static_assert.hpp>
-
 namespace boost {
 namespace container {
 namespace dtl {
@@ -35,10 +33,10 @@ namespace dtl {
 template<unsigned Minimum, unsigned Numerator, unsigned Denominator>
 struct grow_factor_ratio
 {
-   BOOST_STATIC_ASSERT(Numerator > Denominator);
-   BOOST_STATIC_ASSERT(Numerator   < 100);
-   BOOST_STATIC_ASSERT(Denominator < 100);
-   BOOST_STATIC_ASSERT(Denominator == 1 || (0 != Numerator % Denominator));
+   BOOST_CONTAINER_STATIC_ASSERT(Numerator > Denominator);
+   BOOST_CONTAINER_STATIC_ASSERT(Numerator   < 100);
+   BOOST_CONTAINER_STATIC_ASSERT(Denominator < 100);
+   BOOST_CONTAINER_STATIC_ASSERT(Denominator == 1 || (0 != Numerator % Denominator));
 
    template<class SizeType>
    SizeType operator()(const SizeType cur_cap, const SizeType add_min_cap, const SizeType max_cap) const
@@ -80,11 +78,11 @@ struct growth_factor_100
 {};
 
 template<class SizeType>
-BOOST_CONTAINER_FORCEINLINE void clamp_by_stored_size_type(SizeType &, SizeType)
+inline void clamp_by_stored_size_type(SizeType &, SizeType)
 {}
 
 template<class SizeType, class SomeStoredSizeType>
-BOOST_CONTAINER_FORCEINLINE void clamp_by_stored_size_type(SizeType &s, SomeStoredSizeType)
+inline void clamp_by_stored_size_type(SizeType &s, SomeStoredSizeType)
 {
    if (s >= SomeStoredSizeType(-1) ) 
       s = SomeStoredSizeType(-1);

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

@@ -118,16 +118,16 @@ struct base_node
       ::boost::container::construct_in_place(a, &this->get_real_data(), it);
    }
 
-   BOOST_CONTAINER_FORCEINLINE T &get_data()
+   inline T &get_data()
    {  return *move_detail::force_ptr<T*>(this->m_storage.data);   }
 
-   BOOST_CONTAINER_FORCEINLINE const T &get_data() const
+   inline const T &get_data() const
    {  return *move_detail::force_ptr<const T*>(this->m_storage.data);  }
 
-   BOOST_CONTAINER_FORCEINLINE internal_type &get_real_data()
+   inline internal_type &get_real_data()
    {  return *move_detail::force_ptr<internal_type*>(this->m_storage.data);   }
 
-   BOOST_CONTAINER_FORCEINLINE const internal_type &get_real_data() const
+   inline const internal_type &get_real_data() const
    {  return *move_detail::force_ptr<const internal_type*>(this->m_storage.data);  }
 
    #if defined(BOOST_CONTAINER_DISABLE_ALIASING_WARNING)
@@ -136,7 +136,7 @@ struct base_node
    #  endif
 
    template<class Alloc>
-   BOOST_CONTAINER_FORCEINLINE void destructor(Alloc &a) BOOST_NOEXCEPT
+   inline void destructor(Alloc &a) BOOST_NOEXCEPT
    {
       allocator_traits<Alloc>::destroy
          (a, &this->get_real_data());
@@ -144,7 +144,7 @@ struct base_node
    }
 
    template<class Pair>
-   BOOST_CONTAINER_FORCEINLINE
+   inline
    typename dtl::enable_if< dtl::is_pair<Pair>, void >::type
       do_assign(const Pair &p)
    {
@@ -154,13 +154,13 @@ struct base_node
    }
 
    template<class V>
-   BOOST_CONTAINER_FORCEINLINE 
+   inline 
    typename dtl::disable_if< dtl::is_pair<V>, void >::type
       do_assign(const V &v)
    {  this->get_real_data() = v; }
 
    template<class Pair>
-   BOOST_CONTAINER_FORCEINLINE 
+   inline 
    typename dtl::enable_if< dtl::is_pair<Pair>, void >::type
       do_move_assign(Pair &p)
    {
@@ -170,7 +170,7 @@ struct base_node
    }
 
    template<class V>
-   BOOST_CONTAINER_FORCEINLINE 
+   inline 
    typename dtl::disable_if< dtl::is_pair<V>, void >::type
       do_move_assign(V &v)
    {  this->get_real_data() = ::boost::move(v); }
@@ -178,7 +178,7 @@ struct base_node
    private:
    base_node();
 
-   BOOST_CONTAINER_FORCEINLINE ~base_node()
+   inline ~base_node()
    { }
 };
 
@@ -256,7 +256,7 @@ struct node_alloc_holder
    public:
 
    //Constructors for sequence containers
-   BOOST_CONTAINER_FORCEINLINE node_alloc_holder()
+   inline node_alloc_holder()
    {}
 
    explicit node_alloc_holder(const intrusive_bucket_traits& bt)
@@ -339,30 +339,30 @@ struct node_alloc_holder
                , typename ICont::key_equal(eql))
    {  this->icont().swap(BOOST_MOVE_TO_LV(x).icont());   }
 
-   BOOST_CONTAINER_FORCEINLINE void copy_assign_alloc(const node_alloc_holder &x)
+   inline void copy_assign_alloc(const node_alloc_holder &x)
    {
       dtl::bool_<allocator_traits_type::propagate_on_container_copy_assignment::value> flag;
       dtl::assign_alloc( static_cast<NodeAlloc &>(*this)
                        , static_cast<const NodeAlloc &>(x), flag);
    }
 
-   BOOST_CONTAINER_FORCEINLINE void move_assign_alloc( node_alloc_holder &x)
+   inline void move_assign_alloc( node_alloc_holder &x)
    {
       dtl::bool_<allocator_traits_type::propagate_on_container_move_assignment::value> flag;
       dtl::move_alloc( static_cast<NodeAlloc &>(*this)
                      , static_cast<NodeAlloc &>(x), flag);
    }
 
-   BOOST_CONTAINER_FORCEINLINE ~node_alloc_holder()
+   inline ~node_alloc_holder()
    {  this->clear(alloc_version()); }
 
-   BOOST_CONTAINER_FORCEINLINE size_type max_size() const
+   inline size_type max_size() const
    {  return allocator_traits_type::max_size(this->node_alloc());  }
 
-   BOOST_CONTAINER_FORCEINLINE NodePtr allocate_one()
+   inline NodePtr allocate_one()
    {  return AllocVersionTraits::allocate_one(this->node_alloc());   }
 
-   BOOST_CONTAINER_FORCEINLINE void deallocate_one(const NodePtr &p)
+   inline void deallocate_one(const NodePtr &p)
    {  AllocVersionTraits::deallocate_one(this->node_alloc(), p);  }
 
    #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
@@ -497,7 +497,7 @@ struct node_alloc_holder
       }
    }
 
-   BOOST_CONTAINER_FORCEINLINE void clear(version_1)
+   inline void clear(version_1)
    {  this->icont().clear_and_dispose(Destroyer(this->node_alloc()));   }
 
    void clear(version_2)
@@ -505,7 +505,7 @@ struct node_alloc_holder
       typename NodeAlloc::multiallocation_chain chain;
       allocator_node_destroyer_and_chain_builder<NodeAlloc> builder(this->node_alloc(), chain);
       this->icont().clear_and_dispose(builder);
-      //BOOST_STATIC_ASSERT((::boost::has_move_emulation_enabled<typename NodeAlloc::multiallocation_chain>::value == true));
+      //BOOST_CONTAINER_STATIC_ASSERT((::boost::has_move_emulation_enabled<typename NodeAlloc::multiallocation_chain>::value == true));
       if(!chain.empty())
          this->node_alloc().deallocate_individual(chain);
    }
@@ -524,11 +524,11 @@ struct node_alloc_holder
    }
 
    template<class Key>
-   BOOST_CONTAINER_FORCEINLINE size_type erase_key(const Key& k, version_1)
+   inline size_type erase_key(const Key& k, version_1)
    {  return this->icont().erase_and_dispose(k, Destroyer(this->node_alloc())); }
 
    template<class Key>
-   BOOST_CONTAINER_FORCEINLINE size_type erase_key(const Key& k, version_2)
+   inline size_type erase_key(const Key& k, version_2)
    {
       allocator_multialloc_chain_node_deallocator<NodeAlloc> chain_holder(this->node_alloc());
       return this->icont().erase_and_dispose(k, chain_holder.get_chain_builder());
@@ -537,11 +537,11 @@ struct node_alloc_holder
    protected:
    struct cloner
    {
-      BOOST_CONTAINER_FORCEINLINE explicit cloner(node_alloc_holder &holder)
+      inline explicit cloner(node_alloc_holder &holder)
          :  m_holder(holder)
       {}
 
-      BOOST_CONTAINER_FORCEINLINE NodePtr operator()(const Node &other) const
+      inline NodePtr operator()(const Node &other) const
       {  return m_holder.create_node(other.get_real_data());  }
 
       node_alloc_holder &m_holder;
@@ -549,11 +549,11 @@ struct node_alloc_holder
 
    struct move_cloner
    {
-      BOOST_CONTAINER_FORCEINLINE move_cloner(node_alloc_holder &holder)
+      inline move_cloner(node_alloc_holder &holder)
          :  m_holder(holder)
       {}
 
-      BOOST_CONTAINER_FORCEINLINE NodePtr operator()(Node &other)
+      inline NodePtr operator()(Node &other)
       {  //Use get_real_data() instead of get_real_data to allow moving const key in [multi]map
          return m_holder.create_node(::boost::move(other.get_real_data()));
       }
@@ -561,20 +561,20 @@ struct node_alloc_holder
       node_alloc_holder &m_holder;
    };
 
-   BOOST_CONTAINER_FORCEINLINE ICont &non_const_icont() const
+   inline ICont &non_const_icont() const
    {  return const_cast<ICont&>(this->m_icont);   }
 
-   BOOST_CONTAINER_FORCEINLINE NodeAlloc &node_alloc()
+   inline NodeAlloc &node_alloc()
    {  return static_cast<NodeAlloc &>(*this);   }
 
-   BOOST_CONTAINER_FORCEINLINE const NodeAlloc &node_alloc() const
+   inline const NodeAlloc &node_alloc() const
    {  return static_cast<const NodeAlloc &>(*this);   }
 
    public:
-   BOOST_CONTAINER_FORCEINLINE ICont &icont()
+   inline ICont &icont()
    {  return this->m_icont;   }
 
-   BOOST_CONTAINER_FORCEINLINE const ICont &icont() const
+   inline const ICont &icont() const
    {  return this->m_icont;   }
 
    protected:
@@ -587,10 +587,10 @@ struct key_of_node : KeyOfValue
 {
    typedef typename KeyOfValue::type type;
 
-   BOOST_CONTAINER_FORCEINLINE key_of_node()
+   inline key_of_node()
    {}
 
-   BOOST_CONTAINER_FORCEINLINE const type& operator()(const Node& x) const
+   inline const type& operator()(const Node& x) const
    {  return this->KeyOfValue::operator()(x.get_data());  }
 };
 

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

@@ -84,21 +84,21 @@ class private_node_pool_impl
    {}
 
    //!Destructor. Deallocates all allocated blocks. Never throws
-   BOOST_CONTAINER_FORCEINLINE ~private_node_pool_impl()
+   inline ~private_node_pool_impl()
    {  this->purge_blocks();  }
 
-   BOOST_CONTAINER_FORCEINLINE size_type get_real_num_node() const
+   inline size_type get_real_num_node() const
    {  return m_nodes_per_block; }
 
    //!Returns the segment manager. Never throws
-   BOOST_CONTAINER_FORCEINLINE segment_manager_base_type* get_segment_manager_base()const
+   inline segment_manager_base_type* get_segment_manager_base()const
    {  return boost::movelib::to_raw_pointer(mp_segment_mngr_base);  }
 
-   BOOST_CONTAINER_FORCEINLINE void *allocate_node()
+   inline void *allocate_node()
    {  return this->priv_alloc_node();  }
 
    //!Deallocates an array pointed by ptr. Never throws
-   BOOST_CONTAINER_FORCEINLINE void deallocate_node(void *ptr)
+   inline void deallocate_node(void *ptr)
    {  this->priv_dealloc_node(ptr); }
 
    //!Allocates a singly linked list of n nodes ending in null pointer.
@@ -205,7 +205,7 @@ class private_node_pool_impl
          , backup_list.size());
    }
 
-   BOOST_CONTAINER_FORCEINLINE size_type num_free_nodes()
+   inline size_type num_free_nodes()
    {  return m_freelist.size();  }
 
    //!Deallocates all used memory. Precondition: all nodes allocated from this pool should

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

@@ -25,7 +25,6 @@
 #include <boost/container/container_fwd.hpp>
 #include <boost/container/detail/workaround.hpp>
 
-#include <boost/static_assert.hpp>
 #include <boost/container/detail/mpl.hpp>
 #include <boost/container/detail/type_traits.hpp>
 #include <boost/container/detail/mpl.hpp>
@@ -166,35 +165,35 @@ struct pair
    pair()
       : first(), second()
    {
-      BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
+      BOOST_CONTAINER_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
    }
 
    //pair copy assignment
    pair(const pair& x)
       : first(x.first), second(x.second)
    {
-      BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
+      BOOST_CONTAINER_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
    }
 
    //pair move constructor
    pair(BOOST_RV_REF(pair) p)
       : first(::boost::move(BOOST_MOVE_TO_LV(p).first)), second(::boost::move(BOOST_MOVE_TO_LV(p).second))
    {
-      BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
+      BOOST_CONTAINER_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
    }
 
    template <class D, class S>
    pair(const pair<D, S> &p)
       : first(p.first), second(p.second)
    {
-      BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
+      BOOST_CONTAINER_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
    }
 
    template <class D, class S>
    pair(BOOST_RV_REF_BEG pair<D, S> BOOST_RV_REF_END p)
       : first(::boost::move(BOOST_MOVE_TO_LV(p).first)), second(::boost::move(BOOST_MOVE_TO_LV(p).second))
    {
-      BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
+      BOOST_CONTAINER_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
    }
 
    //pair from two values
@@ -202,7 +201,7 @@ struct pair
       : first(t1)
       , second(t2)
    {
-      BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
+      BOOST_CONTAINER_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
    }
 
    template<class U, class V>
@@ -210,34 +209,34 @@ struct pair
       : first(::boost::forward<U>(u))
       , second(::boost::forward<V>(v))
    {
-      BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
+      BOOST_CONTAINER_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
    }
 
    //And now compatibility with std::pair
    pair(const std::pair<T1, T2>& x)
       : first(x.first), second(x.second)
    {
-      BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
+      BOOST_CONTAINER_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
    }
 
    template <class D, class S>
    pair(const std::pair<D, S>& p)
       : first(p.first), second(p.second)
    {
-      BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
+      BOOST_CONTAINER_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
    }
 
    pair(BOOST_RV_REF_BEG std::pair<T1, T2> BOOST_RV_REF_END p)
       : first(::boost::move(BOOST_MOVE_TO_LV(p).first)), second(::boost::move(BOOST_MOVE_TO_LV(p).second))
    {
-      BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
+      BOOST_CONTAINER_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
    }
 
    template <class D, class S>
    pair(BOOST_RV_REF_BEG std::pair<D, S> BOOST_RV_REF_END p)
       : first(::boost::move(BOOST_MOVE_TO_LV(p).first)), second(::boost::move(BOOST_MOVE_TO_LV(p).second))
    {
-      BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
+      BOOST_CONTAINER_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
    }
 
    #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
@@ -245,7 +244,7 @@ struct pair
    pair(try_emplace_t, BOOST_FWD_REF(KeyType) k, Args && ...args)
       : first(boost::forward<KeyType>(k)), second(::boost::forward<Args>(args)...)\
    {
-      BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
+      BOOST_CONTAINER_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
    }
    #else
 
@@ -255,7 +254,7 @@ struct pair
    pair( try_emplace_t, BOOST_FWD_REF(KeyType) k BOOST_MOVE_I##N BOOST_MOVE_UREF##N )\
       : first(boost::forward<KeyType>(k)), second(BOOST_MOVE_FWD##N)\
    {\
-      BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));\
+      BOOST_CONTAINER_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));\
    }\
    //
    BOOST_MOVE_ITERATE_0TO9(BOOST_PAIR_TRY_EMPLACE_CONSTRUCT_CODE)
@@ -277,7 +276,7 @@ struct pair
        )\
       : first(BOOST_MOVE_TMPL_GET##N), second(BOOST_MOVE_TMPL_GETQ##M)\
    { (void)p; (void)q;\
-      BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));\
+      BOOST_CONTAINER_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));\
    }\
    //
    BOOST_MOVE_ITER2D_0TOMAX(9, BOOST_PAIR_PIECEWISE_CONSTRUCT_BOOST_TUPLE_CODE)
@@ -299,7 +298,7 @@ struct pair
       pair(piecewise_construct_t, Tuple<Args1...> t1, Tuple<Args2...> t2)
          : pair(t1, t2, typename build_number_seq<sizeof...(Args1)>::type(), typename build_number_seq<sizeof...(Args2)>::type())
       {
-         BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
+         BOOST_CONTAINER_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
       }
    #  else
       //piecewise construction from variadic tuple (suboptimal, without delegating constructors)
@@ -319,7 +318,7 @@ struct pair
          : first  (build_from_args<first_type> (::boost::move(t1)))
          , second (build_from_args<second_type>(::boost::move(t2)))
       {
-         BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
+         BOOST_CONTAINER_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
       }
    #  endif   //BOOST_NO_CXX11_VARIADIC_TEMPLATES
    #elif defined(BOOST_MSVC) && (_CPPLIB_VER == 520)
@@ -332,7 +331,7 @@ struct pair
           , StdTuple<BOOST_MOVE_TARGQ##M BOOST_MOVE_I##M BOOST_MOVE_REPEAT(BOOST_MOVE_SUB(10,M),::std::tr1::_Nil)> q)\
          : first(BOOST_MOVE_GET_IDX##N), second(BOOST_MOVE_GET_IDXQ##M)\
       { (void)p; (void)q;\
-         BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));\
+         BOOST_CONTAINER_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));\
       }\
       //
       BOOST_MOVE_ITER2D_0TOMAX(9, BOOST_PAIR_PIECEWISE_CONSTRUCT_MSVC2010_TUPLE_CODE)
@@ -353,7 +352,7 @@ struct pair
           , StdTuple<BOOST_MOVE_TARGQ##M BOOST_MOVE_I##M BOOST_MOVE_REPEAT(BOOST_MOVE_SUB(BOOST_MOVE_ADD(_VARIADIC_MAX, 3),M),::std::_Nil) > q)\
          : first(BOOST_MOVE_GET_IDX##N), second(BOOST_MOVE_GET_IDXQ##M)\
       { (void)p; (void)q;\
-         BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));\
+         BOOST_CONTAINER_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));\
       }\
       //
       BOOST_MOVE_ITER2D_0TOMAX(BOOST_PAIR_PIECEWISE_CONSTRUCT_MSVC2012_TUPLE_MAX_IT, BOOST_PAIR_PIECEWISE_CONSTRUCT_MSVC2012_TUPLE_CODE)

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

@@ -33,13 +33,13 @@ namespace container {
 template <class PseudoReference>
 struct operator_arrow_proxy
 {
-   BOOST_CONTAINER_FORCEINLINE operator_arrow_proxy(const PseudoReference &px)
+   inline operator_arrow_proxy(const PseudoReference &px)
       :  m_value(px)
    {}
 
    typedef PseudoReference element_type;
 
-   BOOST_CONTAINER_FORCEINLINE PseudoReference* operator->() const { return &m_value; }
+   inline PseudoReference* operator->() const { return &m_value; }
 
    mutable PseudoReference m_value;
 };
@@ -47,13 +47,13 @@ struct operator_arrow_proxy
 template <class T>
 struct operator_arrow_proxy<T&>
 {
-   BOOST_CONTAINER_FORCEINLINE operator_arrow_proxy(T &px)
+   inline operator_arrow_proxy(T &px)
       :  m_value(px)
    {}
 
    typedef T element_type;
 
-   BOOST_CONTAINER_FORCEINLINE T* operator->() const { return const_cast<T*>(&m_value); }
+   inline T* operator->() const { return const_cast<T*>(&m_value); }
 
    T &m_value;
 };
@@ -69,29 +69,29 @@ class transform_iterator
       , typename UnaryFunction::result_type>
 {
    public:
-   BOOST_CONTAINER_FORCEINLINE explicit transform_iterator(const Iterator &it, const UnaryFunction &f = UnaryFunction())
+   inline explicit transform_iterator(const Iterator &it, const UnaryFunction &f = UnaryFunction())
       :  UnaryFunction(f), m_it(it)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE explicit transform_iterator()
+   inline explicit transform_iterator()
       :  UnaryFunction(), m_it()
    {}
 
    //Constructors
-   BOOST_CONTAINER_FORCEINLINE transform_iterator& operator++()
+   inline transform_iterator& operator++()
    { increment();   return *this;   }
 
-      BOOST_CONTAINER_FORCEINLINE transform_iterator operator++(int)
+      inline transform_iterator operator++(int)
    {
       transform_iterator result (*this);
       increment();
       return result;
    }
 
-   BOOST_CONTAINER_FORCEINLINE friend bool operator== (const transform_iterator& i, const transform_iterator& i2)
+   inline friend bool operator== (const transform_iterator& i, const transform_iterator& i2)
    { return i.equal(i2); }
 
-   BOOST_CONTAINER_FORCEINLINE friend bool operator!= (const transform_iterator& i, const transform_iterator& i2)
+   inline friend bool operator!= (const transform_iterator& i, const transform_iterator& i2)
    { return !(i == i2); }
 
 /*
@@ -104,69 +104,69 @@ class transform_iterator
    friend bool operator>= (const transform_iterator& i, const transform_iterator& i2)
    { return !(i < i2); }
 */
-   BOOST_CONTAINER_FORCEINLINE friend typename Iterator::difference_type operator- (const transform_iterator& i, const transform_iterator& i2)
+   inline friend typename Iterator::difference_type operator- (const transform_iterator& i, const transform_iterator& i2)
    { return i2.distance_to(i); }
 
    //Arithmetic
-   BOOST_CONTAINER_FORCEINLINE transform_iterator& operator+=(typename Iterator::difference_type off)
+   inline transform_iterator& operator+=(typename Iterator::difference_type off)
    {  this->advance(off); return *this;   }
 
-   BOOST_CONTAINER_FORCEINLINE transform_iterator operator+(typename Iterator::difference_type off) const
+   inline transform_iterator operator+(typename Iterator::difference_type off) const
    {
       transform_iterator other(*this);
       other.advance(off);
       return other;
    }
 
-   BOOST_CONTAINER_FORCEINLINE friend transform_iterator operator+(typename Iterator::difference_type off, const transform_iterator& right)
+   inline friend transform_iterator operator+(typename Iterator::difference_type off, const transform_iterator& right)
    {  return right + off; }
 
-   BOOST_CONTAINER_FORCEINLINE transform_iterator& operator-=(typename Iterator::difference_type off)
+   inline transform_iterator& operator-=(typename Iterator::difference_type off)
    {  this->advance(-off); return *this;   }
 
-   BOOST_CONTAINER_FORCEINLINE transform_iterator operator-(typename Iterator::difference_type off) const
+   inline transform_iterator operator-(typename Iterator::difference_type off) const
    {  return *this + (-off);  }
 
-   BOOST_CONTAINER_FORCEINLINE typename UnaryFunction::result_type operator*() const
+   inline typename UnaryFunction::result_type operator*() const
    { return dereference(); }
 
-   BOOST_CONTAINER_FORCEINLINE operator_arrow_proxy<typename UnaryFunction::result_type>
+   inline operator_arrow_proxy<typename UnaryFunction::result_type>
       operator->() const
    { return operator_arrow_proxy<typename UnaryFunction::result_type>(dereference());  }
 
-   BOOST_CONTAINER_FORCEINLINE Iterator & base()
+   inline Iterator & base()
    {  return m_it;   }
 
-   BOOST_CONTAINER_FORCEINLINE const Iterator & base() const
+   inline const Iterator & base() const
    {  return m_it;   }
 
    private:
    Iterator m_it;
 
-   BOOST_CONTAINER_FORCEINLINE void increment()
+   inline void increment()
    { ++m_it; }
 
-   BOOST_CONTAINER_FORCEINLINE void decrement()
+   inline void decrement()
    { --m_it; }
 
-   BOOST_CONTAINER_FORCEINLINE bool equal(const transform_iterator &other) const
+   inline bool equal(const transform_iterator &other) const
    {  return m_it == other.m_it;   }
 
-   BOOST_CONTAINER_FORCEINLINE bool less(const transform_iterator &other) const
+   inline bool less(const transform_iterator &other) const
    {  return other.m_it < m_it;   }
 
-   BOOST_CONTAINER_FORCEINLINE typename UnaryFunction::result_type dereference() const
+   inline typename UnaryFunction::result_type dereference() const
    { return UnaryFunction::operator()(*m_it); }
 
-   BOOST_CONTAINER_FORCEINLINE void advance(typename Iterator::difference_type n)
+   inline void advance(typename Iterator::difference_type n)
    {  boost::container::iterator_advance(m_it, n); }
 
-   BOOST_CONTAINER_FORCEINLINE typename Iterator::difference_type distance_to(const transform_iterator &other)const
+   inline typename Iterator::difference_type distance_to(const transform_iterator &other)const
    {  return boost::container::iterator_distance(other.m_it, m_it); }
 };
 
 template <class Iterator, class UnaryFunc>
-BOOST_CONTAINER_FORCEINLINE transform_iterator<Iterator, UnaryFunc>
+inline transform_iterator<Iterator, UnaryFunc>
 make_transform_iterator(Iterator it, UnaryFunc fun)
 {
    return transform_iterator<Iterator, UnaryFunc>(it, fun);