* Clean up constructor template auto deduction guides to use Boost.Container traits

* GitHub #73: '"triviality of pair".

* Fixed race condition bug in unsynchronized_pool_resource

include/boost/container/deque.hpp

@@ -2240,9 +2240,9 @@ class deque : protected deque_base<Allocator>
 
 #if __cplusplus >= 201703L
 template <typename InputIterator>
-deque(InputIterator, InputIterator) -> deque<typename std::iterator_traits<InputIterator>::value_type>;
+deque(InputIterator, InputIterator) -> deque<typename iterator_traits<InputIterator>::value_type>;
 template <typename InputIterator, typename Allocator>
-deque(InputIterator, InputIterator, Allocator const&) -> deque<typename std::iterator_traits<InputIterator>::value_type, Allocator>;
+deque(InputIterator, InputIterator, Allocator const&) -> deque<typename iterator_traits<InputIterator>::value_type, Allocator>;
 #endif
 
 }}

include/boost/container/detail/pair.hpp

@@ -550,6 +550,14 @@ struct is_class< std::pair<T1, T2> >
    static const bool value = true;
 };
 
+template<class A, class B>
+struct is_trivially_copy_assignable
+   <boost::container::dtl::pair<A,B> >
+{
+   static const bool value = boost::move_detail::is_trivially_copy_assignable<A>::value &&
+                             boost::move_detail::is_trivially_copy_assignable<B>::value ;
+};
+
 }  //namespace move_detail{
 
 }  //namespace boost {

include/boost/container/detail/thread_mutex.hpp

@@ -0,0 +1,179 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2018-2018. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/interprocess for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+//
+// This code is partially based on the lightweight mutex implemented
+// by Boost.SmartPtr:
+//
+//  Copyright (c) 2002, 2003 Peter Dimov
+//  Copyright (c) Microsoft Corporation 2014
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+#
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#ifndef BOOST_CONTAINER_DETAIL_THREAD_MUTEX_HPP
+#define BOOST_CONTAINER_DETAIL_THREAD_MUTEX_HPP
+
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/detail/workaround.hpp>
+
+#if defined(BOOST_HAS_PTHREADS)
+
+#include <pthread.h>
+#include <boost/assert.hpp>
+
+namespace boost{
+namespace container {
+namespace dtl {
+
+class thread_mutex
+{
+   public:
+   thread_mutex()
+   {
+      BOOST_VERIFY(pthread_mutex_init(&m_mut, 0) == 0);
+   }
+
+   ~thread_mutex()
+   {
+     BOOST_VERIFY(pthread_mutex_destroy(&m_mut) == 0);
+   }
+
+   void lock()
+   {
+      BOOST_VERIFY(pthread_mutex_lock( &m_mut) == 0);
+   }
+
+   void unlock()
+   {
+      BOOST_VERIFY(pthread_mutex_unlock(&m_mut) == 0);
+   }
+
+   private:
+   thread_mutex(thread_mutex const &);
+   thread_mutex & operator=(thread_mutex const &);
+   
+   pthread_mutex_t m_mut;
+};
+
+} // namespace dtl {
+} // namespace container {
+} // namespace boost {
+
+#else //!BOOST_HAS_PTHREADS (Windows implementation)
+
+#ifdef BOOST_USE_WINDOWS_H
+
+#include <windows.h>
+
+namespace boost{
+namespace container {
+namespace dtl {
+
+typedef ::CRITICAL_SECTION win_critical_section;
+
+} // namespace dtl {
+} // namespace container {
+} // namespace boost {
+
+#else //! BOOST_USE_WINDOWS_H
+
+struct _RTL_CRITICAL_SECTION_DEBUG;
+struct _RTL_CRITICAL_SECTION;
+   
+namespace boost{
+namespace container {
+namespace dtl {
+
+#ifdef BOOST_PLAT_WINDOWS_UWP
+extern "C" __declspec(dllimport) void __stdcall InitializeCriticalSectionEx(::_RTL_CRITICAL_SECTION *, unsigned long, unsigned long);
+#else
+extern "C" __declspec(dllimport) void __stdcall InitializeCriticalSection(::_RTL_CRITICAL_SECTION *);
+#endif
+extern "C" __declspec(dllimport) void __stdcall EnterCriticalSection(::_RTL_CRITICAL_SECTION *);
+extern "C" __declspec(dllimport) void __stdcall LeaveCriticalSection(::_RTL_CRITICAL_SECTION *);
+extern "C" __declspec(dllimport) void __stdcall DeleteCriticalSection(::_RTL_CRITICAL_SECTION *);
+
+struct win_critical_section
+{
+   struct _RTL_CRITICAL_SECTION_DEBUG * DebugInfo;
+   long LockCount;
+   long RecursionCount;
+   void * OwningThread;
+   void * LockSemaphore;
+   #if defined(_WIN64)
+   unsigned __int64 SpinCount;
+   #else
+   unsigned long SpinCount;
+   #endif
+};
+
+} // namespace dtl {
+} // namespace container {
+} // namespace boost {
+
+#endif   //BOOST_USE_WINDOWS_H
+
+namespace boost{
+namespace container {
+namespace dtl {
+
+class thread_mutex
+{
+   public:
+   thread_mutex()
+   {
+      #ifdef BOOST_PLAT_WINDOWS_UWP
+      InitializeCriticalSectionEx(reinterpret_cast< ::_RTL_CRITICAL_SECTION* >(&m_crit_sect), 4000, 0);
+      #else
+      InitializeCriticalSection(reinterpret_cast< ::_RTL_CRITICAL_SECTION* >(&m_crit_sect));
+      #endif
+   }
+
+   void lock()
+   {
+      EnterCriticalSection(reinterpret_cast< ::_RTL_CRITICAL_SECTION* >(&m_crit_sect));
+   }
+
+   void unlock()
+   {
+      LeaveCriticalSection(reinterpret_cast< ::_RTL_CRITICAL_SECTION* >(&m_crit_sect));
+   }
+
+   ~thread_mutex()
+   {
+      DeleteCriticalSection(reinterpret_cast< ::_RTL_CRITICAL_SECTION* >(&m_crit_sect));
+   }
+  
+   private:
+   thread_mutex(thread_mutex const &);
+   thread_mutex & operator=(thread_mutex const &);
+   
+   win_critical_section m_crit_sect;
+};
+
+} // namespace dtl {
+} // namespace container {
+} // namespace boost {
+
+#endif   //BOOST_HAS_PTHREADS
+
+#endif // #ifndef BOOST_CONTAINER_DETAIL_THREAD_MUTEX_HPP

