boostorg/container
1
0
Fork 1
mirror of https://github.com/boostorg/container.git synced 2025-08-01 13:34:30 +02:00
Code Issues Packages Projects Releases Wiki Activity

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

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

* Fixed race condition bug in unsynchronized_pool_resource
This commit is contained in:
Ion Gaztañaga
2018-06-14 13:17:55 +02:00
parent 69d42ef636
commit 9a22431578
16 changed files with 532 additions and 109 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
doc/container.qbk
View File

@@ -1247,12 +1247,17 @@ use [*Boost.Container]? There are several reasons for that:
* Implemented C++14's heterogeneous lookup functions for `[multi]map/[multi]set/flat_[multi]map/flat_[multi]set`.
* Added [@https://github.com/boostorg/container/pull/71 GitHub #71: ['"Constructor Template Auto Deduction guides "]].
* Fixed bugs:
* [@https://svn.boost.org/trac/boost/ticket/13533 Trac #13533: ['"Boost vector resize causes assert(false)"]].
* [@https://github.com/boostorg/container/issues/73 GitHub #73: ['"triviality of pair"]].
* Fixed race condition bug in [classref boost::container::pmr::unsynchronized_pool_resource unsynchronized_pool_resource]
found by Arthur O'Dowyer in his blog post
[@https://quuxplusone.github.io/blog/2018/06/05/libcpp-memory-resource/ <memory_resource> for libc++]
[endsect]
[section:release_notes_boost_1_67_00 Boost 1.67 Release]
* ['vector] can now have options, using [classref boost::container::vector_options vector_options].

4
include/boost/container/deque.hpp
View File

@@ -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
}}

8
include/boost/container/detail/pair.hpp
View File

@@ -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 {

179
include/boost/container/detail/thread_mutex.hpp Normal file
View File

@@ -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

102
include/boost/container/flat_map.hpp
View File

@@ -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
}}

70
include/boost/container/flat_set.hpp
View File

@@ -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

7
include/boost/container/list.hpp
View File

@@ -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

102
include/boost/container/map.hpp
View File

@@ -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

5
include/boost/container/pmr/synchronized_pool_resource.hpp
View File

@@ -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:

70
include/boost/container/set.hpp
View File

@@ -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

9
include/boost/container/slist.hpp
View File

@@ -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
}}

9
include/boost/container/stable_vector.hpp
View File

@@ -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

9
include/boost/container/string.hpp
View File

@@ -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

9
include/boost/container/vector.hpp
View File

@@ -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

3
proj/vc7ide/container.vcproj
View File

@@ -314,6 +314,9 @@
<File
RelativePath="..\..\..\..\boost\container\detail\std_fwd.hpp">
</File>
<File
RelativePath="..\..\..\..\boost\container\detail\thread_mutex.hpp">
</File>
<File
RelativePath="..\to-do.txt">
</File>

48
src/synchronized_pool_resource.cpp
View File

@@ -11,31 +11,29 @@
#define BOOST_CONTAINER_SOURCE
#include <boost/container/detail/config_begin.hpp>
#include <boost/container/detail/workaround.hpp>
#include <boost/container/detail/dlmalloc.hpp>
#include <boost/container/detail/thread_mutex.hpp>
#include <boost/container/pmr/synchronized_pool_resource.hpp>
#include <cstddef>
namespace {
using namespace boost::container;
using namespace boost::container::dtl;
class dlmalloc_sync_scoped_lock
class thread_mutex_lock
{
void *m_sync;
thread_mutex &m_mut;
public:
explicit dlmalloc_sync_scoped_lock(void *sync)
: m_sync(sync)
explicit thread_mutex_lock(thread_mutex &m)
: m_mut(m)
{
if(!dlmalloc_sync_lock(m_sync)){
throw_bad_alloc();
}
m_mut.lock();
}
~dlmalloc_sync_scoped_lock()
~thread_mutex_lock()
{
dlmalloc_sync_unlock(m_sync);
m_mut.unlock();
}
};
@@ -46,32 +44,28 @@ namespace container {
namespace pmr {
synchronized_pool_resource::synchronized_pool_resource(const pool_options& opts, memory_resource* upstream) BOOST_NOEXCEPT
: m_pool_resource(opts, upstream), m_opaque_sync()
: m_mut(), m_pool_resource(opts, upstream)
{}
synchronized_pool_resource::synchronized_pool_resource() BOOST_NOEXCEPT
: m_pool_resource(), m_opaque_sync()
: m_mut(), m_pool_resource()
{}
synchronized_pool_resource::synchronized_pool_resource(memory_resource* upstream) BOOST_NOEXCEPT
: m_pool_resource(upstream), m_opaque_sync()
: m_mut(), m_pool_resource(upstream)
{}
synchronized_pool_resource::synchronized_pool_resource(const pool_options& opts) BOOST_NOEXCEPT
: m_pool_resource(opts), m_opaque_sync()
: m_mut(), m_pool_resource(opts)
{}
synchronized_pool_resource::~synchronized_pool_resource() //virtual
{
if(m_opaque_sync)
dlmalloc_sync_destroy(m_opaque_sync);
}
{}
void synchronized_pool_resource::release()
{
if(m_opaque_sync){ //If there is no mutex, no allocation could be done
m_pool_resource.release();
}
thread_mutex_lock lck(m_mut); (void)lck;
m_pool_resource.release();
}
memory_resource* synchronized_pool_resource::upstream_resource() const
@@ -82,19 +76,13 @@ pool_options synchronized_pool_resource::options() const
void* synchronized_pool_resource::do_allocate(std::size_t bytes, std::size_t alignment) //virtual
{
if(!m_opaque_sync){ //If there is no mutex, no allocation could be done
m_opaque_sync = dlmalloc_sync_create();
if(!m_opaque_sync){
throw_bad_alloc();
}
}
dlmalloc_sync_scoped_lock lock(m_opaque_sync); (void)lock;
thread_mutex_lock lck(m_mut); (void)lck;
return m_pool_resource.do_allocate(bytes, alignment);
}
void synchronized_pool_resource::do_deallocate(void* p, std::size_t bytes, std::size_t alignment) //virtual
{
dlmalloc_sync_scoped_lock lock(m_opaque_sync); (void)lock;
thread_mutex_lock lck(m_mut); (void)lck;
return m_pool_resource.do_deallocate(p, bytes, alignment);
}