passenger 6.2.0 → 6.2.2

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

@@ -109,7 +109,7 @@ class flat_set
    typedef Key                                                                      value_type;
    typedef typename BOOST_CONTAINER_IMPDEF(tree_t::sequence_type)                   sequence_type;
    typedef typename sequence_type::allocator_type                                   allocator_type;
-   typedef ::boost::container::allocator_traits<allocator_type>                     allocator_traits_type;
+   typedef boost::container::allocator_traits<allocator_type>                     allocator_traits_type;
    typedef typename sequence_type::pointer                                          pointer;
    typedef typename sequence_type::const_pointer                                    const_pointer;
    typedef typename sequence_type::reference                                        reference;
@@ -374,7 +374,7 @@ class flat_set
    //! <b>Effects</b>: Copy constructs a container using the specified allocator.
    //!
    //! <b>Complexity</b>: Linear in x.size().
-   inline flat_set(const flat_set& x, const allocator_type &a)
+   inline flat_set(const flat_set& x, const BOOST_CONTAINER_DOC1ST(allocator_type, typename dtl::type_identity<allocator_type>::type) &a)
       : tree_t(static_cast<const tree_t&>(x), a)
    {}
 
@@ -382,7 +382,7 @@ class flat_set
    //!                 Constructs *this using x's resources.
    //!
    //! <b>Complexity</b>: Constant if a == x.get_allocator(), linear otherwise
-   inline flat_set(BOOST_RV_REF(flat_set) x, const allocator_type &a)
+   inline flat_set(BOOST_RV_REF(flat_set) x, const BOOST_CONTAINER_DOC1ST(allocator_type, typename dtl::type_identity<allocator_type>::type) &a)
       : tree_t(BOOST_MOVE_BASE(tree_t, x), a)
    {}
 
@@ -411,7 +411,7 @@ class flat_set
    flat_set& operator=(std::initializer_list<value_type> il)
    {
        this->clear();
-       this->insert(il.begin(), il.end());
+       this->tree_t::insert_unique_range(il.begin(), il.end());
        return *this;
    }
 #endif
@@ -638,7 +638,7 @@ class flat_set
 
    #endif   // !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
-   #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+   #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
    //! <b>Effects</b>: Inserts x if and only if there is no element in the container
    //!   with key equivalent to the key of x.
    //!
@@ -650,7 +650,8 @@ class flat_set
    //!   to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   std::pair<iterator, bool> insert(const value_type &x);
+   std::pair<iterator, bool> insert(const value_type &x)
+   {  return this->tree_t::insert_unique(x); }
 
    //! <b>Effects</b>: Inserts a new value_type move constructed from the pair if and
    //! only if there is no element in the container with key equivalent to the key of x.
@@ -663,15 +664,35 @@ class flat_set
    //!   to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   std::pair<iterator, bool> insert(value_type &&x);
-   #else
-   private:
-   typedef std::pair<iterator, bool> insert_return_pair;
-   public:
-   BOOST_MOVE_CONVERSION_AWARE_CATCH(insert, value_type, insert_return_pair, this->tree_t::insert_unique)
-   #endif
+   std::pair<iterator, bool> insert(value_type &&x)
+   {  return this->tree_t::insert_unique(boost::move(x)); }
+
+   //! <b>Requires</b>: This overload is available only if
+   //! key_compare::is_transparent exists.
+   //!
+   //! <b>Effects</b>: Inserts a new value_type move constructed from the pair if and
+   //! only if there is no element in the container with key equivalent to the key of x.
+   //!
+   //! <b>Returns</b>: The bool component of the returned pair is true if and only
+   //!   if the insertion takes place, and the iterator component of the pair
+   //!   points to the element with key equivalent to the key of x.
+   //!
+   //! <b>Complexity</b>: Logarithmic search time plus linear insertion
+   //!   to the elements with bigger keys than x.
+   //!
+   //! <b>Note</b>: If an element is inserted it might invalidate elements.
+   template <class K>
+   inline BOOST_CONTAINER_DOC1ST
+      (std::pair<iterator BOOST_MOVE_I bool>
+         , typename dtl::enable_if_c<
+         dtl::is_transparent<key_compare>::value &&                  //transparent
+         !dtl::is_convertible<K BOOST_MOVE_I iterator>::value &&     //not convertible to iterator
+         !dtl::is_convertible<K BOOST_MOVE_I const_iterator>::value  //not convertible to const_iterator
+         BOOST_MOVE_I std::pair<iterator BOOST_MOVE_I bool>
+       >::type)
+      insert(K &&x)
+   {  return this->tree_t::insert_unique(boost::forward<K>(x)); }
 
