passenger 6.0.3 → 6.0.8

data/src/cxx_supportlib/vendor-modified/boost/container/pmr/monotonic_buffer_resource.hpp

@@ -18,6 +18,7 @@
 #include <boost/container/detail/config_begin.hpp>
 #include <boost/container/detail/workaround.hpp>
 #include <boost/container/detail/auto_link.hpp>
+#include <boost/container/container_fwd.hpp>
 #include <boost/container/pmr/memory_resource.hpp>
 #include <boost/container/detail/block_slist.hpp>
 
@@ -108,7 +109,7 @@ class BOOST_CONTAINER_DECL monotonic_buffer_resource
 
    //! <b>Effects</b>: Calls
    //!   `this->release()`.
-   virtual ~monotonic_buffer_resource();
+   ~monotonic_buffer_resource() BOOST_OVERRIDE;
 
    //! <b>Effects</b>: `upstream_resource()->deallocate()` as necessary to release all allocated memory.
    //!   [Note: memory is released back to `upstream_resource()` even if some blocks that were allocated
@@ -159,18 +160,18 @@ class BOOST_CONTAINER_DECL monotonic_buffer_resource
    //!   then allocate the return block from the newly-allocated internal `current_buffer`.
    //!
    //! <b>Throws</b>: Nothing unless `upstream_resource()->allocate()` throws.
-   virtual void* do_allocate(std::size_t bytes, std::size_t alignment);
+   void* do_allocate(std::size_t bytes, std::size_t alignment) BOOST_OVERRIDE;
 
    //! <b>Effects</b>: None
    //!
    //! <b>Throws</b>: Nothing
    //!
    //! <b>Remarks</b>: Memory used by this resource increases monotonically until its destruction.
-   virtual void do_deallocate(void* p, std::size_t bytes, std::size_t alignment) BOOST_NOEXCEPT;
+   void do_deallocate(void* p, std::size_t bytes, std::size_t alignment) BOOST_NOEXCEPT BOOST_OVERRIDE;
 
    //! <b>Returns</b>:
    //!   `this == dynamic_cast<const monotonic_buffer_resource*>(&other)`.
-   virtual bool do_is_equal(const memory_resource& other) const BOOST_NOEXCEPT;
+   bool do_is_equal(const memory_resource& other) const BOOST_NOEXCEPT BOOST_OVERRIDE;
 };
 
 }  //namespace pmr {

data/src/cxx_supportlib/vendor-modified/boost/container/pmr/resource_adaptor.hpp

@@ -15,14 +15,44 @@
 #  pragma once 
 #endif
 
-#include <boost/config.hpp>
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/detail/workaround.hpp>
+#include <boost/container/container_fwd.hpp>
+
 #include <boost/container/pmr/memory_resource.hpp>
 #include <boost/container/allocator_traits.hpp>
 #include <boost/intrusive/detail/ebo_functor_holder.hpp>
 #include <boost/move/utility_core.hpp>
