passenger 6.0.19 → 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/mutex.hpp

@@ -30,6 +30,8 @@
 
 // Extremely Light-Weight wrapper classes for OS thread synchronization
 
+
+
 #define BOOST_MUTEX_HELPER_NONE         0
 #define BOOST_MUTEX_HELPER_WIN32        1
 #define BOOST_MUTEX_HELPER_PTHREAD      2
@@ -50,14 +52,6 @@
          defined(__i386__) || defined(__x86_64__))) ||                     \
       (defined(_MSC_VER) && _MSC_VER>=1310))
       #define BOOST_MUTEX_HELPER BOOST_MUTEX_HELPER_SPINLOCKS
-   #endif
-
-   #if defined(BOOST_WINDOWS)
-      #include <boost/winapi/critical_section.hpp>
-      #include <boost/winapi/thread.hpp>
-      #ifndef BOOST_MUTEX_HELPER
-         #define BOOST_MUTEX_HELPER BOOST_MUTEX_HELPER_WIN32
-      #endif
    #elif defined(BOOST_HAS_UNISTD_H)
       #include <unistd.h>
       #if !defined(BOOST_MUTEX_HELPER) && (defined(_POSIX_THREADS) || defined(BOOST_HAS_PTHREADS))
@@ -74,11 +68,9 @@
    //...
 #elif BOOST_MUTEX_HELPER == BOOST_MUTEX_HELPER_SPINLOCKS
    #if defined(_MSC_VER)
-      #include <boost/detail/interlocked.hpp>
-      #define interlockedcompareexchange _InterlockedCompareExchange
+      #include <intrin.h>
       #define interlockedexchange        _InterlockedExchange
    #elif defined(WIN32) && defined(__GNUC__)
-      #define interlockedcompareexchange(a, b, c) __sync_val_compare_and_swap(a, c, b)
       #define interlockedexchange                 __sync_lock_test_and_set
    #endif /* Win32 */
 
@@ -123,8 +115,52 @@
    /* How to yield for a spin lock */
    #define SPINS_PER_YIELD       63
    #if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
+      #if !defined( BOOST_USE_WINDOWS_H )
+         #if defined (WIN32_PLATFORM_PSPC)
+            #define BOOST_CONTAINERWINAPI_IMPORT BOOST_SYMBOL_IMPORT
+         #elif defined (_WIN32_WCE)
+            #define BOOST_CONTAINERWINAPI_IMPORT
+         #else
+            #define BOOST_CONTAINERWINAPI_IMPORT BOOST_SYMBOL_IMPORT
+         #endif
+
+         #if defined(WINAPI)
+            #define BOOST_CONTAINERWINAPI_WINAPI_CC WINAPI
+         #else
+            #if defined(_M_IX86) || defined(__i386__)
+               #define BOOST_CONTAINERWINAPI_DETAIL_STDCALL __stdcall
+            #else
+               #define BOOST_CONTAINERWINAPI_DETAIL_STDCALL
+            #endif
+            #define BOOST_CONTAINERWINAPI_WINAPI_CC BOOST_CONTAINERWINAPI_DETAIL_STDCALL
+         #endif
+
+         #if !defined(__LP64__)
+         namespace boost {
+            namespace container_winapi {
+            typedef unsigned long DWORD_;
+            #else
+            typedef unsigned int DWORD_;
+            #endif
+            typedef int BOOL_;
+         }}
+
+      extern "C" {
+         BOOST_CONTAINERWINAPI_IMPORT boost::container_winapi::DWORD_ BOOST_CONTAINERWINAPI_WINAPI_CC
+            SleepEx(
+               boost::container_winapi::DWORD_ dwMilliseconds,
+               boost::container_winapi::BOOL_ bAlertable);
+      } // extern "C"
+      #endif
+
+      namespace boost {
+         namespace container_winapi {
+            using ::SleepEx;
+         }
+      }
+
       #define SLEEP_EX_DURATION     50 /* delay for yield/sleep */
-      #define SPIN_LOCK_YIELD  boost::winapi::SleepEx(SLEEP_EX_DURATION, 0)
+      #define SPIN_LOCK_YIELD  boost::container_winapi::SleepEx(SLEEP_EX_DURATION, 0)
    #elif defined (__SVR4) && defined (__sun) /* solaris */
       #include <thread.h>
       #define SPIN_LOCK_YIELD   thr_yield();

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

@@ -45,8 +45,6 @@
 #if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 #include <boost/move/detail/fwd_macros.hpp>
 #endif
-// other
-#include <boost/core/no_exceptions_support.hpp>
 
 
 namespace boost {
@@ -120,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)
@@ -138,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());
@@ -146,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)
    {
@@ -156,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)
    {
@@ -172,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); }
@@ -180,7 +178,7 @@ struct base_node
    private:
    base_node();
 
-   BOOST_CONTAINER_FORCEINLINE ~base_node()
+   inline ~base_node()
    { }
 };
 
