passenger 5.3.3 → 5.3.4

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

@@ -28,6 +28,24 @@
 namespace boost {
 namespace container {
 
+////////////////////////////////////////////////////////////////
+//
+//
+//       OPTIONS FOR ASSOCIATIVE TREE-BASED CONTAINERS
+//
+//
+////////////////////////////////////////////////////////////////
+
+//! Enumeration used to configure ordered associative containers
+//! with a concrete tree implementation.
+enum tree_type_enum
+{
+   red_black_tree,
+   avl_tree,
+   scapegoat_tree,
+   splay_tree
+};
+
 #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
 template<tree_type_enum TreeType, bool OptimizeSize>
@@ -37,6 +55,8 @@ struct tree_opt
    static const bool optimize_size = OptimizeSize;
 };
 
+typedef tree_opt<red_black_tree, true> tree_assoc_defaults;
+
 #endif   //!defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
 //!This option setter specifies the underlying tree type
@@ -72,6 +92,151 @@ struct tree_assoc_options
    typedef implementation_defined type;
 };
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+//! Helper alias metafunction to combine options into a single type to be used
+//! by tree-based associative containers
+template<class ...Options>
+using tree_assoc_options_t = typename boost::container::tree_assoc_options<Options...>::type;
+
+#endif
+
+////////////////////////////////////////////////////////////////
+//
+//
+//          OPTIONS FOR VECTOR-BASED CONTAINERS
+//
+//
+////////////////////////////////////////////////////////////////
+
+#if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+
+template<class AllocTraits, class StoredSizeType>
+struct get_stored_size_type_with_alloctraits
+{
+   typedef StoredSizeType type;
+};
+
+template<class AllocTraits>
+struct get_stored_size_type_with_alloctraits<AllocTraits, void>
+{
+   typedef typename AllocTraits::size_type type;
+};
+
+template<class GrowthType, class StoredSizeType>
+struct vector_opt
+{
+   typedef GrowthType      growth_factor_type;
+   typedef StoredSizeType  stored_size_type;
+
+   template<class AllocTraits>
+   struct get_stored_size_type
+      : get_stored_size_type_with_alloctraits<AllocTraits, StoredSizeType>
+   {};
+};
+
+class default_next_capacity;
+
+typedef vector_opt<void, void> vector_null_opt;
+
+#else    //!defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+
+//!This growth factor argument specifies that the container should increase it's
+//!capacity a 50% when existing capacity is exhausted.
+struct growth_factor_50{};
+
+//!This growth factor argument specifies that the container should increase it's
+//!capacity a 60% when existing capacity is exhausted.
+struct growth_factor_60{};
+
+//!This growth factor argument specifies that the container should increase it's
+//!capacity a 100% (doubling its capacity) when existing capacity is exhausted.
+struct growth_factor_100{};
+
+#endif   //!defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+
+//!This option setter specifies the growth factor strategy of the underlying vector.
+//!
+//!\tparam GrowthFactor A function object that has the following signature:<br/><br/>
+//!`template<class SizeType>`<br/>
+//!`SizeType operator()(SizeType cur_cap, SizeType add_min_cap, SizeType max_cap) const;`.<br/><br/>
+//!`cur_cap` is the current capacity, `add_min_cap` is the minimum additional capacity
+//!we want to achieve and `max_cap` is the maximum capacity that the allocator or other 
+//!factors allow. The implementation should return a value between `cur_cap` + `add_min_cap`
+//!and `max_cap`. `cur_cap` + `add_min_cap` is guaranteed not to overflow/wraparound,
+//! but the implementation should handle wraparound produced by the growth factor.
+//!
+//!Predefined growth factors that can be passed as arguments to this option are:
+//!\c boost::container::growth_factor_50
+//!\c boost::container::growth_factor_60
+//!\c boost::container::growth_factor_100
+//!
+//!If this option is not specified, a default will be used by the container.
+BOOST_INTRUSIVE_OPTION_TYPE(growth_factor, GrowthFactor, GrowthFactor, growth_factor_type)
+
+//!This option specifies the unsigned integer type that a user wants the container
+//!to use to hold size-related information inside a container (e.g. current size, current capacity).
+//!
+//!\tparam StoredSizeType A unsigned integer type. It shall be smaller than than the size
+//! of the size_type deduced from `allocator_traits<A>::size_type` or the same type.
+//!
+//!If the maximum capacity() to be used is limited, a user can try to use 8-bit, 16-bit 
+//!(e.g. in 32-bit machines), or 32-bit size types (e.g. in a 64 bit machine) to see if some
+//!memory can be saved for empty vectors. This could potentially performance benefits due to better
+//!cache usage.
+//!
+//!Note that alignment requirements can disallow theoritical space savings. Example:
+//!\c vector holds a pointer and two size types (for size and capacity), in a 32 bit machine
+//!a 8 bit size type (total size: 4 byte pointer + 2 x 1 byte sizes = 6 bytes) 
+//!will not save space when comparing two 16-bit size types because usually
+//!a 32 bit alignment is required for vector and the size will be rounded to 8 bytes. In a 64-bit
+//!machine a 16 bit size type does not usually save memory when comparing to a 32-bit size type.
+//!Measure the size of the resulting container and do not assume a smaller \c stored_size
+//!will always lead to a smaller sizeof(container).
+//!
+//!If a user tries to insert more elements than representable by \c stored_size, vector
+//!will throw a length_error.
+//!
+//!If this option is not specified, `allocator_traits<A>::size_type` (usually std::size_t) will
+//!be used to store size-related information inside the container.
+BOOST_INTRUSIVE_OPTION_TYPE(stored_size, StoredSizeType, StoredSizeType, stored_size_type)
+
+//! Helper metafunction to combine options into a single type to be used
+//! by \c boost::container::vector.
+//! Supported options are: \c boost::container::growth_factor and \c boost::container::stored_size
+#if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) || defined(BOOST_CONTAINER_VARIADIC_TEMPLATES)
+template<class ...Options>
+#else
+template<class O1 = void, class O2 = void, class O3 = void, class O4 = void>
+#endif
+struct vector_options
+{
+   /// @cond
+   typedef typename ::boost::intrusive::pack_options
+      < vector_null_opt,
+      #if !defined(BOOST_CONTAINER_VARIADIC_TEMPLATES)
+      O1, O2, O3, O4
+      #else
+      Options...
+      #endif
+      >::type packed_options;
+   typedef vector_opt< typename packed_options::growth_factor_type
+                     , typename packed_options::stored_size_type> implementation_defined;
+   /// @endcond
+   typedef implementation_defined type;
+};
+
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+//! Helper alias metafunction to combine options into a single type to be used
+//! by \c boost::container::vector.
+//! Supported options are: \c boost::container::growth_factor and \c boost::container::stored_size
+template<class ...Options>
+using vector_options_t = typename boost::container::vector_options<Options...>::type;
+
+#endif
+
+
 }  //namespace container {
 }  //namespace boost {
 

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