-   #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
    //! <b>Effects</b>: Inserts a copy of x in the container if and only if there is
    //!   no element in the container with key equivalent to the key of x.
    //!   p is a hint pointing to where the insert should start to search.
@@ -683,9 +704,11 @@ class flat_set
    //!   right before p) plus insertion linear to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   iterator insert(const_iterator p, const value_type &x);
+   iterator insert(const_iterator p, const value_type &x)
+   {  return this->tree_t::insert_unique(p, x); }
 
-   //! <b>Effects</b>: Inserts an element move constructed from x in the container.
+   //! <b>Effects</b>: Move-inserts x in the container if and only if there is
+   //!   no element in the container with key equivalent to the key of x.
    //!   p is a hint pointing to where the insert should start to search.
    //!
    //! <b>Returns</b>: An iterator pointing to the element with key equivalent to the key of x.
@@ -694,8 +717,40 @@ class flat_set
    //!   right before p) plus insertion linear to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   iterator insert(const_iterator p, value_type &&x);
+   iterator insert(const_iterator p, value_type &&x)
+   {  return this->tree_t::insert_unique(p, boost::move(x)); }
+
+   //! <b>Requires</b>: This overload is available only if
+   //! key_compare::is_transparent exists.
+   //!
+   //! <b>Effects</b>: Forward-inserts x in the container if and only if there is
+   //!   no element in the container with key equivalent to the key of x.
+   //!   p is a hint pointing to where the insert should start to search.
+   //!
+   //! <b>Returns</b>: An iterator pointing to the element with key equivalent
+   //!   to the key of x.
+   //!
+   //! <b>Complexity</b>: Logarithmic search time (constant if x is inserted
+   //!   right before p) plus insertion linear to the elements with bigger keys than x.
+   //!
+   //! <b>Note</b>: If an element is inserted it might invalidate elements.
+   template <class K>
+   inline BOOST_CONTAINER_DOC1ST
+      ( iterator
+         , typename dtl::enable_if_c<
+            dtl::is_transparent<key_compare>::value &&                  //transparent
+            !dtl::is_convertible<K BOOST_MOVE_I iterator>::value &&     //not convertible to iterator
+            !dtl::is_convertible<K BOOST_MOVE_I const_iterator>::value  //not convertible to const_iterator
+            BOOST_MOVE_I iterator
+       >::type)
+      insert(const_iterator p, K &&x)
+   {  return this->tree_t::insert_unique(p, boost::forward<K>(x)); }
+
    #else
+   private:
+   typedef std::pair<iterator, bool> insert_return_pair;
+   public:
+   BOOST_MOVE_CONVERSION_AWARE_CATCH(insert, value_type, insert_return_pair, this->tree_t::insert_unique)
    BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG(insert, value_type, iterator, this->tree_t::insert_unique, const_iterator, const_iterator)
    #endif
 
@@ -709,7 +764,7 @@ class flat_set
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class InputIterator>
    inline void insert(InputIterator first, InputIterator last)
-      {  this->tree_t::insert_unique(first, last);  }
+      {  this->tree_t::insert_unique_range(first, last);  }
 
    //! <b>Requires</b>: first, last are not iterators into *this and
    //! must be ordered according to the predicate and must be
@@ -723,7 +778,7 @@ class flat_set
    //! <b>Note</b>: Non-standard extension. If an element is inserted it might invalidate elements.
    template <class InputIterator>
    inline void insert(ordered_unique_range_t, InputIterator first, InputIterator last)
-      {  this->tree_t::insert_unique(ordered_unique_range, first, last);  }
+      {  this->tree_t::insert_unique_range(ordered_unique_range, first, last);  }
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
    //! <b>Effects</b>: inserts each element from the range [il.begin(), il.end()) if and only
@@ -733,7 +788,7 @@ class flat_set
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    inline void insert(std::initializer_list<value_type> il)
-   {  this->tree_t::insert_unique(il.begin(), il.end()); }
+   {  this->tree_t::insert_unique_range(il.begin(), il.end()); }
 
    //! <b>Requires</b>: Range [il.begin(), il.end()) must be ordered according to the predicate
    //! and must be unique values.