include/boost/container/flat_map.hpp

@@ -1546,22 +1546,57 @@ class flat_map
 };
 
 #if __cplusplus >= 201703L
+
 template <typename InputIterator>
-flat_map(InputIterator, InputIterator) -> flat_map<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type>;
+flat_map(InputIterator, InputIterator) ->
+   flat_map< typename dtl::remove_const< typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type>;
+
 template <typename InputIterator, typename Allocator>
-flat_map(InputIterator, InputIterator, Allocator const&) -> flat_map<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, std::less<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>>, Allocator>;
+flat_map(InputIterator, InputIterator, Allocator const&) ->
+   flat_map< typename dtl::remove_const< typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , std::less<typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type>
+           , Allocator>;
+
 template <typename InputIterator, typename Compare>
-flat_map(InputIterator, InputIterator, Compare const&) -> flat_map<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, Compare>;
+flat_map(InputIterator, InputIterator, Compare const&) ->
+   flat_map< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , Compare>;
+
 template <typename InputIterator, typename Compare, typename Allocator>
-flat_map(InputIterator, InputIterator, Compare const&, Allocator const&) -> flat_map<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, Compare, Allocator>;
+flat_map(InputIterator, InputIterator, Compare const&, Allocator const&) ->
+   flat_map< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , Compare
+           , Allocator>;
+
 template <typename InputIterator>
-flat_map(ordered_unique_range_t, InputIterator, InputIterator) -> flat_map<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type>;
+flat_map(ordered_unique_range_t, InputIterator, InputIterator) ->
+   flat_map< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type>;
+
 template <typename InputIterator, typename Allocator>
-flat_map(ordered_unique_range_t, InputIterator, InputIterator, Allocator const&) -> flat_map<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, std::less<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>>, Allocator>;
+flat_map(ordered_unique_range_t, InputIterator, InputIterator, Allocator const&) ->
+   flat_map< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , std::less<typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type>
+           , Allocator>;
+
 template <typename InputIterator, typename Compare>