+#include <boost/move/detail/type_traits.hpp>
+#include <boost/container/detail/std_fwd.hpp>
+
+#include <cstring>
 
 namespace boost {
 namespace container {
+
+namespace pmr_dtl {
+
+template<class T>
+struct max_allocator_alignment
+{
+   static const std::size_t value = 1;
+};
+
+template<class T>
+struct max_allocator_alignment< ::boost::container::new_allocator<T> >
+{
+   static const std::size_t value = boost::move_detail::alignment_of<boost::move_detail::max_align_t>::value;
+};
+
+template<class T>
+struct max_allocator_alignment< std::allocator<T> >
+{
+   static const std::size_t value = boost::move_detail::alignment_of<boost::move_detail::max_align_t>::value;
+};
+
+}  //namespace pmr_dtl
+
 namespace pmr {
 
 //! An instance of resource_adaptor<Allocator> is an adaptor that wraps a memory_resource interface
@@ -57,7 +87,7 @@ class resource_adaptor_imp
    void static_assert_if_not_char_allocator() const
    {
       //This class can only be used with allocators type char
-      BOOST_STATIC_ASSERT((dtl::is_same<typename Allocator::value_type, char>::value));
+      BOOST_STATIC_ASSERT((boost::container::dtl::is_same<typename Allocator::value_type, char>::value));
    }
    #endif
 
@@ -114,15 +144,25 @@ class resource_adaptor_imp
    protected:
    //! <b>Returns</b>: Allocated memory obtained by calling m_alloc.allocate. The size and alignment
    //!   of the allocated memory shall meet the requirements for a class derived from memory_resource.
-   virtual void* do_allocate(size_t bytes, size_t alignment)
-   {  (void)alignment;  return this->ebo_alloc_t::get().allocate(bytes);  }
+   virtual void* do_allocate(std::size_t bytes, std::size_t alignment)
+   {
+      if (alignment <= priv_guaranteed_allocator_alignment())
+         return this->ebo_alloc_t::get().allocate(bytes);
+      else
+         return this->priv_aligned_alloc(bytes, alignment);
+   }
 
    //! <b>Requires</b>: p was previously allocated using A.allocate, where A == m_alloc, and not
    //!   subsequently deallocated. 
    //!
    //! <b>Effects</b>: Returns memory to the allocator using m_alloc.deallocate().
-   virtual void do_deallocate(void* p, size_t bytes, size_t alignment)
-   {  (void)alignment; this->ebo_alloc_t::get().deallocate((char*)p, bytes);   }
+   virtual void do_deallocate(void* p, std::size_t bytes, std::size_t alignment)
+   {
+      if (alignment <= priv_guaranteed_allocator_alignment())
+         this->ebo_alloc_t::get().deallocate((char*)p, bytes);
+      else
+         this->priv_aligned_dealloc(p, bytes, alignment);
+   }
 
    //! Let p be dynamic_cast<const resource_adaptor_imp*>(&other).
    //!
@@ -132,6 +172,48 @@ class resource_adaptor_imp
       const resource_adaptor_imp* p = dynamic_cast<const resource_adaptor_imp*>(&other);
       return p && p->ebo_alloc_t::get() == this->ebo_alloc_t::get();
    }
+
+   private:
+   void * priv_aligned_alloc(std::size_t bytes, std::size_t alignment)
+   {
+      //Allocate space for requested bytes, plus alignment, plus bookeeping data
+      void *const p = this->ebo_alloc_t::get().allocate(bytes + priv_extra_bytes_for_overalignment(alignment));
+
+      if (0 != p) {
+         //Obtain the aligned address after the bookeeping data
+         void *const aligned_ptr = (void*)(((std::size_t)p + priv_extra_bytes_for_overalignment(alignment)) & ~(alignment - 1));
+
+         //Store bookeeping data. Use memcpy as the underlying memory might be unaligned for
+         //a pointer (e.g. 2 byte alignment in 32 bit, 4 byte alignment in 64 bit)
+         std::memcpy(priv_bookeeping_addr_from_aligned_ptr(aligned_ptr), &p, sizeof(p));
+         return aligned_ptr;
+      }
+      return 0;
+   }
+
+   void priv_aligned_dealloc(void *aligned_ptr, std::size_t bytes, std::size_t alignment)
+   {
+      //Obtain bookeeping data
+      void *p;
+      std::memcpy(&p, priv_bookeeping_addr_from_aligned_ptr(aligned_ptr), sizeof(p));
+      std::size_t s  = bytes + priv_extra_bytes_for_overalignment(alignment);
+      this->ebo_alloc_t::get().deallocate((char*)p, s);
+   }
+
+   static BOOST_CONTAINER_FORCEINLINE void *priv_bookeeping_addr_from_aligned_ptr(void *aligned_ptr)
+   {
+      return reinterpret_cast<void*>(reinterpret_cast<std::size_t>(aligned_ptr) - sizeof(void*));
+   }
+
+   BOOST_CONTAINER_FORCEINLINE static std::size_t priv_extra_bytes_for_overalignment(std::size_t alignment)
+   {
+      return alignment - 1 + sizeof(void*);
+   }
+
+   BOOST_CONTAINER_FORCEINLINE static std::size_t priv_guaranteed_allocator_alignment()
+   {
+      return pmr_dtl::max_allocator_alignment<Allocator>::value;
+   }
 };
 
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
@@ -190,4 +272,6 @@ class resource_adaptor
 }  //namespace container {
 }  //namespace boost {
 
+#include <boost/container/detail/config_end.hpp>
+
 #endif   //BOOST_CONTAINER_PMR_RESOURCE_ADAPTOR_HPP

data/src/cxx_supportlib/vendor-modified/boost/container/pmr/synchronized_pool_resource.hpp

@@ -89,7 +89,7 @@ class BOOST_CONTAINER_DECL synchronized_pool_resource
    #endif
 
    //! @copydoc ::boost::container::pmr::unsynchronized_pool_resource::~unsynchronized_pool_resource()
-   virtual ~synchronized_pool_resource();
+   ~synchronized_pool_resource() BOOST_OVERRIDE;
 
    //! @copydoc ::boost::container::pmr::unsynchronized_pool_resource::release()
    void release();
@@ -103,13 +103,13 @@ class BOOST_CONTAINER_DECL synchronized_pool_resource
    protected:
 
    //! @copydoc ::boost::container::pmr::unsynchronized_pool_resource::do_allocate()
-   virtual void* do_allocate(std::size_t bytes, std::size_t alignment);
+   void* do_allocate(std::size_t bytes, std::size_t alignment) BOOST_OVERRIDE;
 
    //! @copydoc ::boost::container::pmr::unsynchronized_pool_resource::do_deallocate(void*,std::size_t,std::size_t)
-   virtual void do_deallocate(void* p, std::size_t bytes, std::size_t alignment);
+   void do_deallocate(void* p, std::size_t bytes, std::size_t alignment) BOOST_OVERRIDE;
 
    //! @copydoc ::boost::container::pmr::unsynchronized_pool_resource::do_is_equal(const memory_resource&)const