@@ -745,7 +800,7 @@ class flat_set
    //!
    //! <b>Note</b>: Non-standard extension. If an element is inserted it might invalidate elements.
    inline void insert(ordered_unique_range_t, std::initializer_list<value_type> il)
-   {  this->tree_t::insert_unique(ordered_unique_range, il.begin(), il.end()); }
+   {  this->tree_t::insert_unique_range(ordered_unique_range, il.begin(), il.end()); }
 #endif
 
    //! @copydoc ::boost::container::flat_map::merge(flat_map<Key, T, C2, AllocatorOrContainer>&)
@@ -770,7 +825,7 @@ class flat_set
 
    //! <b>Effects</b>: If present, erases the element in the container with key equivalent to x.
    //!
-   //! <b>Returns</b>: Returns the number of erased elements (0/1).
+   //! <b>Returns</b>: Returns the number of erased elements.
    //!
    //! <b>Complexity</b>: Logarithmic search time plus erasure time
    //!   linear to the elements with bigger keys.
@@ -801,6 +856,15 @@ class flat_set
    //!   linear to the elements with bigger keys.
    iterator erase(const_iterator first, const_iterator last);
 
+   //! <b>Requires</b>: This overload is available only if
+   //! key_compare::is_transparent exists.
+   //!
+   //! <b>Effects</b>: If present, erases the element in the container with key equivalent to x.
+   //!
+   //! <b>Returns</b>: Returns the number of erased elements.
+   template<class K>
+   size_type erase(K && k);
+
    //! <b>Effects</b>: Swaps the contents of *this and x.
    //!
    //! <b>Throws</b>: Nothing.