-flat_map(ordered_unique_range_t, InputIterator, InputIterator, Compare const&) -> flat_map<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, Compare>;
+flat_map(ordered_unique_range_t, InputIterator, InputIterator, Compare const&) ->
+   flat_map< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , Compare>;
+
 template <typename InputIterator, typename Compare, typename Allocator>
-flat_map(ordered_unique_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) -> flat_map<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, Compare, Allocator>;
+flat_map(ordered_unique_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) ->
+   flat_map< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , Compare
+           , Allocator>;
+
 #endif
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
@@ -2776,22 +2811,57 @@ class flat_multimap
 };
 
 #if __cplusplus >= 201703L
+
 template <typename InputIterator>
-flat_multimap(InputIterator, InputIterator) -> flat_multimap<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type>;
+flat_multimap(InputIterator, InputIterator) ->
+   flat_multimap<typename dtl::remove_const< typename iterator_traits<InputIterator>::value_type::first_type>::type
+                        , typename iterator_traits<InputIterator>::value_type::second_type>;
+
 template <typename InputIterator, typename Allocator>
-flat_multimap(InputIterator, InputIterator, Allocator const&) -> flat_multimap<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, std::less<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>>, Allocator>;
+flat_multimap(InputIterator, InputIterator, Allocator const&) ->
+   flat_multimap<typename dtl::remove_const< typename iterator_traits<InputIterator>::value_type::first_type>::type
+                        , typename iterator_traits<InputIterator>::value_type::second_type
+                        , std::less<typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type>
+                        , Allocator>;
+
 template <typename InputIterator, typename Compare>
-flat_multimap(InputIterator, InputIterator, Compare const&) -> flat_multimap<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, Compare>;
+flat_multimap(InputIterator, InputIterator, Compare const&) ->
+   flat_multimap< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , Compare>;
+
 template <typename InputIterator, typename Compare, typename Allocator>
-flat_multimap(InputIterator, InputIterator, Compare const&, Allocator const&) -> flat_multimap<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, Compare, Allocator>;
+flat_multimap(InputIterator, InputIterator, Compare const&, Allocator const&) ->
+   flat_multimap< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , Compare
+           , Allocator>;
+
 template <typename InputIterator>
-flat_multimap(ordered_range_t, InputIterator, InputIterator) -> flat_multimap<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type>;
+flat_multimap(ordered_range_t, InputIterator, InputIterator) ->
+   flat_multimap< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type>;
+
 template <typename InputIterator, typename Allocator>
-flat_multimap(ordered_range_t, InputIterator, InputIterator, Allocator const&) -> flat_multimap<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, std::less<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>>, Allocator>;
+flat_multimap(ordered_range_t, InputIterator, InputIterator, Allocator const&) ->
+   flat_multimap< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , std::less<typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type>
+           , Allocator>;
+
 template <typename InputIterator, typename Compare>
-flat_multimap(ordered_range_t, InputIterator, InputIterator, Compare const&) -> flat_multimap<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, Compare>;
+flat_multimap(ordered_range_t, InputIterator, InputIterator, Compare const&) ->
+   flat_multimap< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , Compare>;
+
 template <typename InputIterator, typename Compare, typename Allocator>
-flat_multimap(ordered_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) -> flat_multimap<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, Compare, Allocator>;
+flat_multimap(ordered_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) ->
+   flat_multimap< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , Compare
+           , Allocator>;
+
 #endif
 
 }}

include/boost/container/flat_set.hpp

@@ -1092,22 +1092,39 @@ class flat_set
 };
 
 #if __cplusplus >= 201703L
+
 template <typename InputIterator>
-flat_set(InputIterator, InputIterator) -> flat_set<typename std::iterator_traits<InputIterator>::value_type>;
+flat_set(InputIterator, InputIterator) ->
+   flat_set<typename iterator_traits<InputIterator>::value_type>;
+
 template <typename InputIterator, typename Allocator>
-flat_set(InputIterator, InputIterator, Allocator const&) -> flat_set<typename std::iterator_traits<InputIterator>::value_type, std::less<typename std::iterator_traits<InputIterator>::value_type>, Allocator>;
+flat_set(InputIterator, InputIterator, Allocator const&) ->
+   flat_set<typename iterator_traits<InputIterator>::value_type, std::less<typename iterator_traits<InputIterator>::value_type>, Allocator>;
+
 template <typename InputIterator, typename Compare>
