passenger 6.0.16 → 6.0.18

data/src/cxx_supportlib/vendor-modified/boost/unordered/unordered_map.hpp

@@ -20,6 +20,7 @@
 #include <boost/move/move.hpp>
 #include <boost/type_traits/is_constructible.hpp>
 #include <boost/unordered/detail/map.hpp>
+#include <boost/unordered/detail/type_traits.hpp>
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
 #include <initializer_list>
@@ -50,9 +51,9 @@ namespace boost {
       typedef K key_type;
       typedef T mapped_type;
       typedef std::pair<const K, T> value_type;
-      typedef H hasher;
-      typedef P key_equal;
-      typedef A allocator_type;
+      typedef typename boost::type_identity<H>::type hasher;
+      typedef typename boost::type_identity<P>::type key_equal;
+      typedef typename boost::type_identity<A>::type allocator_type;
 
     private:
       typedef boost::unordered::detail::map<A, K, T, H, P> types;
@@ -123,6 +124,9 @@ namespace boost {
 
       explicit unordered_map(size_type, const hasher&, const allocator_type&);
 
+      template <class InputIterator>
+      unordered_map(InputIterator, InputIterator, const allocator_type&);
+
       template <class InputIt>
       unordered_map(InputIt, InputIt, size_type, const allocator_type&);
 
@@ -131,6 +135,8 @@ namespace boost {
         InputIt, InputIt, size_type, const hasher&, const allocator_type&);
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+      unordered_map(std::initializer_list<value_type>, const allocator_type&);
+
       unordered_map(
         std::initializer_list<value_type>, size_type, const allocator_type&);
 
@@ -926,7 +932,7 @@ namespace boost {
       template <typename T>
       using iter_to_alloc_t =
         typename std::pair<iter_key_t<T> const, iter_val_t<T> >;
-    }
+    } // namespace detail
 
     template <class InputIterator,
       class Hash =
@@ -934,58 +940,80 @@ namespace boost {
       class Pred =
         std::equal_to<boost::unordered::detail::iter_key_t<InputIterator> >,
       class Allocator = std::allocator<
-        boost::unordered::detail::iter_to_alloc_t<InputIterator> > >
+        boost::unordered::detail::iter_to_alloc_t<InputIterator> >,
+      class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
+      class = boost::enable_if_t<detail::is_hash_v<Hash> >,
+      class = boost::enable_if_t<detail::is_pred_v<Pred> >,
+      class = boost::enable_if_t<detail::is_allocator_v<Allocator> > >
     unordered_map(InputIterator, InputIterator,
       std::size_t = boost::unordered::detail::default_bucket_count,
       Hash = Hash(), Pred = Pred(), Allocator = Allocator())
-      ->unordered_map<boost::unordered::detail::iter_key_t<InputIterator>,
+      -> unordered_map<boost::unordered::detail::iter_key_t<InputIterator>,
         boost::unordered::detail::iter_val_t<InputIterator>, Hash, Pred,
         Allocator>;
 
-    template <class Key, class T, class Hash = boost::hash<Key>,
-      class Pred = std::equal_to<Key>,
-      class Allocator = std::allocator<std::pair<const Key, T> > >
-    unordered_map(std::initializer_list<std::pair<const Key, T> >,
+    template <class Key, class T,
+      class Hash = boost::hash<boost::remove_const_t<Key> >,
+      class Pred = std::equal_to<boost::remove_const_t<Key> >,
+      class Allocator = std::allocator<std::pair<const Key, T> >,
+      class = boost::enable_if_t<detail::is_hash_v<Hash> >,
+      class = boost::enable_if_t<detail::is_pred_v<Pred> >,
+      class = boost::enable_if_t<detail::is_allocator_v<Allocator> > >
+    unordered_map(std::initializer_list<std::pair<Key, T> >,
       std::size_t = boost::unordered::detail::default_bucket_count,
       Hash = Hash(), Pred = Pred(), Allocator = Allocator())
-      ->unordered_map<Key, T, Hash, Pred, Allocator>;
+      -> unordered_map<boost::remove_const_t<Key>, T, Hash, Pred, Allocator>;
 
-    template <class InputIterator, class Allocator>
+    template <class InputIterator, class Allocator,
+      class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
+      class = boost::enable_if_t<detail::is_allocator_v<Allocator> > >
     unordered_map(InputIterator, InputIterator, std::size_t, Allocator)
-      ->unordered_map<boost::unordered::detail::iter_key_t<InputIterator>,
+      -> unordered_map<boost::unordered::detail::iter_key_t<InputIterator>,
         boost::unordered::detail::iter_val_t<InputIterator>,
         boost::hash<boost::unordered::detail::iter_key_t<InputIterator> >,
         std::equal_to<boost::unordered::detail::iter_key_t<InputIterator> >,
         Allocator>;
 
-    template <class InputIterator, class Allocator>
+    template <class InputIterator, class Allocator,
+      class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
+      class = boost::enable_if_t<detail::is_allocator_v<Allocator> > >
     unordered_map(InputIterator, InputIterator, Allocator)
-      ->unordered_map<boost::unordered::detail::iter_key_t<InputIterator>,
+      -> unordered_map<boost::unordered::detail::iter_key_t<InputIterator>,
         boost::unordered::detail::iter_val_t<InputIterator>,
         boost::hash<boost::unordered::detail::iter_key_t<InputIterator> >,
         std::equal_to<boost::unordered::detail::iter_key_t<InputIterator> >,
         Allocator>;
 
-    template <class InputIterator, class Hash, class Allocator>
+    template <class InputIterator, class Hash, class Allocator,
+      class = boost::enable_if_t<detail::is_hash_v<Hash> >,
+      class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
+      class = boost::enable_if_t<detail::is_allocator_v<Allocator> > >
     unordered_map(InputIterator, InputIterator, std::size_t, Hash, Allocator)
-      ->unordered_map<boost::unordered::detail::iter_key_t<InputIterator>,
+      -> unordered_map<boost::unordered::detail::iter_key_t<InputIterator>,
         boost::unordered::detail::iter_val_t<InputIterator>, Hash,
         std::equal_to<boost::unordered::detail::iter_key_t<InputIterator> >,
         Allocator>;
 
-    template <class Key, class T, typename Allocator>
-    unordered_map(
-      std::initializer_list<std::pair<const Key, T> >, std::size_t, Allocator)
-      ->unordered_map<Key, T, boost::hash<Key>, std::equal_to<Key>, Allocator>;
-
-    template <class Key, class T, typename Allocator>
-    unordered_map(std::initializer_list<std::pair<const Key, T> >, Allocator)
-      ->unordered_map<Key, T, boost::hash<Key>, std::equal_to<Key>, Allocator>;
-
-    template <class Key, class T, class Hash, class Allocator>
-    unordered_map(std::initializer_list<std::pair<const Key, T> >, std::size_t,
-      Hash, Allocator)
-      ->unordered_map<Key, T, Hash, std::equal_to<Key>, Allocator>;
+    template <class Key, class T, class Allocator,
+      class = boost::enable_if_t<detail::is_allocator_v<Allocator> > >
+    unordered_map(std::initializer_list<std::pair<Key, T> >, std::size_t,
+      Allocator) -> unordered_map<boost::remove_const_t<Key>, T,
+      boost::hash<boost::remove_const_t<Key> >,
+      std::equal_to<boost::remove_const_t<Key> >, Allocator>;
+
+    template <class Key, class T, class Allocator,
+      class = boost::enable_if_t<detail::is_allocator_v<Allocator> > >
+    unordered_map(std::initializer_list<std::pair<Key, T> >, Allocator)
+      -> unordered_map<boost::remove_const_t<Key>, T,
+        boost::hash<boost::remove_const_t<Key> >,
+        std::equal_to<boost::remove_const_t<Key> >, Allocator>;
+
+    template <class Key, class T, class Hash, class Allocator,
+      class = boost::enable_if_t<detail::is_hash_v<Hash> >,
+      class = boost::enable_if_t<detail::is_allocator_v<Allocator> > >
+    unordered_map(std::initializer_list<std::pair<Key, T> >, std::size_t, Hash,
+      Allocator) -> unordered_map<boost::remove_const_t<Key>, T, Hash,
+      std::equal_to<boost::remove_const_t<Key> >, Allocator>;
 
 #endif
 
@@ -1002,9 +1030,9 @@ namespace boost {
       typedef K key_type;
       typedef T mapped_type;
       typedef std::pair<const K, T> value_type;
-      typedef H hasher;
-      typedef P key_equal;
-      typedef A allocator_type;
+      typedef typename boost::type_identity<H>::type hasher;
+      typedef typename boost::type_identity<P>::type key_equal;
+      typedef typename boost::type_identity<A>::type allocator_type;
 
     private:
       typedef boost::unordered::detail::map<A, K, T, H, P> types;
@@ -1076,6 +1104,9 @@ namespace boost {
       explicit unordered_multimap(
         size_type, const hasher&, const allocator_type&);
 
+      template <class InputIterator>
+      unordered_multimap(InputIterator, InputIterator, const allocator_type&);
+
       template <class InputIt>
       unordered_multimap(InputIt, InputIt, size_type, const allocator_type&);
 
@@ -1084,6 +1115,9 @@ namespace boost {
         InputIt, InputIt, size_type, const hasher&, const allocator_type&);
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+      unordered_multimap(
+        std::initializer_list<value_type>, const allocator_type&);
+
       unordered_multimap(
         std::initializer_list<value_type>, size_type, const allocator_type&);
 
@@ -1601,62 +1635,82 @@ namespace boost {
       class Pred =
         std::equal_to<boost::unordered::detail::iter_key_t<InputIterator> >,
       class Allocator = std::allocator<
-        boost::unordered::detail::iter_to_alloc_t<InputIterator> > >
+        boost::unordered::detail::iter_to_alloc_t<InputIterator> >,
+      class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
+      class = boost::enable_if_t<detail::is_hash_v<Hash> >,
+      class = boost::enable_if_t<detail::is_pred_v<Pred> >,
+      class = boost::enable_if_t<detail::is_allocator_v<Allocator> > >
     unordered_multimap(InputIterator, InputIterator,
       std::size_t = boost::unordered::detail::default_bucket_count,
       Hash = Hash(), Pred = Pred(), Allocator = Allocator())
-      ->unordered_multimap<boost::unordered::detail::iter_key_t<InputIterator>,
+      -> unordered_multimap<boost::unordered::detail::iter_key_t<InputIterator>,
         boost::unordered::detail::iter_val_t<InputIterator>, Hash, Pred,
         Allocator>;
 
-    template <class Key, class T, class Hash = boost::hash<Key>,
-      class Pred = std::equal_to<Key>,
-      class Allocator = std::allocator<std::pair<const Key, T> > >
-    unordered_multimap(std::initializer_list<std::pair<const Key, T> >,
+    template <class Key, class T,
+      class Hash = boost::hash<boost::remove_const_t<Key> >,
+      class Pred = std::equal_to<boost::remove_const_t<Key> >,
+      class Allocator = std::allocator<std::pair<const Key, T> >,
+      class = boost::enable_if_t<detail::is_hash_v<Hash> >,
+      class = boost::enable_if_t<detail::is_pred_v<Pred> >,
+      class = boost::enable_if_t<detail::is_allocator_v<Allocator> > >
+    unordered_multimap(std::initializer_list<std::pair<Key, T> >,
       std::size_t = boost::unordered::detail::default_bucket_count,
       Hash = Hash(), Pred = Pred(), Allocator = Allocator())
-      ->unordered_multimap<Key, T, Hash, Pred, Allocator>;
+      -> unordered_multimap<boost::remove_const_t<Key>, T, Hash, Pred,
+        Allocator>;
 
-    template <class InputIterator, class Allocator>
+    template <class InputIterator, class Allocator,
+      class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
+      class = boost::enable_if_t<detail::is_allocator_v<Allocator> > >
     unordered_multimap(InputIterator, InputIterator, std::size_t, Allocator)
-      ->unordered_multimap<boost::unordered::detail::iter_key_t<InputIterator>,
+      -> unordered_multimap<boost::unordered::detail::iter_key_t<InputIterator>,
         boost::unordered::detail::iter_val_t<InputIterator>,
         boost::hash<boost::unordered::detail::iter_key_t<InputIterator> >,
         std::equal_to<boost::unordered::detail::iter_key_t<InputIterator> >,
         Allocator>;
 
-    template <class InputIterator, class Allocator>
+    template <class InputIterator, class Allocator,
+      class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
+      class = boost::enable_if_t<detail::is_allocator_v<Allocator> > >
     unordered_multimap(InputIterator, InputIterator, Allocator)
-      ->unordered_multimap<boost::unordered::detail::iter_key_t<InputIterator>,
+      -> unordered_multimap<boost::unordered::detail::iter_key_t<InputIterator>,
         boost::unordered::detail::iter_val_t<InputIterator>,
         boost::hash<boost::unordered::detail::iter_key_t<InputIterator> >,
         std::equal_to<boost::unordered::detail::iter_key_t<InputIterator> >,
         Allocator>;
 
-    template <class InputIterator, class Hash, class Allocator>
+    template <class InputIterator, class Hash, class Allocator,
+      class = boost::enable_if_t<detail::is_hash_v<Hash> >,
+      class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
+      class = boost::enable_if_t<detail::is_allocator_v<Allocator> > >
     unordered_multimap(
       InputIterator, InputIterator, std::size_t, Hash, Allocator)
-      ->unordered_multimap<boost::unordered::detail::iter_key_t<InputIterator>,
+      -> unordered_multimap<boost::unordered::detail::iter_key_t<InputIterator>,
         boost::unordered::detail::iter_val_t<InputIterator>, Hash,
         std::equal_to<boost::unordered::detail::iter_key_t<InputIterator> >,
         Allocator>;
 
-    template <class Key, class T, typename Allocator>
-    unordered_multimap(
-      std::initializer_list<std::pair<const Key, T> >, std::size_t, Allocator)
-      ->unordered_multimap<Key, T, boost::hash<Key>, std::equal_to<Key>,
-        Allocator>;
-
-    template <class Key, class T, typename Allocator>
-    unordered_multimap(
-      std::initializer_list<std::pair<const Key, T> >, Allocator)
-      ->unordered_multimap<Key, T, boost::hash<Key>, std::equal_to<Key>,
-        Allocator>;
-
-    template <class Key, class T, class Hash, class Allocator>
-    unordered_multimap(std::initializer_list<std::pair<const Key, T> >,
-      std::size_t, Hash, Allocator)
-      ->unordered_multimap<Key, T, Hash, std::equal_to<Key>, Allocator>;
+    template <class Key, class T, class Allocator,
+      class = boost::enable_if_t<detail::is_allocator_v<Allocator> > >
+    unordered_multimap(std::initializer_list<std::pair<Key, T> >, std::size_t,
+      Allocator) -> unordered_multimap<boost::remove_const_t<Key>, T,
+      boost::hash<boost::remove_const_t<Key> >,
+      std::equal_to<boost::remove_const_t<Key> >, Allocator>;
+
+    template <class Key, class T, class Allocator,
+      class = boost::enable_if_t<detail::is_allocator_v<Allocator> > >
+    unordered_multimap(std::initializer_list<std::pair<Key, T> >, Allocator)
+      -> unordered_multimap<boost::remove_const_t<Key>, T,
+        boost::hash<boost::remove_const_t<Key> >,
+        std::equal_to<boost::remove_const_t<Key> >, Allocator>;
+
+    template <class Key, class T, class Hash, class Allocator,
+      class = boost::enable_if_t<detail::is_hash_v<Hash> >,
+      class = boost::enable_if_t<detail::is_allocator_v<Allocator> > >
+    unordered_multimap(std::initializer_list<std::pair<Key, T> >, std::size_t,
+      Hash, Allocator) -> unordered_multimap<boost::remove_const_t<Key>, T,
+      Hash, std::equal_to<boost::remove_const_t<Key> >, Allocator>;
 
 #endif
 
@@ -1664,8 +1718,6 @@ namespace boost {
 
     template <class K, class T, class H, class P, class A>
     unordered_map<K, T, H, P, A>::unordered_map()
-        : table_(boost::unordered::detail::default_bucket_count, hasher(),
-            key_equal(), allocator_type())
     {
     }
 
@@ -1753,6 +1805,17 @@ namespace boost {
     {
     }
 
+    template <class K, class T, class H, class P, class A>
+    template <class InputIterator>
+    unordered_map<K, T, H, P, A>::unordered_map(
+      InputIterator f, InputIterator l, const allocator_type& a)
+        : table_(boost::unordered::detail::initial_size(
+                   f, l, detail::default_bucket_count),
+            hasher(), key_equal(), a)
+    {
+      this->insert(f, l);
+    }
+
     template <class K, class T, class H, class P, class A>
     template <class InputIt>
     unordered_map<K, T, H, P, A>::unordered_map(
@@ -1775,6 +1838,16 @@ namespace boost {
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
 
+    template <class K, class T, class H, class P, class A>
+    unordered_map<K, T, H, P, A>::unordered_map(
+      std::initializer_list<value_type> list, const allocator_type& a)
+        : table_(boost::unordered::detail::initial_size(
+                   list.begin(), list.end(), detail::default_bucket_count),
+            hasher(), key_equal(), a)
+    {
+      this->insert(list.begin(), list.end());
+    }
+
     template <class K, class T, class H, class P, class A>
     unordered_map<K, T, H, P, A>::unordered_map(
       std::initializer_list<value_type> list, size_type n,
@@ -2069,6 +2142,10 @@ namespace boost {
     template <class K, class T, class H, class P, class A>
     float unordered_map<K, T, H, P, A>::load_factor() const BOOST_NOEXCEPT
     {
+      if (table_.size_ == 0) {
+        return 0.0f;
+      }
+
       BOOST_ASSERT(table_.bucket_count() != 0);
       return static_cast<float>(table_.size_) /
              static_cast<float>(table_.bucket_count());
@@ -2143,8 +2220,6 @@ namespace boost {
 
     template <class K, class T, class H, class P, class A>
     unordered_multimap<K, T, H, P, A>::unordered_multimap()
-        : table_(boost::unordered::detail::default_bucket_count, hasher(),
-            key_equal(), allocator_type())
     {
     }
 
@@ -2234,6 +2309,17 @@ namespace boost {
     {
     }
 
+    template <class K, class T, class H, class P, class A>
+    template <class InputIterator>
+    unordered_multimap<K, T, H, P, A>::unordered_multimap(
+      InputIterator f, InputIterator l, const allocator_type& a)
+        : table_(boost::unordered::detail::initial_size(
+                   f, l, detail::default_bucket_count),
+            hasher(), key_equal(), a)
+    {
+      this->insert(f, l);
+    }
+
     template <class K, class T, class H, class P, class A>
     template <class InputIt>
     unordered_multimap<K, T, H, P, A>::unordered_multimap(
@@ -2256,6 +2342,16 @@ namespace boost {
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
 
+    template <class K, class T, class H, class P, class A>
+    unordered_multimap<K, T, H, P, A>::unordered_multimap(
+      std::initializer_list<value_type> list, const allocator_type& a)
+        : table_(boost::unordered::detail::initial_size(
+                   list.begin(), list.end(), detail::default_bucket_count),
+            hasher(), key_equal(), a)
+    {
+      this->insert(list.begin(), list.end());
+    }
+
     template <class K, class T, class H, class P, class A>
     unordered_multimap<K, T, H, P, A>::unordered_multimap(
       std::initializer_list<value_type> list, size_type n,
@@ -2506,6 +2602,10 @@ namespace boost {
     template <class K, class T, class H, class P, class A>
     float unordered_multimap<K, T, H, P, A>::load_factor() const BOOST_NOEXCEPT
     {
+      if (table_.size_ == 0) {
+        return 0.0f;
+      }
+
       BOOST_ASSERT(table_.bucket_count() != 0);
       return static_cast<float>(table_.size_) /
              static_cast<float>(table_.bucket_count());