-   virtual bool do_is_equal(const memory_resource& other) const BOOST_NOEXCEPT;
+   bool do_is_equal(const memory_resource& other) const BOOST_NOEXCEPT BOOST_OVERRIDE;
 
    //Non-standard observers
    public:

data/src/cxx_supportlib/vendor-modified/boost/container/pmr/unsynchronized_pool_resource.hpp

@@ -103,7 +103,7 @@ class BOOST_CONTAINER_DECL unsynchronized_pool_resource
 
    //! <b>Effects</b>: Calls
    //!   `this->release()`.
-   virtual ~unsynchronized_pool_resource();
+   ~unsynchronized_pool_resource() BOOST_OVERRIDE;
 
    //! <b>Effects</b>: Calls Calls `upstream_resource()->deallocate()` as necessary
    //!   to release all allocated memory. [ Note: memory is released back to
@@ -134,18 +134,18 @@ class BOOST_CONTAINER_DECL unsynchronized_pool_resource
    //!   using `upstream_resource()->allocate()`.
    //!
    //! <b>Throws</b>: Nothing unless `upstream_resource()->allocate()` throws.
-   virtual void* do_allocate(std::size_t bytes, std::size_t alignment);
+   void* do_allocate(std::size_t bytes, std::size_t alignment) BOOST_OVERRIDE;
 
    //! <b>Effects</b>: Return the memory at p to the pool. It is unspecified if or under
    //!   what circumstances this operation will result in a call to
    //!   `upstream_resource()->deallocate()`.
    //!
    //! <b>Throws</b>: Nothing.
-   virtual void do_deallocate(void* p, std::size_t bytes, std::size_t alignment);
+   void do_deallocate(void* p, std::size_t bytes, std::size_t alignment) BOOST_OVERRIDE;
 
    //! <b>Returns</b>:
    //!   `this == dynamic_cast<const unsynchronized_pool_resource*>(&other)`.
-   virtual bool do_is_equal(const memory_resource& other) const BOOST_NOEXCEPT;
+   bool do_is_equal(const memory_resource& other) const BOOST_NOEXCEPT BOOST_OVERRIDE;
 
    //Non-standard observers
    public:

data/src/cxx_supportlib/vendor-modified/boost/container/scoped_allocator.hpp

@@ -79,10 +79,10 @@ struct outermost_allocator_imp
 {
    typedef MaybeScopedAlloc type;
 
-   static type &get(MaybeScopedAlloc &a)
+   BOOST_CONTAINER_FORCEINLINE static type &get(MaybeScopedAlloc &a)
    {  return a;  }
 
-   static const type &get(const MaybeScopedAlloc &a)
+   BOOST_CONTAINER_FORCEINLINE static const type &get(const MaybeScopedAlloc &a)
    {  return a;  }
 };
 
@@ -92,10 +92,10 @@ struct outermost_allocator_imp<MaybeScopedAlloc, true>
    typedef typename MaybeScopedAlloc::outer_allocator_type outer_type;
    typedef typename outermost_allocator_type_impl<outer_type>::type type;
 
-   static type &get(MaybeScopedAlloc &a)
+   BOOST_CONTAINER_FORCEINLINE static type &get(MaybeScopedAlloc &a)
    {  return outermost_allocator_imp<outer_type>::get(a.outer_allocator());  }
 
-   static const type &get(const MaybeScopedAlloc &a)
+   BOOST_CONTAINER_FORCEINLINE static const type &get(const MaybeScopedAlloc &a)
    {  return outermost_allocator_imp<outer_type>::get(a.outer_allocator());  }
 };
 
@@ -112,12 +112,12 @@ struct outermost_allocator
 {};
 
 template <typename Allocator>
-typename outermost_allocator<Allocator>::type &
+BOOST_CONTAINER_FORCEINLINE typename outermost_allocator<Allocator>::type &
    get_outermost_allocator(Allocator &a)
 {  return outermost_allocator<Allocator>::get(a);   }
 
 template <typename Allocator>
-const typename outermost_allocator<Allocator>::type &
+BOOST_CONTAINER_FORCEINLINE const typename outermost_allocator<Allocator>::type &
    get_outermost_allocator(const Allocator &a)
 {  return outermost_allocator<Allocator>::get(a);   }
 
@@ -161,34 +161,34 @@ class scoped_allocator_adaptor_base
       inner_allocator_type::is_always_equal::value
       > is_always_equal;
 
-   scoped_allocator_adaptor_base()
+   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base()
       {}
 
    template <class OuterA2>
-   scoped_allocator_adaptor_base(BOOST_FWD_REF(OuterA2) outerAlloc, const InnerAllocs &...args)
+   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base(BOOST_FWD_REF(OuterA2) outerAlloc, const InnerAllocs &...args)
       : outer_allocator_type(::boost::forward<OuterA2>(outerAlloc))
       , m_inner(args...)
       {}
 
-   scoped_allocator_adaptor_base(const scoped_allocator_adaptor_base& other)
+   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base(const scoped_allocator_adaptor_base& other)
       : outer_allocator_type(other.outer_allocator())
       , m_inner(other.inner_allocator())
       {}
 