-flat_set(InputIterator, InputIterator, Compare const&) -> flat_set<typename std::iterator_traits<InputIterator>::value_type, Compare>;
+flat_set(InputIterator, InputIterator, Compare const&) ->
+   flat_set<typename iterator_traits<InputIterator>::value_type, Compare>;
+
 template <typename InputIterator, typename Compare, typename Allocator>
-flat_set(InputIterator, InputIterator, Compare const&, Allocator const&) -> flat_set<typename std::iterator_traits<InputIterator>::value_type, Compare, Allocator>;
+flat_set(InputIterator, InputIterator, Compare const&, Allocator const&) ->
+   flat_set<typename iterator_traits<InputIterator>::value_type, Compare, Allocator>;
+
 template <typename InputIterator>
-flat_set(ordered_unique_range_t, InputIterator, InputIterator) -> flat_set<typename std::iterator_traits<InputIterator>::value_type>;
+flat_set(ordered_unique_range_t, InputIterator, InputIterator) ->
+   flat_set<typename iterator_traits<InputIterator>::value_type>;
+
 template <typename InputIterator, typename Allocator>
-flat_set(ordered_unique_range_t, InputIterator, InputIterator, Allocator const&) -> flat_set<typename std::iterator_traits<InputIterator>::value_type, std::less<typename std::iterator_traits<InputIterator>::value_type>, Allocator>;
+flat_set(ordered_unique_range_t, InputIterator, InputIterator, Allocator const&) ->
+   flat_set<typename iterator_traits<InputIterator>::value_type, std::less<typename iterator_traits<InputIterator>::value_type>, Allocator>;
+
 template <typename InputIterator, typename Compare>
-flat_set(ordered_unique_range_t, InputIterator, InputIterator, Compare const&) -> flat_set<typename std::iterator_traits<InputIterator>::value_type, Compare>;
+flat_set(ordered_unique_range_t, InputIterator, InputIterator, Compare const&) ->
+   flat_set<typename iterator_traits<InputIterator>::value_type, Compare>;
+
 template <typename InputIterator, typename Compare, typename Allocator>
-flat_set(ordered_unique_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) -> flat_set<typename std::iterator_traits<InputIterator>::value_type, Compare, Allocator>;
+flat_set(ordered_unique_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) ->
+   flat_set<typename iterator_traits<InputIterator>::value_type, Compare, Allocator>;
+
 #endif
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
@@ -1765,22 +1782,43 @@ class flat_multiset
 };
 
 #if __cplusplus >= 201703L
+
 template <typename InputIterator>
-flat_multiset(InputIterator, InputIterator) -> flat_multiset<typename std::iterator_traits<InputIterator>::value_type>;
+flat_multiset(InputIterator, InputIterator) ->
+   flat_multiset<typename iterator_traits<InputIterator>::value_type>;
+
 template <typename InputIterator, typename Allocator>
-flat_multiset(InputIterator, InputIterator, Allocator const&) -> flat_multiset<typename std::iterator_traits<InputIterator>::value_type, std::less<typename std::iterator_traits<InputIterator>::value_type>, Allocator>;
+flat_multiset(InputIterator, InputIterator, Allocator const&) ->
+   flat_multiset< typename iterator_traits<InputIterator>::value_type
+                , std::less<typename iterator_traits<InputIterator>::value_type>
+                , Allocator>;
+
 template <typename InputIterator, typename Compare>
-flat_multiset(InputIterator, InputIterator, Compare const&) -> flat_multiset<typename std::iterator_traits<InputIterator>::value_type, Compare>;
+flat_multiset(InputIterator, InputIterator, Compare const&) ->
+   flat_multiset<typename iterator_traits<InputIterator>::value_type, Compare>;
+
 template <typename InputIterator, typename Compare, typename Allocator>
-flat_multiset(InputIterator, InputIterator, Compare const&, Allocator const&) -> flat_multiset<typename std::iterator_traits<InputIterator>::value_type, Compare, Allocator>;
+flat_multiset(InputIterator, InputIterator, Compare const&, Allocator const&) ->
+   flat_multiset<typename iterator_traits<InputIterator>::value_type, Compare, Allocator>;
+
 template <typename InputIterator>
-flat_multiset(ordered_range_t, InputIterator, InputIterator) -> flat_multiset<typename std::iterator_traits<InputIterator>::value_type>;
+flat_multiset(ordered_range_t, InputIterator, InputIterator) ->
+   flat_multiset<typename iterator_traits<InputIterator>::value_type>;
+
 template <typename InputIterator, typename Allocator>