@@ -26,14 +26,12 @@ namespace pmr {
 
 template <class Key
          ,class T
-         ,class Compare  = std::less<Key>
-         ,class Options = tree_assoc_defaults >
+         ,class Compare  = std::less<Key > >
 using flat_map = boost::container::flat_map<Key, T, Compare, polymorphic_allocator<std::pair<Key, T> > >;
 
 template <class Key
          ,class T
-         ,class Compare  = std::less<Key>
-         ,class Options = tree_assoc_defaults >
+         ,class Compare  = std::less<Key> >
 using flat_multimap = boost::container::flat_multimap<Key, T, Compare, polymorphic_allocator<std::pair<Key, T> > >;
 
 #endif
@@ -42,8 +40,7 @@ using flat_multimap = boost::container::flat_multimap<Key, T, Compare, polymorph
 //! that uses a polymorphic allocator
 template <class Key
          ,class T
-         ,class Compare  = std::less<Key>
-         ,class Options = tree_assoc_defaults >
+         ,class Compare  = std::less<Key> >
 struct flat_map_of
 {
    typedef boost::container::flat_map<Key, T, Compare, polymorphic_allocator<std::pair<Key, T> > > type;
@@ -53,8 +50,7 @@ struct flat_map_of
 //! that uses a polymorphic allocator
 template <class Key
          ,class T
-         ,class Compare  = std::less<Key>
-         ,class Options = tree_assoc_defaults >
+         ,class Compare  = std::less<Key> >
 struct flat_multimap_of
 {
    typedef boost::container::flat_multimap<Key, T, Compare, polymorphic_allocator<std::pair<Key, T> > > type;

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

@@ -25,13 +25,11 @@ namespace pmr {
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
 
 template <class Key
-         ,class Compare = std::less<Key>
-         ,class Options = tree_assoc_defaults >
+         ,class Compare = std::less<Key> >
 using flat_set = boost::container::flat_set<Key, Compare, polymorphic_allocator<Key> >;
 
 template <class Key
-         ,class Compare = std::less<Key>
-         ,class Options = tree_assoc_defaults >
+         ,class Compare = std::less<Key> >
 using flat_multiset = boost::container::flat_multiset<Key, Compare, polymorphic_allocator<Key> >;
 
 #endif
@@ -39,8 +37,7 @@ using flat_multiset = boost::container::flat_multiset<Key, Compare, polymorphic_
 //! A portable metafunction to obtain a flat_set
 //! that uses a polymorphic allocator
 template <class Key
-         ,class Compare = std::less<Key>
-         ,class Options = tree_assoc_defaults >
+         ,class Compare = std::less<Key> >
 struct flat_set_of
 {
    typedef boost::container::flat_set<Key, Compare, polymorphic_allocator<Key> > type;
@@ -49,8 +46,7 @@ struct flat_set_of
 //! A portable metafunction to obtain a flat_multiset
 //! that uses a polymorphic allocator
 template <class Key
-         ,class Compare = std::less<Key>
-         ,class Options = tree_assoc_defaults >
+         ,class Compare = std::less<Key> >
 struct flat_multiset_of
 {
    typedef boost::container::flat_multiset<Key, Compare, polymorphic_allocator<Key> > type;

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

@@ -27,13 +27,13 @@ namespace pmr {
 template <class Key
          ,class T
          ,class Compare  = std::less<Key>
-         ,class Options = tree_assoc_defaults >
+         ,class Options = void >
 using map = boost::container::map<Key, T, Compare, polymorphic_allocator<std::pair<const Key, T> >, Options>;
 
 template <class Key
          ,class T
          ,class Compare  = std::less<Key>
-         ,class Options = tree_assoc_defaults >
+         ,class Options = void >
 using multimap = boost::container::multimap<Key, T, Compare, polymorphic_allocator<std::pair<const Key, T> >, Options>;
 
 #endif
@@ -43,7 +43,7 @@ using multimap = boost::container::multimap<Key, T, Compare, polymorphic_allocat
 template <class Key
          ,class T
          ,class Compare  = std::less<Key>
-         ,class Options = tree_assoc_defaults >
+         ,class Options = void >
 struct map_of
 {
    typedef boost::container::map<Key, T, Compare, polymorphic_allocator<std::pair<const Key, T> >, Options> type;
@@ -54,7 +54,7 @@ struct map_of
 template <class Key
          ,class T
          ,class Compare  = std::less<Key>
-         ,class Options = tree_assoc_defaults >
+         ,class Options = void >
 struct multimap_of
 {
    typedef boost::container::multimap<Key, T, Compare, polymorphic_allocator<std::pair<const Key, T> >, Options> type;

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

@@ -92,20 +92,20 @@ class polymorphic_allocator
 
    #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
    //! <b>Requires</b>: Uses-allocator construction of T with allocator
-   //!   `this->resource()` and constructor arguments `std::forward<Args>(args)...`
+   //!   `*this` and constructor arguments `std::forward<Args>(args)...`
    //!   is well-formed. [Note: uses-allocator construction is always well formed for
    //!   types that do not use allocators. - end note]
    //!
    //! <b>Effects</b>: Construct a T object at p by uses-allocator construction with allocator
-   //!   `this->resource()` and constructor arguments `std::forward<Args>(args)...`.
+   //!   `*this` and constructor arguments `std::forward<Args>(args)...`.
    //!
    //! <b>Throws</b>: Nothing unless the constructor for T throws.
    template < typename U, class ...Args>
    void construct(U* p, BOOST_FWD_REF(Args)...args)
    {
       new_allocator<U> na;
-      container_detail::dispatch_uses_allocator
-         (na, this->resource(), p, ::boost::forward<Args>(args)...);
+      dtl::dispatch_uses_allocator
+         (na, *this, p, ::boost::forward<Args>(args)...);
    }
 
    #else // #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
@@ -117,8 +117,8 @@ class polymorphic_allocator
    void construct(U* p BOOST_MOVE_I##N BOOST_MOVE_UREFQ##N)\
    {\
       new_allocator<U> na;\
-      container_detail::dispatch_uses_allocator\
-         (na, this->resource(), p BOOST_MOVE_I##N BOOST_MOVE_FWDQ##N);\
+      dtl::dispatch_uses_allocator\
+         (na, *this, p BOOST_MOVE_I##N BOOST_MOVE_FWDQ##N);\
    }\
    //
    BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_PMR_POLYMORPHIC_ALLOCATOR_CONSTRUCT_CODE)

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

@@ -57,7 +57,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((container_detail::is_same<typename Allocator::value_type, char>::value));
+      BOOST_STATIC_ASSERT((dtl::is_same<typename Allocator::value_type, char>::value));
    }
    #endif
 

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

@@ -26,12 +26,12 @@ namespace pmr {
 
 template <class Key
          ,class Compare = std::less<Key>
-         ,class Options = tree_assoc_defaults >
+         ,class Options = void >
 using set = boost::container::set<Key, Compare, polymorphic_allocator<Key>, Options>;
 
 template <class Key
          ,class Compare = std::less<Key>
-         ,class Options = tree_assoc_defaults >
+         ,class Options = void >
 using multiset = boost::container::multiset<Key, Compare, polymorphic_allocator<Key>, Options>;
 
 #endif
@@ -40,7 +40,7 @@ using multiset = boost::container::multiset<Key, Compare, polymorphic_allocator<
 //! that uses a polymorphic allocator
 template <class Key
          ,class Compare = std::less<Key>
-         ,class Options = tree_assoc_defaults >
+         ,class Options = void >
 struct set_of
 {
    typedef boost::container::set<Key, Compare, polymorphic_allocator<Key>, Options> type;
@@ -50,7 +50,7 @@ struct set_of
 //! that uses a polymorphic allocator
 template <class Key
          ,class Compare = std::less<Key>
-         ,class Options = tree_assoc_defaults >
+         ,class Options = void >
 struct multiset_of
 {
    typedef boost::container::multiset<Key, Compare, polymorphic_allocator<Key>, Options> type;

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

@@ -44,7 +44,7 @@ namespace boost { namespace container {
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
-namespace container_detail {
+namespace dtl {
 
 template <typename Allocator>
 struct is_scoped_allocator_imp
@@ -99,16 +99,16 @@ struct outermost_allocator_imp<MaybeScopedAlloc, true>
    {  return outermost_allocator_imp<outer_type>::get(a.outer_allocator());  }
 };
 
-}  //namespace container_detail {
+}  //namespace dtl {
 
 template <typename Allocator>
 struct is_scoped_allocator
-   : container_detail::is_scoped_allocator_imp<Allocator>
+   : dtl::is_scoped_allocator_imp<Allocator>
 {};
 
 template <typename Allocator>
 struct outermost_allocator
-   : container_detail::outermost_allocator_imp<Allocator>
+   : dtl::outermost_allocator_imp<Allocator>
 {};
 
 template <typename Allocator>
@@ -121,7 +121,7 @@ const typename outermost_allocator<Allocator>::type &
    get_outermost_allocator(const Allocator &a)
 {  return outermost_allocator<Allocator>::get(a);   }
 
-namespace container_detail {
+namespace dtl {
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
@@ -144,19 +144,19 @@ class scoped_allocator_adaptor_base
    typedef allocator_traits<inner_allocator_type>     inner_traits_type;
    typedef scoped_allocator_adaptor
       <OuterAlloc, InnerAllocs...>                    scoped_allocator_type;
-   typedef container_detail::bool_<
+   typedef dtl::bool_<
       outer_traits_type::propagate_on_container_copy_assignment::value ||
       inner_allocator_type::propagate_on_container_copy_assignment::value
       > propagate_on_container_copy_assignment;
-   typedef container_detail::bool_<
+   typedef dtl::bool_<
       outer_traits_type::propagate_on_container_move_assignment::value ||
       inner_allocator_type::propagate_on_container_move_assignment::value
       > propagate_on_container_move_assignment;
-   typedef container_detail::bool_<
+   typedef dtl::bool_<
       outer_traits_type::propagate_on_container_swap::value ||
       inner_allocator_type::propagate_on_container_swap::value
       > propagate_on_container_swap;
-   typedef container_detail::bool_<
+   typedef dtl::bool_<
       outer_traits_type::is_always_equal::value &&
       inner_allocator_type::is_always_equal::value
       > is_always_equal;
@@ -286,20 +286,20 @@ class scoped_allocator_adaptor_base<OuterAlloc, true, BOOST_MOVE_TARG##N>\
    typedef scoped_allocator_adaptor<BOOST_MOVE_TARG##N> inner_allocator_type;\
    typedef scoped_allocator_adaptor<OuterAlloc, BOOST_MOVE_TARG##N> scoped_allocator_type;\
    typedef allocator_traits<inner_allocator_type> inner_traits_type;\
-   typedef container_detail::bool_<\
+   typedef dtl::bool_<\
       outer_traits_type::propagate_on_container_copy_assignment::value ||\
       inner_allocator_type::propagate_on_container_copy_assignment::value\
       > propagate_on_container_copy_assignment;\
-   typedef container_detail::bool_<\
+   typedef dtl::bool_<\
       outer_traits_type::propagate_on_container_move_assignment::value ||\
       inner_allocator_type::propagate_on_container_move_assignment::value\
       > propagate_on_container_move_assignment;\
-   typedef container_detail::bool_<\
+   typedef dtl::bool_<\
       outer_traits_type::propagate_on_container_swap::value ||\
       inner_allocator_type::propagate_on_container_swap::value\
       > propagate_on_container_swap;\
    \
-   typedef container_detail::bool_<\
+   typedef dtl::bool_<\
       outer_traits_type::is_always_equal::value &&\
       inner_allocator_type::is_always_equal::value\
       > is_always_equal;\
@@ -521,7 +521,7 @@ class scoped_allocator_adaptor_base< OuterAlloc BOOST_CONTAINER_SCOPEDALLOC_DUMM
    }
 };
 
-}  //namespace container_detail {
+}  //namespace dtl {
 
 #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
@@ -578,14 +578,14 @@ template <typename OuterAlloc, BOOST_MOVE_CLASS9>
 class scoped_allocator_adaptor
 #endif
 
-   : public container_detail::scoped_allocator_adaptor_base
+   : public dtl::scoped_allocator_adaptor_base
          <OuterAlloc BOOST_CONTAINER_SCOPEDALLOC_DUMMYTRUE, BOOST_CONTAINER_SCOPEDALLOC_ALLINNER>
 {
    BOOST_COPYABLE_AND_MOVABLE(scoped_allocator_adaptor)
 
    public:
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
-   typedef container_detail::scoped_allocator_adaptor_base
+   typedef dtl::scoped_allocator_adaptor_base
       <OuterAlloc BOOST_CONTAINER_SCOPEDALLOC_DUMMYTRUE, BOOST_CONTAINER_SCOPEDALLOC_ALLINNER> base_type;
    typedef typename base_type::internal_type_t              internal_type_t;
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
@@ -810,7 +810,7 @@ class scoped_allocator_adaptor
    template < typename T, class ...Args>
    void construct(T* p, BOOST_FWD_REF(Args)...args)
    {
-      container_detail::dispatch_uses_allocator
+      dtl::dispatch_uses_allocator
          ( (get_outermost_allocator)(this->outer_allocator())
          , this->inner_allocator(), p, ::boost::forward<Args>(args)...);
    }
@@ -823,7 +823,7 @@ class scoped_allocator_adaptor
    template < typename T BOOST_MOVE_I##N BOOST_MOVE_CLASSQ##N >\
    void construct(T* p BOOST_MOVE_I##N BOOST_MOVE_UREFQ##N)\
    {\
-      container_detail::dispatch_uses_allocator\
+      dtl::dispatch_uses_allocator\
          ( (get_outermost_allocator)(this->outer_allocator())\
          , this->inner_allocator(), p BOOST_MOVE_I##N BOOST_MOVE_FWDQ##N);\
    }\
@@ -888,7 +888,7 @@ inline bool operator==(const scoped_allocator_adaptor<OuterA1, BOOST_CONTAINER_S
    #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
    const bool has_zero_inner = sizeof...(InnerAllocs) == 0u;
    #else
-   const bool has_zero_inner = boost::container::container_detail::is_same<P0, void>::value;
+   const bool has_zero_inner = boost::container::dtl::is_same<P0, void>::value;
    #endif
    typedef scoped_allocator_operator_equal<has_zero_inner> equal_t;
    return equal_t::equal_outer(a.outer_allocator(), b.outer_allocator()) &&