-   scoped_allocator_adaptor_base(BOOST_RV_REF(scoped_allocator_adaptor_base) other)
+   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base(BOOST_RV_REF(scoped_allocator_adaptor_base) other)
       : outer_allocator_type(::boost::move(other.outer_allocator()))
       , m_inner(::boost::move(other.inner_allocator()))
       {}
 
    template <class OuterA2>
-   scoped_allocator_adaptor_base
+   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base
       (const scoped_allocator_adaptor_base<OuterA2, InnerAllocs...>& other)
       : outer_allocator_type(other.outer_allocator())
       , m_inner(other.inner_allocator())
       {}
 
    template <class OuterA2>
-   scoped_allocator_adaptor_base
+   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base
       (BOOST_RV_REF_BEG scoped_allocator_adaptor_base
          <OuterA2, InnerAllocs...> BOOST_RV_REF_END other)
       : outer_allocator_type(other.outer_allocator())
@@ -199,7 +199,7 @@ class scoped_allocator_adaptor_base
    struct internal_type_t{};
 
    template <class OuterA2>
-   scoped_allocator_adaptor_base
+   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base
       ( internal_type_t
       , BOOST_FWD_REF(OuterA2) outerAlloc
       , const inner_allocator_type &inner)
@@ -209,7 +209,7 @@ class scoped_allocator_adaptor_base
 
    public:
 
-   scoped_allocator_adaptor_base &operator=
+   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base &operator=
       (BOOST_COPY_ASSIGN_REF(scoped_allocator_adaptor_base) other)
    {
       outer_allocator_type::operator=(other.outer_allocator());
@@ -217,35 +217,35 @@ class scoped_allocator_adaptor_base
       return *this;
    }
 
-   scoped_allocator_adaptor_base &operator=(BOOST_RV_REF(scoped_allocator_adaptor_base) other)
+   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base &operator=(BOOST_RV_REF(scoped_allocator_adaptor_base) other)
    {
       outer_allocator_type::operator=(boost::move(other.outer_allocator()));
       m_inner = ::boost::move(other.inner_allocator());
       return *this;
    }
 
-   void swap(scoped_allocator_adaptor_base &r)
+   BOOST_CONTAINER_FORCEINLINE void swap(scoped_allocator_adaptor_base &r)
    {
       boost::adl_move_swap(this->outer_allocator(), r.outer_allocator());
       boost::adl_move_swap(this->m_inner, r.inner_allocator());
    }
 
-   friend void swap(scoped_allocator_adaptor_base &l, scoped_allocator_adaptor_base &r)
+   BOOST_CONTAINER_FORCEINLINE friend void swap(scoped_allocator_adaptor_base &l, scoped_allocator_adaptor_base &r)
    {  l.swap(r);  }
 
-   inner_allocator_type&       inner_allocator() BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE inner_allocator_type&       inner_allocator() BOOST_NOEXCEPT_OR_NOTHROW
       { return m_inner; }
 
-   inner_allocator_type const& inner_allocator() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE inner_allocator_type const& inner_allocator() const BOOST_NOEXCEPT_OR_NOTHROW
       { return m_inner; }
 
-   outer_allocator_type      & outer_allocator() BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE outer_allocator_type      & outer_allocator() BOOST_NOEXCEPT_OR_NOTHROW
       { return static_cast<outer_allocator_type&>(*this); }
 
-   const outer_allocator_type &outer_allocator() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE const outer_allocator_type &outer_allocator() const BOOST_NOEXCEPT_OR_NOTHROW
       { return static_cast<const outer_allocator_type&>(*this); }
 