-flat_multiset(ordered_range_t, InputIterator, InputIterator, Allocator const&) -> flat_multiset<typename std::iterator_traits<InputIterator>::value_type, std::less<typename std::iterator_traits<InputIterator>::value_type>, Allocator>;
+flat_multiset(ordered_range_t, InputIterator, InputIterator, Allocator const&) ->
+   flat_multiset< typename iterator_traits<InputIterator>::value_type
+                , std::less<typename iterator_traits<InputIterator>::value_type>
+                , Allocator>;
+
 template <typename InputIterator, typename Compare>
-flat_multiset(ordered_range_t, InputIterator, InputIterator, Compare const&) -> flat_multiset<typename std::iterator_traits<InputIterator>::value_type, Compare>;
+flat_multiset(ordered_range_t, InputIterator, InputIterator, Compare const&) ->
+   flat_multiset< typename iterator_traits<InputIterator>::value_type, Compare>;
+
 template <typename InputIterator, typename Compare, typename Allocator>
-flat_multiset(ordered_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) -> flat_multiset<typename std::iterator_traits<InputIterator>::value_type, Compare, Allocator>;
+flat_multiset(ordered_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) ->
+   flat_multiset<typename iterator_traits<InputIterator>::value_type, Compare, Allocator>;
+
 #endif
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED

include/boost/container/list.hpp

@@ -1466,9 +1466,12 @@ class list
 
 #if __cplusplus >= 201703L
 template <typename InputIterator>
-list(InputIterator, InputIterator) -> list<typename std::iterator_traits<InputIterator>::value_type>;
+list(InputIterator, InputIterator) ->
+   list<typename iterator_traits<InputIterator>::value_type>;
+
 template <typename InputIterator, typename Allocator>
-list(InputIterator, InputIterator, Allocator const&) -> list<typename std::iterator_traits<InputIterator>::value_type, Allocator>;
+list(InputIterator, InputIterator, Allocator const&) ->
+   list<typename iterator_traits<InputIterator>::value_type, Allocator>;
 #endif
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED

include/boost/container/map.hpp

@@ -1264,22 +1264,57 @@ class map
 };
 
 #if __cplusplus >= 201703L
+
 template <typename InputIterator>
-map(InputIterator, InputIterator) -> map<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type>;
+map(InputIterator, InputIterator) ->
+   map< typename dtl::remove_const< typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type>;
+
 template <typename InputIterator, typename Allocator>
-map(InputIterator, InputIterator, Allocator const&) -> map<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, std::less<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>>, Allocator>;
+map(InputIterator, InputIterator, Allocator const&) ->
+   map< typename dtl::remove_const< typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , std::less<typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type>
+           , Allocator>;
+
 template <typename InputIterator, typename Compare>
-map(InputIterator, InputIterator, Compare const&) -> map<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, Compare>;
+map(InputIterator, InputIterator, Compare const&) ->
+   map< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , Compare>;
+
 template <typename InputIterator, typename Compare, typename Allocator>
-map(InputIterator, InputIterator, Compare const&, Allocator const&) -> map<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, Compare, Allocator>;
+map(InputIterator, InputIterator, Compare const&, Allocator const&) ->
+   map< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , Compare
+           , Allocator>;
+
 template <typename InputIterator>
-map(ordered_unique_range_t, InputIterator, InputIterator) -> map<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type>;
+map(ordered_unique_range_t, InputIterator, InputIterator) ->
+   map< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type>;
+
 template <typename InputIterator, typename Allocator>
-map(ordered_unique_range_t, InputIterator, InputIterator, Allocator const&) -> map<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, std::less<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>>, Allocator>;
+map(ordered_unique_range_t, InputIterator, InputIterator, Allocator const&) ->
+   map< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , std::less<typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type>
+           , Allocator>;
+
 template <typename InputIterator, typename Compare>
-map(ordered_unique_range_t, InputIterator, InputIterator, Compare const&) -> map<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, Compare>;
+map(ordered_unique_range_t, InputIterator, InputIterator, Compare const&) ->
+   map< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , Compare>;
+
 template <typename InputIterator, typename Compare, typename Allocator>
-map(ordered_unique_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) -> map<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, Compare, Allocator>;
+map(ordered_unique_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) ->
+   map< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , Compare
+           , Allocator>;
+
 #endif
 
 