@@ -258,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)
@@ -341,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)
@@ -417,26 +415,26 @@ struct node_alloc_holder
    NodePtr create_node_from_key(BOOST_FWD_REF(KeyConvertible) key)
    {
       NodePtr p = this->allocate_one();
-      BOOST_TRY{
+      BOOST_CONTAINER_TRY{
          ::new(boost::movelib::iterator_to_raw_pointer(p), boost_container_new_t()) Node;
          NodeAlloc &na = this->node_alloc();
          node_allocator_traits_type::construct
             (na, dtl::addressof(p->get_real_data().first), boost::forward<KeyConvertible>(key));
-         BOOST_TRY{
+         BOOST_CONTAINER_TRY{
             node_allocator_traits_type::construct(na, dtl::addressof(p->get_real_data().second));
          }
-         BOOST_CATCH(...){
+         BOOST_CONTAINER_CATCH(...){
             node_allocator_traits_type::destroy(na, dtl::addressof(p->get_real_data().first));
-            BOOST_RETHROW;
+            BOOST_CONTAINER_RETHROW;
          }
-         BOOST_CATCH_END
+         BOOST_CONTAINER_CATCH_END
       }
-      BOOST_CATCH(...) {
+      BOOST_CONTAINER_CATCH(...) {
          p->destroy_header();
          this->node_alloc().deallocate(p, 1);
-         BOOST_RETHROW
+         BOOST_CONTAINER_RETHROW
       }
-      BOOST_CATCH_END
+      BOOST_CONTAINER_CATCH_END
       return (p);
    }
 
@@ -470,7 +468,7 @@ struct node_alloc_holder
          chain.clear();
 
          Node *p = 0;
-            BOOST_TRY{
+            BOOST_CONTAINER_TRY{
             Deallocator node_deallocator(NodePtr(), nalloc);
             dtl::scoped_node_destructor<NodeAlloc> sdestructor(nalloc, 0);
             while(n){
@@ -490,16 +488,16 @@ struct node_alloc_holder
             sdestructor.release();
             node_deallocator.release();
          }
-         BOOST_CATCH(...){
+         BOOST_CONTAINER_CATCH(...){
             chain.incorporate_after(chain.last(), &*itbeg, &*itlast, n);
             node_allocator_version_traits_type::deallocate_individual(this->node_alloc(), chain);
-            BOOST_RETHROW
+            BOOST_CONTAINER_RETHROW
          }
-         BOOST_CATCH_END
+         BOOST_CONTAINER_CATCH_END
       }
    }
 
-   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)
@@ -507,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);
    }
@@ -526,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());
@@ -539,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;
@@ -551,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()));
       }
@@ -563,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:
@@ -589,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

@@ -33,7 +33,6 @@
 #include <boost/intrusive/set.hpp>
 #include <boost/intrusive/slist.hpp>
 
-#include <boost/core/no_exceptions_support.hpp>
 #include <boost/assert.hpp>
 #include <cstddef>
 
@@ -85,21 +84,21 @@ class private_node_pool_impl
    {}
 
    //!Destructor. Deallocates all allocated blocks. Never throws
-   ~private_node_pool_impl()
+   inline ~private_node_pool_impl()
    {  this->purge_blocks();  }
 
-   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
-   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);  }
 
-   void *allocate_node()
+   inline void *allocate_node()
    {  return this->priv_alloc_node();  }
 
    //!Deallocates an array pointed by ptr. Never throws
-   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.
@@ -206,7 +205,7 @@ class private_node_pool_impl
          , backup_list.size());
    }
 
-   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
@@ -310,7 +309,7 @@ class private_node_pool_impl
       size_type blocksize =
          (get_rounded_size)(m_real_node_size*m_nodes_per_block, (size_type)alignment_of<node_t>::value);
 
-      BOOST_TRY{
+      BOOST_CONTAINER_TRY{
          for(size_type i = 0; i != num_blocks; ++i){
             //We allocate a new NodeBlock and put it as first
             //element in the free Node list
@@ -326,11 +325,11 @@ class private_node_pool_impl
             }
          }
       }
-      BOOST_CATCH(...){
+      BOOST_CONTAINER_CATCH(...){
          //to-do: if possible, an efficient way to deallocate allocated blocks
-         BOOST_RETHROW
+         BOOST_CONTAINER_RETHROW
       }
-      BOOST_CATCH_END
+      BOOST_CONTAINER_CATCH_END
    }
 
    //!Deprecated, use deallocate_free_blocks

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/placement_new.hpp

@@ -10,14 +10,6 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
-#ifndef BOOST_CONFIG_HPP
-#  include <boost/config.hpp>
-#endif
-
-#if defined(BOOST_HAS_PRAGMA_ONCE)
-#  pragma once
-#endif
-
 #include <cstddef>
 
 struct boost_container_new_t{};