-   scoped_allocator_type select_on_container_copy_construction() const
+   BOOST_CONTAINER_FORCEINLINE scoped_allocator_type select_on_container_copy_construction() const
    {
       return scoped_allocator_type
          (internal_type_t()
@@ -304,33 +304,33 @@ class scoped_allocator_adaptor_base<OuterAlloc, true, BOOST_MOVE_TARG##N>\
       inner_allocator_type::is_always_equal::value\
       > is_always_equal;\
    \
-   scoped_allocator_adaptor_base(){}\
+   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base(){}\
    \
    template <class OuterA2>\
-   scoped_allocator_adaptor_base(BOOST_FWD_REF(OuterA2) outerAlloc, BOOST_MOVE_CREF##N)\
+   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base(BOOST_FWD_REF(OuterA2) outerAlloc, BOOST_MOVE_CREF##N)\
       : outer_allocator_type(::boost::forward<OuterA2>(outerAlloc))\
       , m_inner(BOOST_MOVE_ARG##N)\
       {}\
    \
-   scoped_allocator_adaptor_base(const scoped_allocator_adaptor_base& other)\
+   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base(const scoped_allocator_adaptor_base& other)\
       : outer_allocator_type(other.outer_allocator())\
       , m_inner(other.inner_allocator())\
       {}\
    \
-   scoped_allocator_adaptor_base(BOOST_RV_REF(scoped_allocator_adaptor_base) other)\
+   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base(BOOST_RV_REF(scoped_allocator_adaptor_base) other)\
       : outer_allocator_type(::boost::move(other.outer_allocator()))\
       , m_inner(::boost::move(other.inner_allocator()))\
       {}\
    \
    template <class OuterA2>\
-   scoped_allocator_adaptor_base\
+   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base\
       (const scoped_allocator_adaptor_base<OuterA2, true, BOOST_MOVE_TARG##N>& other)\
       : outer_allocator_type(other.outer_allocator())\
       , m_inner(other.inner_allocator())\
       {}\
    \
    template <class OuterA2>\
-   scoped_allocator_adaptor_base\
+   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base\
       (BOOST_RV_REF_BEG scoped_allocator_adaptor_base<OuterA2, true, BOOST_MOVE_TARG##N> BOOST_RV_REF_END other)\
       : outer_allocator_type(other.outer_allocator())\
       , m_inner(other.inner_allocator())\
@@ -340,14 +340,14 @@ class scoped_allocator_adaptor_base<OuterAlloc, true, BOOST_MOVE_TARG##N>\
    struct internal_type_t{};\
    \
    template <class OuterA2>\
-   scoped_allocator_adaptor_base\
+   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base\
       ( internal_type_t, BOOST_FWD_REF(OuterA2) outerAlloc, const inner_allocator_type &inner)\
       : outer_allocator_type(::boost::forward<OuterA2>(outerAlloc))\
       , m_inner(inner)\
    {}\
    \
    public:\
-   scoped_allocator_adaptor_base &operator=\
+   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base &operator=\
       (BOOST_COPY_ASSIGN_REF(scoped_allocator_adaptor_base) other)\
    {\
       outer_allocator_type::operator=(other.outer_allocator());\
@@ -355,35 +355,35 @@ class scoped_allocator_adaptor_base<OuterAlloc, true, BOOST_MOVE_TARG##N>\
       return *this;\
    }\
    \
-   scoped_allocator_adaptor_base &operator=(BOOST_RV_REF(scoped_allocator_adaptor_base) other)\
+   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base &operator=(BOOST_RV_REF(scoped_allocator_adaptor_base) other)\
    {\
       outer_allocator_type::operator=(boost::move(other.outer_allocator()));\
       m_inner = ::boost::move(other.inner_allocator());\
       return *this;\
    }\
    \
-   void swap(scoped_allocator_adaptor_base &r)\
+   BOOST_CONTAINER_FORCEINLINE void swap(scoped_allocator_adaptor_base &r)\
    {\
       boost::adl_move_swap(this->outer_allocator(), r.outer_allocator());\
       boost::adl_move_swap(this->m_inner, r.inner_allocator());\
    }\
    \
-   friend void swap(scoped_allocator_adaptor_base &l, scoped_allocator_adaptor_base &r)\
+   BOOST_CONTAINER_FORCEINLINE friend void swap(scoped_allocator_adaptor_base &l, scoped_allocator_adaptor_base &r)\
    {  l.swap(r);  }\
    \
-   inner_allocator_type&       inner_allocator()\
+   BOOST_CONTAINER_FORCEINLINE inner_allocator_type&       inner_allocator()\
       { return m_inner; }\
    \
-   inner_allocator_type const& inner_allocator() const\
+   BOOST_CONTAINER_FORCEINLINE inner_allocator_type const& inner_allocator() const\
       { return m_inner; }\
    \
-   outer_allocator_type      & outer_allocator()\
+   BOOST_CONTAINER_FORCEINLINE outer_allocator_type      & outer_allocator()\
       { return static_cast<outer_allocator_type&>(*this); }\
    \
-   const outer_allocator_type &outer_allocator() const\
+   BOOST_CONTAINER_FORCEINLINE const outer_allocator_type &outer_allocator() const\
       { return static_cast<const outer_allocator_type&>(*this); }\
    \
-   scoped_allocator_type select_on_container_copy_construction() const\
+   BOOST_CONTAINER_FORCEINLINE scoped_allocator_type select_on_container_copy_construction() const\
    {\
       return scoped_allocator_type\
          (internal_type_t()\
@@ -440,30 +440,30 @@ class scoped_allocator_adaptor_base< OuterAlloc BOOST_CONTAINER_SCOPEDALLOC_DUMM
    typedef typename outer_traits_type::
       is_always_equal                           is_always_equal;
 
-   scoped_allocator_adaptor_base()
+   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base()
       {}
 
    template <class OuterA2>
-   scoped_allocator_adaptor_base(BOOST_FWD_REF(OuterA2) outerAlloc)
+   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base(BOOST_FWD_REF(OuterA2) outerAlloc)
       : outer_allocator_type(::boost::forward<OuterA2>(outerAlloc))
       {}
 
-   scoped_allocator_adaptor_base(const scoped_allocator_adaptor_base& other)
+   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base(const scoped_allocator_adaptor_base& other)
       : outer_allocator_type(other.outer_allocator())
       {}
 
-   scoped_allocator_adaptor_base(BOOST_RV_REF(scoped_allocator_adaptor_base) other)
+   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base(BOOST_RV_REF(scoped_allocator_adaptor_base) other)
       : outer_allocator_type(::boost::move(other.outer_allocator()))
       {}
 
    template <class OuterA2>
-   scoped_allocator_adaptor_base
+   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base
       (const scoped_allocator_adaptor_base<OuterA2 BOOST_CONTAINER_SCOPEDALLOC_DUMMYTRUE>& other)
       : outer_allocator_type(other.outer_allocator())
       {}
 
    template <class OuterA2>
-   scoped_allocator_adaptor_base
+   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base
       (BOOST_RV_REF_BEG scoped_allocator_adaptor_base<OuterA2 BOOST_CONTAINER_SCOPEDALLOC_DUMMYTRUE> BOOST_RV_REF_END other)
       : outer_allocator_type(other.outer_allocator())
       {}
@@ -472,44 +472,44 @@ class scoped_allocator_adaptor_base< OuterAlloc BOOST_CONTAINER_SCOPEDALLOC_DUMM
    struct internal_type_t{};
 
    template <class OuterA2>
-   scoped_allocator_adaptor_base(internal_type_t, BOOST_FWD_REF(OuterA2) outerAlloc, const inner_allocator_type &)
+   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base(internal_type_t, BOOST_FWD_REF(OuterA2) outerAlloc, const inner_allocator_type &)
       : outer_allocator_type(::boost::forward<OuterA2>(outerAlloc))
       {}
 
    public:
-   scoped_allocator_adaptor_base &operator=(BOOST_COPY_ASSIGN_REF(scoped_allocator_adaptor_base) other)
+   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base &operator=(BOOST_COPY_ASSIGN_REF(scoped_allocator_adaptor_base) other)
    {
       outer_allocator_type::operator=(other.outer_allocator());
       return *this;
    }
 
-   scoped_allocator_adaptor_base &operator=(BOOST_RV_REF(scoped_allocator_adaptor_base) other)
+   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base &operator=(BOOST_RV_REF(scoped_allocator_adaptor_base) other)
    {
       outer_allocator_type::operator=(boost::move(other.outer_allocator()));
       return *this;
    }
 
-   void swap(scoped_allocator_adaptor_base &r)
+   BOOST_CONTAINER_FORCEINLINE void swap(scoped_allocator_adaptor_base &r)
    {
       boost::adl_move_swap(this->outer_allocator(), r.outer_allocator());
    }
 
-   friend void swap(scoped_allocator_adaptor_base &l, scoped_allocator_adaptor_base &r)
+   BOOST_CONTAINER_FORCEINLINE friend void swap(scoped_allocator_adaptor_base &l, scoped_allocator_adaptor_base &r)
    {  l.swap(r);  }
 
-   inner_allocator_type&       inner_allocator()
+   BOOST_CONTAINER_FORCEINLINE inner_allocator_type&       inner_allocator()
       { return static_cast<inner_allocator_type&>(*this); }
 
-   inner_allocator_type const& inner_allocator() const
+   BOOST_CONTAINER_FORCEINLINE inner_allocator_type const& inner_allocator() const
       { return static_cast<const inner_allocator_type&>(*this); }
 
-   outer_allocator_type      & outer_allocator()
+   BOOST_CONTAINER_FORCEINLINE outer_allocator_type      & outer_allocator()
       { return static_cast<outer_allocator_type&>(*this); }
 
-   const outer_allocator_type &outer_allocator() const
+   BOOST_CONTAINER_FORCEINLINE const outer_allocator_type &outer_allocator() const
       { return static_cast<const outer_allocator_type&>(*this); }
 
-   scoped_allocator_type select_on_container_copy_construction() const
+   BOOST_CONTAINER_FORCEINLINE scoped_allocator_type select_on_container_copy_construction() const
    {
       return scoped_allocator_type
          (internal_type_t()
@@ -641,21 +641,21 @@ class scoped_allocator_adaptor
 
    //! <b>Effects</b>: value-initializes the OuterAlloc base class
    //! and the inner allocator object.
-   scoped_allocator_adaptor()
+   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor()
       {}
 
-   ~scoped_allocator_adaptor()
+   BOOST_CONTAINER_FORCEINLINE ~scoped_allocator_adaptor()
       {}
 
    //! <b>Effects</b>: initializes each allocator within the adaptor with
    //! the corresponding allocator from other.
-   scoped_allocator_adaptor(const scoped_allocator_adaptor& other)
+   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor(const scoped_allocator_adaptor& other)
       : base_type(other.base())
       {}
 
    //! <b>Effects</b>: move constructs each allocator within the adaptor with
    //! the corresponding allocator from other.
-   scoped_allocator_adaptor(BOOST_RV_REF(scoped_allocator_adaptor) other)
+   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor(BOOST_RV_REF(scoped_allocator_adaptor) other)
       : base_type(::boost::move(other.base()))
       {}
 
@@ -667,14 +667,14 @@ class scoped_allocator_adaptor
    //! with innerAllocs...(hence recursively initializing each allocator within the adaptor with the
    //! corresponding allocator from the argument list).
    template <class OuterA2>
-   scoped_allocator_adaptor(BOOST_FWD_REF(OuterA2) outerAlloc, const InnerAllocs & ...innerAllocs)
+   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor(BOOST_FWD_REF(OuterA2) outerAlloc, const InnerAllocs & ...innerAllocs)
       : base_type(::boost::forward<OuterA2>(outerAlloc), innerAllocs...)
       {}
    #else // #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
    #define BOOST_CONTAINER_SCOPED_ALLOCATOR_ADAPTOR_RELATED_ALLOCATOR_CONSTRUCTOR_CODE(N)\
    template <class OuterA2>\
-   scoped_allocator_adaptor(BOOST_FWD_REF(OuterA2) outerAlloc BOOST_MOVE_I##N BOOST_MOVE_CREF##N)\
+   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor(BOOST_FWD_REF(OuterA2) outerAlloc BOOST_MOVE_I##N BOOST_MOVE_CREF##N)\
       : base_type(::boost::forward<OuterA2>(outerAlloc) BOOST_MOVE_I##N BOOST_MOVE_ARG##N)\
       {}\
    //
@@ -687,7 +687,7 @@ class scoped_allocator_adaptor
    //!
    //! <b>Effects</b>: initializes each allocator within the adaptor with the corresponding allocator from other.
    template <class OuterA2>
-   scoped_allocator_adaptor(const scoped_allocator_adaptor<OuterA2, BOOST_CONTAINER_SCOPEDALLOC_ALLINNER> &other)
+   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor(const scoped_allocator_adaptor<OuterA2, BOOST_CONTAINER_SCOPEDALLOC_ALLINNER> &other)
       : base_type(other.base())
       {}
 
@@ -696,15 +696,15 @@ class scoped_allocator_adaptor
    //! <b>Effects</b>: initializes each allocator within the adaptor with the corresponding allocator
    //! rvalue from other.
    template <class OuterA2>
-   scoped_allocator_adaptor(BOOST_RV_REF_BEG scoped_allocator_adaptor
+   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor(BOOST_RV_REF_BEG scoped_allocator_adaptor
       <OuterA2, BOOST_CONTAINER_SCOPEDALLOC_ALLINNER> BOOST_RV_REF_END other)
       : base_type(::boost::move(other.base()))
       {}
 
-   scoped_allocator_adaptor &operator=(BOOST_COPY_ASSIGN_REF(scoped_allocator_adaptor) other)
+   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor &operator=(BOOST_COPY_ASSIGN_REF(scoped_allocator_adaptor) other)
    {  return static_cast<scoped_allocator_adaptor&>(base_type::operator=(static_cast<const base_type &>(other))); }
 
-   scoped_allocator_adaptor &operator=(BOOST_RV_REF(scoped_allocator_adaptor) other)
+   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor &operator=(BOOST_RV_REF(scoped_allocator_adaptor) other)
    {  return static_cast<scoped_allocator_adaptor&>(base_type::operator=(boost::move(other.base()))); }
 
    #ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
@@ -736,13 +736,13 @@ class scoped_allocator_adaptor
 
    //! <b>Returns</b>:
    //!   <code>allocator_traits<OuterAlloc>:: max_size(outer_allocator())</code>.
-   size_type max_size() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE size_type max_size() const BOOST_NOEXCEPT_OR_NOTHROW
    {  return outer_traits_type::max_size(this->outer_allocator());   }
 
    //! <b>Effects</b>:
    //!   calls <code>OUTERMOST_ALLOC_TRAITS(*this):: destroy(OUTERMOST(*this), p)</code>.
    template <class T>
-   void destroy(T* p) BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE void destroy(T* p) BOOST_NOEXCEPT_OR_NOTHROW
    {
       allocator_traits<typename outermost_allocator<OuterAlloc>::type>
          ::destroy(get_outermost_allocator(this->outer_allocator()), p);
@@ -750,17 +750,17 @@ class scoped_allocator_adaptor
 
    //! <b>Returns</b>:
    //! <code>allocator_traits<OuterAlloc>::allocate(outer_allocator(), n)</code>.
-   pointer allocate(size_type n)
+   BOOST_CONTAINER_FORCEINLINE pointer allocate(size_type n)
    {  return outer_traits_type::allocate(this->outer_allocator(), n);   }
 
    //! <b>Returns</b>:
    //! <code>allocator_traits<OuterAlloc>::allocate(outer_allocator(), n, hint)</code>.
-   pointer allocate(size_type n, const_void_pointer hint)
+   BOOST_CONTAINER_FORCEINLINE pointer allocate(size_type n, const_void_pointer hint)
    {  return outer_traits_type::allocate(this->outer_allocator(), n, hint);   }
 
    //! <b>Effects</b>:
    //! <code>allocator_traits<OuterAlloc>::deallocate(outer_allocator(), p, n)</code>.
-   void deallocate(pointer p, size_type n)
+   BOOST_CONTAINER_FORCEINLINE void deallocate(pointer p, size_type n)
    {  outer_traits_type::deallocate(this->outer_allocator(), p, n);  }
 
    #ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
@@ -772,9 +772,9 @@ class scoped_allocator_adaptor
    #endif   //BOOST_CONTAINER_DOXYGEN_INVOKED
 
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
-   base_type &base()             { return *this; }
+   BOOST_CONTAINER_FORCEINLINE base_type &base()             { return *this; }
 
-   const base_type &base() const { return *this; }
+   BOOST_CONTAINER_FORCEINLINE const base_type &base() const { return *this; }
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
    #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
@@ -808,7 +808,7 @@ class scoped_allocator_adaptor
    //! to true but the specific constructor does not take an allocator. This definition prevents a silent
    //! failure to pass an inner allocator to a contained element. -end note]
    template < typename T, class ...Args>
-   void construct(T* p, BOOST_FWD_REF(Args)...args)
+   BOOST_CONTAINER_FORCEINLINE void construct(T* p, BOOST_FWD_REF(Args)...args)
    {
       dtl::dispatch_uses_allocator
          ( (get_outermost_allocator)(this->outer_allocator())
@@ -821,7 +821,7 @@ class scoped_allocator_adaptor
    //overload selection problems when the first parameter is a pair.
    #define BOOST_CONTAINER_SCOPED_ALLOCATOR_CONSTRUCT_CODE(N) \
    template < typename T BOOST_MOVE_I##N BOOST_MOVE_CLASSQ##N >\
-   void construct(T* p BOOST_MOVE_I##N BOOST_MOVE_UREFQ##N)\
+   BOOST_CONTAINER_FORCEINLINE void construct(T* p BOOST_MOVE_I##N BOOST_MOVE_UREFQ##N)\
    {\
       dtl::dispatch_uses_allocator\
          ( (get_outermost_allocator)(this->outer_allocator())\
@@ -838,7 +838,7 @@ class scoped_allocator_adaptor
    public:
    //Internal function
    template <class OuterA2>
-   scoped_allocator_adaptor(internal_type_t, BOOST_FWD_REF(OuterA2) outer, const inner_allocator_type& inner)
+   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor(internal_type_t, BOOST_FWD_REF(OuterA2) outer, const inner_allocator_type& inner)
       : base_type(internal_type_t(), ::boost::forward<OuterA2>(outer), inner)
    {}
 
@@ -853,17 +853,17 @@ struct scoped_allocator_operator_equal
    //Optimize equal outer allocator types with 
    //allocator_traits::equal which uses is_always_equal
    template<class IA>
-   static bool equal_outer(const IA &l, const IA &r)
+   BOOST_CONTAINER_FORCEINLINE static bool equal_outer(const IA &l, const IA &r)
    {  return allocator_traits<IA>::equal(l, r);  }
 
    //Otherwise compare it normally
    template<class IA1, class IA2>
-   static bool equal_outer(const IA1 &l, const IA2 &r)
+   BOOST_CONTAINER_FORCEINLINE static bool equal_outer(const IA1 &l, const IA2 &r)
    {  return l == r;  }
 
    //Otherwise compare it normally
    template<class IA>
-   static bool equal_inner(const IA &l, const IA &r)
+   BOOST_CONTAINER_FORCEINLINE static bool equal_inner(const IA &l, const IA &r)
    {  return allocator_traits<IA>::equal(l, r);  }
 };
 
@@ -875,14 +875,14 @@ struct scoped_allocator_operator_equal<true>
    //inner_allocator_type is the same as outer_allocator_type
    //so both types can be different in operator==
    template<class IA1, class IA2>
-   static bool equal_inner(const IA1 &, const IA2 &)
+   BOOST_CONTAINER_FORCEINLINE static bool equal_inner(const IA1 &, const IA2 &)
    {  return true;  }
 };
 
 /// @endcond
 
 template <typename OuterA1, typename OuterA2, BOOST_CONTAINER_SCOPEDALLOC_ALLINNERCLASS>
-inline bool operator==(const scoped_allocator_adaptor<OuterA1, BOOST_CONTAINER_SCOPEDALLOC_ALLINNER>& a
+BOOST_CONTAINER_FORCEINLINE bool operator==(const scoped_allocator_adaptor<OuterA1, BOOST_CONTAINER_SCOPEDALLOC_ALLINNER>& a
                       ,const scoped_allocator_adaptor<OuterA2, BOOST_CONTAINER_SCOPEDALLOC_ALLINNER>& b)
 {
    #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
@@ -896,7 +896,7 @@ inline bool operator==(const scoped_allocator_adaptor<OuterA1, BOOST_CONTAINER_S
 }
 
 template <typename OuterA1, typename OuterA2, BOOST_CONTAINER_SCOPEDALLOC_ALLINNERCLASS>
-inline bool operator!=(const scoped_allocator_adaptor<OuterA1, BOOST_CONTAINER_SCOPEDALLOC_ALLINNER>& a
+BOOST_CONTAINER_FORCEINLINE bool operator!=(const scoped_allocator_adaptor<OuterA1, BOOST_CONTAINER_SCOPEDALLOC_ALLINNER>& a
                       ,const scoped_allocator_adaptor<OuterA2, BOOST_CONTAINER_SCOPEDALLOC_ALLINNER>& b)
 {  return !(a == b);   }