@@ -2118,22 +2153,57 @@ class multimap
 };
 
 #if __cplusplus >= 201703L
+
 template <typename InputIterator>
-multimap(InputIterator, InputIterator) -> multimap<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type>;
+multimap(InputIterator, InputIterator) ->
+   multimap<typename dtl::remove_const< typename iterator_traits<InputIterator>::value_type::first_type>::type
+                        , typename iterator_traits<InputIterator>::value_type::second_type>;
+
 template <typename InputIterator, typename Allocator>
-multimap(InputIterator, InputIterator, Allocator const&) -> multimap<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, std::less<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>>, Allocator>;
+multimap(InputIterator, InputIterator, Allocator const&) ->
+   multimap<typename dtl::remove_const< typename iterator_traits<InputIterator>::value_type::first_type>::type
+                        , typename iterator_traits<InputIterator>::value_type::second_type
+                        , std::less<typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type>
+                        , Allocator>;
+
 template <typename InputIterator, typename Compare>
-multimap(InputIterator, InputIterator, Compare const&) -> multimap<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, Compare>;
+multimap(InputIterator, InputIterator, Compare const&) ->
+   multimap< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , Compare>;
+
 template <typename InputIterator, typename Compare, typename Allocator>
-multimap(InputIterator, InputIterator, Compare const&, Allocator const&) -> multimap<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, Compare, Allocator>;
+multimap(InputIterator, InputIterator, Compare const&, Allocator const&) ->
+   multimap< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , Compare
+           , Allocator>;
+
 template <typename InputIterator>
-multimap(ordered_range_t, InputIterator, InputIterator) -> multimap<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type>;
+multimap(ordered_range_t, InputIterator, InputIterator) ->
+   multimap< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type>;
+
 template <typename InputIterator, typename Allocator>
-multimap(ordered_range_t, InputIterator, InputIterator, Allocator const&) -> multimap<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, std::less<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>>, Allocator>;
+multimap(ordered_range_t, InputIterator, InputIterator, Allocator const&) ->
+   multimap< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , std::less<typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type>
+           , Allocator>;
+
 template <typename InputIterator, typename Compare>
-multimap(ordered_range_t, InputIterator, InputIterator, Compare const&) -> multimap<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, Compare>;
+multimap(ordered_range_t, InputIterator, InputIterator, Compare const&) ->
+   multimap< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , Compare>;
+
 template <typename InputIterator, typename Compare, typename Allocator>
-multimap(ordered_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) -> multimap<std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type::first_type>, typename std::iterator_traits<InputIterator>::value_type::second_type, Compare, Allocator>;
+multimap(ordered_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) ->
+   multimap< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type
+           , typename iterator_traits<InputIterator>::value_type::second_type
+           , Compare
+           , Allocator>;
+
 #endif
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED

include/boost/container/pmr/synchronized_pool_resource.hpp

@@ -20,6 +20,7 @@
 #include <boost/container/detail/auto_link.hpp>
 #include <boost/container/pmr/memory_resource.hpp>
 #include <boost/container/detail/pool_resource.hpp>
+#include <boost/container/detail/thread_mutex.hpp>
 
 #include <cstddef>
 