@@ -1144,10 +1208,17 @@ inline typename flat_set<K, C, A>::size_type erase_if(flat_set<K, C, A>& c, Pred
 
 #ifndef BOOST_CONTAINER_NO_CXX17_CTAD
 
+//! <b>Deduction guide</b>: allows a `flat_set` to be constructed from the iterator
+//! range <code>[first, last)</code>, deducing the key type from the value type of
+//! `InputIterator` and using the default comparator and allocator.
 template <typename InputIterator>
 flat_set(InputIterator, InputIterator) ->
    flat_set< it_based_value_type_t<InputIterator> >;
 
+//! <b>Deduction guide</b>: allows a `flat_set` to be constructed from the iterator
+//! range <code>[first, last)</code>, deducing the key type from `InputIterator`. The
+//! trailing argument is used as the allocator if it is an allocator type, otherwise
+//! it is used as the comparator.
 template < typename InputIterator, typename AllocatorOrCompare>
     flat_set(InputIterator, InputIterator, AllocatorOrCompare const&) ->
     flat_set< it_based_value_type_t<InputIterator>
@@ -1163,6 +1234,9 @@ template < typename InputIterator, typename AllocatorOrCompare>
                 >::type
             >;
 
+//! <b>Deduction guide</b>: allows a `flat_set` to be constructed from the iterator
+//! range <code>[first, last)</code>, deducing the key type from `InputIterator` and
+//! taking the comparator and allocator types from the supplied arguments.
 template < typename InputIterator, typename Compare, typename Allocator
          , typename = dtl::require_nonallocator_t<Compare>
          , typename = dtl::require_allocator_t<Allocator>>
@@ -1171,11 +1245,18 @@ flat_set(InputIterator, InputIterator, Compare const&, Allocator const&) ->
            , Compare
            , Allocator>;
 
+//! <b>Deduction guide</b>: allows a `flat_set` to be constructed from an already
+//! ordered, unique iterator range <code>[first, last)</code>, deducing the key type
+//! from `InputIterator` and using the default comparator and allocator.
 template <typename InputIterator>
 flat_set(ordered_unique_range_t, InputIterator, InputIterator) ->
    flat_set< it_based_value_type_t<InputIterator>>;
 
 
+//! <b>Deduction guide</b>: allows a `flat_set` to be constructed from an already
+//! ordered, unique iterator range <code>[first, last)</code>, deducing the key type
+//! from `InputIterator`. The trailing argument is used as the allocator if it is an
+//! allocator type, otherwise it is used as the comparator.
 template < typename InputIterator, typename AllocatorOrCompare>
     flat_set(ordered_unique_range_t, InputIterator, InputIterator, AllocatorOrCompare const&) ->
     flat_set< it_based_value_type_t<InputIterator>
@@ -1191,6 +1272,10 @@ template < typename InputIterator, typename AllocatorOrCompare>
                 >::type
             >;
 
+//! <b>Deduction guide</b>: allows a `flat_set` to be constructed from an already
+//! ordered, unique iterator range <code>[first, last)</code>, deducing the key type
+//! from `InputIterator` and taking the comparator and allocator types from the
+//! supplied arguments.
 template < typename InputIterator, typename Compare, typename Allocator
          , typename = dtl::require_nonallocator_t<Compare>
          , typename = dtl::require_allocator_t<Allocator>>
@@ -1273,7 +1358,7 @@ class flat_multiset
    typedef Key                                                                      value_type;
    typedef typename BOOST_CONTAINER_IMPDEF(tree_t::sequence_type)                   sequence_type;
    typedef typename sequence_type::allocator_type                                   allocator_type;
-   typedef ::boost::container::allocator_traits<allocator_type>                     allocator_traits_type;
+   typedef boost::container::allocator_traits<allocator_type>                     allocator_traits_type;
    typedef typename sequence_type::pointer                                          pointer;
    typedef typename sequence_type::const_pointer                                    const_pointer;
    typedef typename sequence_type::reference                                        reference;
@@ -1462,12 +1547,12 @@ class flat_multiset
    {}
 
    //! @copydoc ::boost::container::flat_set::flat_set(const flat_set &, const allocator_type &)
-   inline flat_multiset(const flat_multiset& x, const allocator_type &a)
+   inline flat_multiset(const flat_multiset& x, const BOOST_CONTAINER_DOC1ST(allocator_type, typename dtl::type_identity<allocator_type>::type) &a)
       : tree_t(static_cast<const tree_t&>(x), a)
    {}
 
    //! @copydoc ::boost::container::flat_set::flat_set(flat_set &&, const allocator_type &)
-   inline flat_multiset(BOOST_RV_REF(flat_multiset) x, const allocator_type &a)
+   inline flat_multiset(BOOST_RV_REF(flat_multiset) x, const BOOST_CONTAINER_DOC1ST(allocator_type, typename dtl::type_identity<allocator_type>::type) &a)
       : tree_t(BOOST_MOVE_BASE(tree_t, x), a)
    {}
 
@@ -1487,7 +1572,7 @@ class flat_multiset
    flat_multiset& operator=(std::initializer_list<value_type> il)
    {
        this->clear();
-       this->insert(il.begin(), il.end());
+       this->tree_t::insert_equal_range(il.begin(), il.end());
        return *this;
    }
 #endif
@@ -1669,7 +1754,7 @@ class flat_multiset
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class InputIterator>
    inline void insert(InputIterator first, InputIterator last)
-      {  this->tree_t::insert_equal(first, last);  }
+      {  this->tree_t::insert_equal_range(first, last);  }
 
    //! <b>Requires</b>: first, last are not iterators into *this and
    //! must be ordered according to the predicate.
@@ -1682,7 +1767,7 @@ class flat_multiset
    //! <b>Note</b>: Non-standard extension. If an element is inserted it might invalidate elements.
    template <class InputIterator>
    inline void insert(ordered_range_t, InputIterator first, InputIterator last)
-      {  this->tree_t::insert_equal(ordered_range, first, last);  }
+      {  this->tree_t::insert_equal_range(ordered_range, first, last);  }
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
    //! <b>Effects</b>: inserts each element from the range [il.begin(), il.end()).
@@ -1691,7 +1776,7 @@ class flat_multiset
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    inline void insert(std::initializer_list<value_type> il)
-   {  this->tree_t::insert_equal(il.begin(), il.end()); }
+   {  this->tree_t::insert_equal_range(il.begin(), il.end()); }
 
    //! <b>Requires</b>: Range [il.begin(), il.end()) must be ordered according to the predicate.
    //!
@@ -1702,7 +1787,7 @@ class flat_multiset
    //!
    //! <b>Note</b>: Non-standard extension. If an element is inserted it might invalidate elements.
    inline void insert(ordered_range_t, std::initializer_list<value_type> il)
-   {  this->tree_t::insert_equal(ordered_range, il.begin(), il.end()); }
+   {  this->tree_t::insert_equal_range(ordered_range, il.begin(), il.end()); }
 #endif
 
    //! @copydoc ::boost::container::flat_multimap::merge(flat_multimap<Key, T, C2, AllocatorOrContainer>&)
@@ -1736,6 +1821,10 @@ class flat_multiset
    //! @copydoc ::boost::container::flat_set::erase(const_iterator,const_iterator)
    iterator erase(const_iterator first, const_iterator last);
 
+   //! @copydoc ::boost::container::flat_set::erase(K&&)
+   template<class K>
+   size_type erase(K && k);
+
    //! @copydoc ::boost::container::flat_set::swap
    void swap(flat_multiset& x)
       BOOST_NOEXCEPT_IF(  allocator_traits_type::is_always_equal::value
@@ -1884,11 +1973,18 @@ inline typename flat_multiset<K, C, A>::size_type erase_if(flat_multiset<K, C, A
 
 #ifndef BOOST_CONTAINER_NO_CXX17_CTAD
 
+//! <b>Deduction guide</b>: allows a `flat_multiset` to be constructed from the
+//! iterator range <code>[first, last)</code>, deducing the key type from the value
+//! type of `InputIterator` and using the default comparator and allocator.
 template <typename InputIterator>
 flat_multiset(InputIterator, InputIterator) ->
    flat_multiset< it_based_value_type_t<InputIterator> >;
 
 
+//! <b>Deduction guide</b>: allows a `flat_multiset` to be constructed from the
+//! iterator range <code>[first, last)</code>, deducing the key type from
+//! `InputIterator`. The trailing argument is used as the allocator if it is an
+//! allocator type, otherwise it is used as the comparator.
 template < typename InputIterator, typename AllocatorOrCompare>
 flat_multiset(InputIterator, InputIterator, AllocatorOrCompare const&) ->
     flat_multiset < it_based_value_type_t<InputIterator>
@@ -1904,6 +2000,10 @@ flat_multiset(InputIterator, InputIterator, AllocatorOrCompare const&) ->
                       >::type
                   >;
 
+//! <b>Deduction guide</b>: allows a `flat_multiset` to be constructed from the
+//! iterator range <code>[first, last)</code>, deducing the key type from
+//! `InputIterator` and taking the comparator and allocator types from the supplied
+//! arguments.
 template < typename InputIterator, typename Compare, typename Allocator
          , typename = dtl::require_nonallocator_t<Compare>
          , typename = dtl::require_allocator_t<Allocator>>
@@ -1912,10 +2012,17 @@ flat_multiset(InputIterator, InputIterator, Compare const&, Allocator const&) ->
            , Compare
            , Allocator>;
 
+//! <b>Deduction guide</b>: allows a `flat_multiset` to be constructed from an already
+//! ordered iterator range <code>[first, last)</code>, deducing the key type from
+//! `InputIterator` and using the default comparator and allocator.
 template <typename InputIterator>
 flat_multiset(ordered_range_t, InputIterator, InputIterator) ->
    flat_multiset< it_based_value_type_t<InputIterator>>;
 
+//! <b>Deduction guide</b>: allows a `flat_multiset` to be constructed from an already
+//! ordered iterator range <code>[first, last)</code>, deducing the key type from
+//! `InputIterator`. The trailing argument is used as the allocator if it is an
+//! allocator type, otherwise it is used as the comparator.
 template < typename InputIterator, typename AllocatorOrCompare>
 flat_multiset(ordered_range_t, InputIterator, InputIterator, AllocatorOrCompare const&) ->
     flat_multiset < it_based_value_type_t<InputIterator>
@@ -1931,6 +2038,10 @@ flat_multiset(ordered_range_t, InputIterator, InputIterator, AllocatorOrCompare
                       >::type
                   >;
 
+//! <b>Deduction guide</b>: allows a `flat_multiset` to be constructed from an already
+//! ordered iterator range <code>[first, last)</code>, deducing the key type from
+//! `InputIterator` and taking the comparator and allocator types from the supplied
+//! arguments.
 template < typename InputIterator, typename Compare, typename Allocator
          , typename = dtl::require_nonallocator_t<Compare>
          , typename = dtl::require_allocator_t<Allocator>>