@@ -60,8 +61,8 @@ namespace pmr {
 class BOOST_CONTAINER_DECL synchronized_pool_resource
    : public memory_resource
 {
-   pool_resource m_pool_resource;
-   void *m_opaque_sync;
+   dtl::thread_mutex m_mut;
+   pool_resource     m_pool_resource;
 
    public:
 

include/boost/container/set.hpp

@@ -935,22 +935,39 @@ class set
 };
 
 #if __cplusplus >= 201703L
+
 template <typename InputIterator>
-set(InputIterator, InputIterator) -> set<typename std::iterator_traits<InputIterator>::value_type>;
+set(InputIterator, InputIterator) ->
+   set<typename iterator_traits<InputIterator>::value_type>;
+
 template <typename InputIterator, typename Allocator>
-set(InputIterator, InputIterator, Allocator const&) -> set<typename std::iterator_traits<InputIterator>::value_type, std::less<typename std::iterator_traits<InputIterator>::value_type>, Allocator>;
+set(InputIterator, InputIterator, Allocator const&) ->
+   set<typename iterator_traits<InputIterator>::value_type, std::less<typename iterator_traits<InputIterator>::value_type>, Allocator>;
+
 template <typename InputIterator, typename Compare>
-set(InputIterator, InputIterator, Compare const&) -> set<typename std::iterator_traits<InputIterator>::value_type, Compare>;
+set(InputIterator, InputIterator, Compare const&) ->
+   set<typename iterator_traits<InputIterator>::value_type, Compare>;
+
 template <typename InputIterator, typename Compare, typename Allocator>
-set(InputIterator, InputIterator, Compare const&, Allocator const&) -> set<typename std::iterator_traits<InputIterator>::value_type, Compare, Allocator>;
+set(InputIterator, InputIterator, Compare const&, Allocator const&) ->
+   set<typename iterator_traits<InputIterator>::value_type, Compare, Allocator>;
+
 template <typename InputIterator>
-set(ordered_unique_range_t, InputIterator, InputIterator) -> set<typename std::iterator_traits<InputIterator>::value_type>;
+set(ordered_unique_range_t, InputIterator, InputIterator) ->
+   set<typename iterator_traits<InputIterator>::value_type>;
+
 template <typename InputIterator, typename Allocator>
-set(ordered_unique_range_t, InputIterator, InputIterator, Allocator const&) -> set<typename std::iterator_traits<InputIterator>::value_type, std::less<typename std::iterator_traits<InputIterator>::value_type>, Allocator>;
+set(ordered_unique_range_t, InputIterator, InputIterator, Allocator const&) ->
+   set<typename iterator_traits<InputIterator>::value_type, std::less<typename iterator_traits<InputIterator>::value_type>, Allocator>;
+
 template <typename InputIterator, typename Compare>
-set(ordered_unique_range_t, InputIterator, InputIterator, Compare const&) -> set<typename std::iterator_traits<InputIterator>::value_type, Compare>;
+set(ordered_unique_range_t, InputIterator, InputIterator, Compare const&) ->
+   set<typename iterator_traits<InputIterator>::value_type, Compare>;
+
 template <typename InputIterator, typename Compare, typename Allocator>
-set(ordered_unique_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) -> set<typename std::iterator_traits<InputIterator>::value_type, Compare, Allocator>;
+set(ordered_unique_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) ->
+   set<typename iterator_traits<InputIterator>::value_type, Compare, Allocator>;
+
 #endif
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
@@ -1540,22 +1557,43 @@ class multiset
 };
 
 #if __cplusplus >= 201703L
+
 template <typename InputIterator>
-multiset(InputIterator, InputIterator) -> multiset<typename std::iterator_traits<InputIterator>::value_type>;
+multiset(InputIterator, InputIterator) ->
+   multiset<typename iterator_traits<InputIterator>::value_type>;
+
 template <typename InputIterator, typename Allocator>
-multiset(InputIterator, InputIterator, Allocator const&) -> multiset<typename std::iterator_traits<InputIterator>::value_type, std::less<typename std::iterator_traits<InputIterator>::value_type>, Allocator>;
+multiset(InputIterator, InputIterator, Allocator const&) ->
+   multiset< typename iterator_traits<InputIterator>::value_type
+                , std::less<typename iterator_traits<InputIterator>::value_type>
+                , Allocator>;
+
 template <typename InputIterator, typename Compare>
-multiset(InputIterator, InputIterator, Compare const&) -> multiset<typename std::iterator_traits<InputIterator>::value_type, Compare>;
+multiset(InputIterator, InputIterator, Compare const&) ->
+   multiset<typename iterator_traits<InputIterator>::value_type, Compare>;
+
 template <typename InputIterator, typename Compare, typename Allocator>
-multiset(InputIterator, InputIterator, Compare const&, Allocator const&) -> multiset<typename std::iterator_traits<InputIterator>::value_type, Compare, Allocator>;
+multiset(InputIterator, InputIterator, Compare const&, Allocator const&) ->
+   multiset<typename iterator_traits<InputIterator>::value_type, Compare, Allocator>;
+
 template <typename InputIterator>
-multiset(ordered_range_t, InputIterator, InputIterator) -> multiset<typename std::iterator_traits<InputIterator>::value_type>;
+multiset(ordered_range_t, InputIterator, InputIterator) ->
+   multiset<typename iterator_traits<InputIterator>::value_type>;
+
 template <typename InputIterator, typename Allocator>
-multiset(ordered_range_t, InputIterator, InputIterator, Allocator const&) -> multiset<typename std::iterator_traits<InputIterator>::value_type, std::less<typename std::iterator_traits<InputIterator>::value_type>, Allocator>;
+multiset(ordered_range_t, InputIterator, InputIterator, Allocator const&) ->
+   multiset< typename iterator_traits<InputIterator>::value_type
+                , std::less<typename iterator_traits<InputIterator>::value_type>
+                , Allocator>;
+
 template <typename InputIterator, typename Compare>
-multiset(ordered_range_t, InputIterator, InputIterator, Compare const&) -> multiset<typename std::iterator_traits<InputIterator>::value_type, Compare>;
+multiset(ordered_range_t, InputIterator, InputIterator, Compare const&) ->
+   multiset< typename iterator_traits<InputIterator>::value_type, Compare>;
+
 template <typename InputIterator, typename Compare, typename Allocator>
-multiset(ordered_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) -> multiset<typename std::iterator_traits<InputIterator>::value_type, Compare, Allocator>;
+multiset(ordered_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) ->
+   multiset<typename iterator_traits<InputIterator>::value_type, Compare, Allocator>;
+
 #endif
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED

include/boost/container/slist.hpp

@@ -1633,10 +1633,15 @@ class slist
 };
 
 #if __cplusplus >= 201703L
+
 template <typename InpIt>
-slist(InpIt, InpIt) -> slist<typename std::iterator_traits<InpIt>::value_type>;
+slist(InpIt, InpIt) ->
+   slist<typename iterator_traits<InpIt>::value_type>;
+
 template <typename InpIt, typename Allocator>
-slist(InpIt, InpIt, Allocator const&) -> slist<typename std::iterator_traits<InpIt>::value_type, Allocator>;
+slist(InpIt, InpIt, Allocator const&) ->
+   slist<typename iterator_traits<InpIt>::value_type, Allocator>;
+
 #endif
 
 }}

include/boost/container/stable_vector.hpp

@@ -2086,10 +2086,15 @@ class stable_vector
 };
 
 #if __cplusplus >= 201703L
+
 template <typename InputIterator>
-stable_vector(InputIterator, InputIterator) -> stable_vector<typename std::iterator_traits<InputIterator>::value_type>;
+stable_vector(InputIterator, InputIterator) ->
+   stable_vector<typename iterator_traits<InputIterator>::value_type>;
+
 template <typename InputIterator, typename Allocator>
-stable_vector(InputIterator, InputIterator, Allocator const&) -> stable_vector<typename std::iterator_traits<InputIterator>::value_type, Allocator>;
+stable_vector(InputIterator, InputIterator, Allocator const&) ->
+   stable_vector<typename iterator_traits<InputIterator>::value_type, Allocator>;
+
 #endif
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED

include/boost/container/string.hpp

@@ -2934,10 +2934,15 @@ class basic_string
 };
 
 #if __cplusplus >= 201703L
+
 template <typename InputIterator>
-basic_string(InputIterator, InputIterator) -> basic_string<typename std::iterator_traits<InputIterator>::value_type>;
+basic_string(InputIterator, InputIterator) ->
+   basic_string<typename iterator_traits<InputIterator>::value_type>;
+
 template <typename InputIterator, typename Allocator>
-basic_string(InputIterator, InputIterator, Allocator const&) -> basic_string<typename std::iterator_traits<InputIterator>::value_type, Allocator>;
+basic_string(InputIterator, InputIterator, Allocator const&) ->
+   basic_string<typename iterator_traits<InputIterator>::value_type, Allocator>;
+
 #endif
 
 #ifdef BOOST_CONTAINER_DOXYGEN_INVOKED

include/boost/container/vector.hpp

@@ -3365,10 +3365,15 @@ class vector
 };
 
 #if __cplusplus >= 201703L
+
 template <typename InputIterator>
-vector(InputIterator, InputIterator) -> vector<typename std::iterator_traits<InputIterator>::value_type>;
+vector(InputIterator, InputIterator) ->
+   vector<typename iterator_traits<InputIterator>::value_type>;
+
 template <typename InputIterator, typename Allocator>
-vector(InputIterator, InputIterator, Allocator const&) -> vector<typename std::iterator_traits<InputIterator>::value_type, Allocator>;
+vector(InputIterator, InputIterator, Allocator const&) ->
+   vector<typename iterator_traits<InputIterator>::value_type, Allocator>;
+
 #endif