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

Rewrite CTAD and SFINAE-out overloads as the standard requires

Browse Source
This commit is contained in:
Ion Gaztañaga
2018-11-12 22:52:45 +01:00
parent 204c30d8ec
commit cb21746b80
23 changed files with 869 additions and 316 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -2238,7 +2238,7 @@ class deque : protected deque_base<Allocator>
#endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED #endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
}; };
#if __cplusplus >= 201703L #ifndef BOOST_CONTAINER_NO_CXX17_CTAD
template <typename InputIterator> template <typename InputIterator>
deque(InputIterator, InputIterator) -> deque<typename iterator_traits<InputIterator>::value_type>; deque(InputIterator, InputIterator) -> deque<typename iterator_traits<InputIterator>::value_type>;
template <typename InputIterator, typename Allocator> template <typename InputIterator, typename Allocator>

13
include/boost/container/detail/iterator.hpp
View File

@@ -23,6 +23,7 @@
#include <boost/intrusive/detail/iterator.hpp> #include <boost/intrusive/detail/iterator.hpp>
#include <boost/move/utility_core.hpp> #include <boost/move/utility_core.hpp>
#include <boost/container/detail/mpl.hpp>
namespace boost { namespace boost {
namespace container { namespace container {
@@ -63,6 +64,18 @@ class back_emplacer
back_emplacer& operator++(int){ return *this; } back_emplacer& operator++(int){ return *this; }
}; };
#ifndef BOOST_CONTAINER_NO_CXX17_CTAD
template<class InputIterator>
using it_based_non_const_first_type_t = typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type;
template<class InputIterator>
using it_based_second_type_t = typename iterator_traits<InputIterator>::value_type::second_type;
template<class InputIterator>
using it_based_value_type_t = typename iterator_traits<InputIterator>::value_type;
#endif
} //namespace container { } //namespace container {
} //namespace boost { } //namespace boost {

31
include/boost/container/detail/mpl.hpp
View File

@@ -61,6 +61,7 @@ using boost::move_detail::enable_if_and;
using boost::move_detail::disable_if_and; using boost::move_detail::disable_if_and;
using boost::move_detail::enable_if_or; using boost::move_detail::enable_if_or;
using boost::move_detail::disable_if_or; using boost::move_detail::disable_if_or;
using boost::move_detail::remove_const;
template <class FirstType> template <class FirstType>
struct select1st struct select1st
@@ -102,6 +103,36 @@ struct enable_if_transparent
: boost::move_detail::enable_if_c<dtl::is_transparent<C>::value, R> : boost::move_detail::enable_if_c<dtl::is_transparent<C>::value, R>
{}; {};
#ifndef BOOST_CONTAINER_NO_CXX17_CTAD
// void_t (void_t for C++11)
template<typename...> using variadic_void_t = void;
// Trait to detect Allocator-like types.
template<typename Allocator, typename = void>
struct is_allocator
{
static const bool value = false;
};
template <typename T>
T&& ctad_declval();
template<typename Allocator>
struct is_allocator < Allocator,
variadic_void_t< typename Allocator::value_type
, decltype(ctad_declval<Allocator&>().allocate(size_t{})) >>
{
static const bool value = true;
};
template<class T>
using require_allocator_t = typename enable_if_c<is_allocator<T>::value, T>::type;
template<class T>
using require_nonallocator_t = typename enable_if_c<!is_allocator<T>::value, T>::type;
#endif
} //namespace dtl { } //namespace dtl {
} //namespace container { } //namespace container {

7
include/boost/container/detail/workaround.hpp
View File

@@ -119,4 +119,11 @@
#define BOOST_CONTAINER_ASAN #define BOOST_CONTAINER_ASAN
#endif #endif
#if (__cplusplus >= 201703L)
//CTAD supported
#else
#define BOOST_CONTAINER_NO_CXX17_CTAD
#endif
#endif //#ifndef BOOST_CONTAINER_DETAIL_WORKAROUND_HPP #endif //#ifndef BOOST_CONTAINER_DETAIL_WORKAROUND_HPP

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

@@ -319,6 +319,21 @@ class flat_map
: m_flat_tree(ordered_range, first, last, comp, dtl::force<const impl_allocator_type>(a)) : m_flat_tree(ordered_range, first, last, comp, dtl::force<const impl_allocator_type>(a))
{} {}
//! <b>Effects</b>: Constructs an empty flat_map using the specified allocator and
//! inserts elements from the ordered range [first ,last). This function
//! is more efficient than the normal range creation for ordered ranges.
//!
//! <b>Requires</b>: [first ,last) must be ordered according to the predicate.
//!
//! <b>Complexity</b>: Linear in N.
//!
//! <b>Note</b>: Non-standard extension.
template <class InputIterator>
BOOST_CONTAINER_FORCEINLINE
flat_map(ordered_unique_range_t, InputIterator first, InputIterator last, const allocator_type& a)
: m_flat_tree(ordered_range, first, last, Compare(), a)
{}
#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
//! <b>Effects</b>: Constructs an empty flat_map and //! <b>Effects</b>: Constructs an empty flat_map and
//! inserts elements from the range [il.begin() ,il.end()). //! inserts elements from the range [il.begin() ,il.end()).
@@ -1563,89 +1578,63 @@ class flat_map
#endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED #endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
}; };
#if __cplusplus >= 201703L #ifndef BOOST_CONTAINER_NO_CXX17_CTAD
template <typename InputIterator> template <typename InputIterator>
flat_map(InputIterator, InputIterator) -> flat_map(InputIterator, InputIterator) ->
flat_map< typename dtl::remove_const< typename iterator_traits<InputIterator>::value_type::first_type>::type flat_map< it_based_non_const_first_type_t<InputIterator>
, typename iterator_traits<InputIterator>::value_type::second_type>; , it_based_second_type_t<InputIterator>>;
#ifdef BOOST_HAS_CTAD_SFINAE template < typename InputIterator, typename Allocator
, typename = dtl::require_allocator_t<Allocator>>
namespace dtl {
template<class T, class U>
using enable_if_allocator_t = std::enable_if_t<std::is_same_v<decltype(std::declval<T>().allocate(0)), U *>, T>;
template<class T, class U>
using enable_if_compare_t = std::enable_if_t<std::is_same_v<decltype(std::declval<T>()(std::declval<U>(), std::declval<U>())), bool>, T>;
} // namespace dtl
template <typename InputIterator, typename Allocator>
flat_map(InputIterator, InputIterator, Allocator const&) -> flat_map(InputIterator, InputIterator, Allocator const&) ->
flat_map< typename dtl::remove_const< typename iterator_traits<InputIterator>::value_type::first_type>::type flat_map< it_based_non_const_first_type_t<InputIterator>
, typename iterator_traits<InputIterator>::value_type::second_type , it_based_second_type_t<InputIterator>
, std::less<typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type> , std::less<it_based_non_const_first_type_t<InputIterator>>
, dtl::enable_if_allocator_t<Allocator, std::remove_const_t<typename iterator_traits<InputIterator>::value_type>>>; , Allocator>;
template <typename InputIterator, typename Compare> template < typename InputIterator, typename Compare
, typename = dtl::require_nonallocator_t<Compare>>
flat_map(InputIterator, InputIterator, Compare const&) -> flat_map(InputIterator, InputIterator, Compare const&) ->
flat_map< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type flat_map< it_based_non_const_first_type_t<InputIterator>
, typename iterator_traits<InputIterator>::value_type::second_type , it_based_second_type_t<InputIterator>
, dtl::enable_if_compare_t<Compare, std::remove_const_t<typename iterator_traits<InputIterator>::value_type::first_type>>>;
#else
template <typename InputIterator, typename 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>; , Compare>;
#endif template < typename InputIterator, typename Compare, typename Allocator
, typename = dtl::require_nonallocator_t<Compare>
template <typename InputIterator, typename Compare, typename Allocator> , typename = dtl::require_allocator_t<Allocator>>
flat_map(InputIterator, InputIterator, Compare const&, Allocator const&) -> flat_map(InputIterator, InputIterator, Compare const&, Allocator const&) ->
flat_map< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type flat_map< it_based_non_const_first_type_t<InputIterator>
, typename iterator_traits<InputIterator>::value_type::second_type , it_based_second_type_t<InputIterator>
, Compare , Compare
, Allocator>; , Allocator>;
template <typename InputIterator> template <typename InputIterator>
flat_map(ordered_unique_range_t, InputIterator, InputIterator) -> flat_map(ordered_unique_range_t, InputIterator, InputIterator) ->
flat_map< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type flat_map< it_based_non_const_first_type_t<InputIterator>
, typename iterator_traits<InputIterator>::value_type::second_type>; , it_based_second_type_t<InputIterator>>;
#ifdef BOOST_HAS_CTAD_SFINAE template < typename InputIterator, typename Allocator
, typename = dtl::require_allocator_t<Allocator>>
template <typename InputIterator, typename Allocator>
flat_map(ordered_unique_range_t, InputIterator, InputIterator, Allocator const&) -> 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 flat_map< it_based_non_const_first_type_t<InputIterator>
, typename iterator_traits<InputIterator>::value_type::second_type , it_based_second_type_t<InputIterator>
, std::less<typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type> , std::less<it_based_non_const_first_type_t<InputIterator>>
, dtl::enable_if_allocator_t<Allocator, std::remove_const_t<typename iterator_traits<InputIterator>::value_type>>>; , Allocator>;
template <typename InputIterator, typename Compare> template < typename InputIterator, typename Compare
, typename = dtl::require_nonallocator_t<Compare>>
flat_map(ordered_unique_range_t, InputIterator, InputIterator, Compare const&) -> 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 flat_map< it_based_non_const_first_type_t<InputIterator>
, typename iterator_traits<InputIterator>::value_type::second_type , it_based_second_type_t<InputIterator>
, dtl::enable_if_compare_t<Compare, std::remove_const_t<typename iterator_traits<InputIterator>::value_type::first_type>>>;
#else
template <typename InputIterator, typename 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>; , Compare>;
#endif template < typename InputIterator, typename Compare, typename Allocator
, typename = dtl::require_nonallocator_t<Compare>
template <typename InputIterator, typename Compare, typename Allocator> , typename = dtl::require_allocator_t<Allocator>>
flat_map(ordered_unique_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) -> 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 flat_map< it_based_non_const_first_type_t<InputIterator>
, typename iterator_traits<InputIterator>::value_type::second_type , it_based_second_type_t<InputIterator>
, Compare , Compare
, Allocator>; , Allocator>;
@@ -1912,6 +1901,21 @@ class flat_multimap
: m_flat_tree(ordered_range, first, last, comp, a) : m_flat_tree(ordered_range, first, last, comp, a)
{} {}
//! <b>Effects</b>: Constructs an empty flat_multimap using the specified comparison object and
//! inserts elements from the ordered range [first ,last). This function
//! is more efficient than the normal range creation for ordered ranges.
//!
//! <b>Requires</b>: [first ,last) must be ordered according to the predicate.
//!
//! <b>Complexity</b>: Linear in N.
//!
//! <b>Note</b>: Non-standard extension.
template <class InputIterator>
BOOST_CONTAINER_FORCEINLINE
flat_multimap(ordered_range_t, InputIterator first, InputIterator last, const allocator_type &a)
: m_flat_tree(ordered_range, first, last, Compare(), a)
{}
#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
//! <b>Effects</b>: Constructs an empty flat_map and //! <b>Effects</b>: Constructs an empty flat_map and
//! inserts elements from the range [il.begin(), il.end()). //! inserts elements from the range [il.begin(), il.end()).
@@ -2880,82 +2884,65 @@ class flat_multimap
{ x.swap(y); } { x.swap(y); }
}; };
#if __cplusplus >= 201703L #ifndef BOOST_CONTAINER_NO_CXX17_CTAD
template <typename InputIterator> template <typename InputIterator>
flat_multimap(InputIterator, InputIterator) -> flat_multimap(InputIterator, InputIterator) ->
flat_multimap<typename dtl::remove_const< typename iterator_traits<InputIterator>::value_type::first_type>::type flat_multimap< it_based_non_const_first_type_t<InputIterator>
, typename iterator_traits<InputIterator>::value_type::second_type>; , it_based_second_type_t<InputIterator>>;
#ifdef BOOST_HAS_CTAD_SFINAE template < typename InputIterator, typename Allocator
, typename = dtl::require_allocator_t<Allocator>>
template <typename InputIterator, typename Allocator>
flat_multimap(InputIterator, InputIterator, Allocator const&) -> flat_multimap(InputIterator, InputIterator, Allocator const&) ->
flat_multimap<typename dtl::remove_const< typename iterator_traits<InputIterator>::value_type::first_type>::type flat_multimap< it_based_non_const_first_type_t<InputIterator>
, typename iterator_traits<InputIterator>::value_type::second_type , it_based_second_type_t<InputIterator>
, std::less<typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type> , std::less<it_based_non_const_first_type_t<InputIterator>>
, dtl::enable_if_allocator_t<Allocator, std::remove_const_t<typename iterator_traits<InputIterator>::value_type>>>; , Allocator>;
template <typename InputIterator, typename Compare> template < typename InputIterator, typename Compare
, typename = dtl::require_nonallocator_t<Compare>>
flat_multimap(InputIterator, InputIterator, Compare const&) -> flat_multimap(InputIterator, InputIterator, Compare const&) ->
flat_multimap< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type flat_multimap< it_based_non_const_first_type_t<InputIterator>
, typename iterator_traits<InputIterator>::value_type::second_type , it_based_second_type_t<InputIterator>
, dtl::enable_if_compare_t<Compare, std::remove_const_t<typename iterator_traits<InputIterator>::value_type::first_type>>>; , Compare>;
#else template < typename InputIterator, typename Compare, typename Allocator
, typename = dtl::require_nonallocator_t<Compare>
template <typename InputIterator, typename Compare> , typename = dtl::require_allocator_t<Allocator>>
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>;
#endif
template <typename InputIterator, typename Compare, typename Allocator>
flat_multimap(InputIterator, InputIterator, Compare const&, Allocator const&) -> flat_multimap(InputIterator, InputIterator, Compare const&, Allocator const&) ->
flat_multimap< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type flat_multimap< it_based_non_const_first_type_t<InputIterator>
, typename iterator_traits<InputIterator>::value_type::second_type , it_based_second_type_t<InputIterator>
, Compare , Compare
, Allocator>; , Allocator>;
template <typename InputIterator> template <typename InputIterator>
flat_multimap(ordered_range_t, InputIterator, InputIterator) -> flat_multimap(ordered_range_t, InputIterator, InputIterator) ->
flat_multimap< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type flat_multimap< it_based_non_const_first_type_t<InputIterator>
, typename iterator_traits<InputIterator>::value_type::second_type>; , it_based_second_type_t<InputIterator>>;
#ifdef BOOST_HAS_CTAD_SFINAE template < typename InputIterator, typename Allocator
, typename = dtl::require_allocator_t<Allocator>>
template <typename InputIterator, typename Allocator>
flat_multimap(ordered_range_t, InputIterator, InputIterator, Allocator const&) -> flat_multimap(ordered_range_t, InputIterator, InputIterator, Allocator const&) ->
flat_multimap< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type flat_multimap< it_based_non_const_first_type_t<InputIterator>
, typename iterator_traits<InputIterator>::value_type::second_type , it_based_second_type_t<InputIterator>
, std::less<typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type> , std::less<it_based_non_const_first_type_t<InputIterator>>
, dtl::enable_if_allocator_t<Allocator, std::remove_const_t<typename iterator_traits<InputIterator>::value_type>>>; , Allocator>;
template <typename InputIterator, typename Compare> template < typename InputIterator, typename Compare
, typename = dtl::require_nonallocator_t<Compare>>
flat_multimap(ordered_range_t, InputIterator, InputIterator, Compare const&) -> flat_multimap(ordered_range_t, InputIterator, InputIterator, Compare const&) ->
flat_multimap< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type flat_multimap< it_based_non_const_first_type_t<InputIterator>
, typename iterator_traits<InputIterator>::value_type::second_type , it_based_second_type_t<InputIterator>
, dtl::enable_if_compare_t<Compare, std::remove_const_t<typename iterator_traits<InputIterator>::value_type::first_type>>>; , Compare>;
#else template < typename InputIterator, typename Compare, typename Allocator
, typename = dtl::require_nonallocator_t<Compare>
template <typename InputIterator, typename Compare> , typename = dtl::require_allocator_t<Allocator>>
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>;
#endif
template <typename InputIterator, typename Compare, typename Allocator>
flat_multimap(ordered_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) -> 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 flat_multimap< it_based_non_const_first_type_t<InputIterator>
, typename iterator_traits<InputIterator>::value_type::second_type , it_based_second_type_t<InputIterator>
, Compare , Compare
, Allocator>; , Allocator>;
#endif #endif

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

@@ -257,6 +257,22 @@ class flat_set
: tree_t(ordered_unique_range, first, last, comp, a) : tree_t(ordered_unique_range, first, last, comp, a)
{} {}
//! <b>Effects</b>: Constructs an empty container using the specified allocator and
//! inserts elements from the ordered unique range [first ,last). This function
//! is more efficient than the normal range creation for ordered ranges.
//!
//! <b>Requires</b>: [first ,last) must be ordered according to the predicate and must be
//! unique values.
//!
//! <b>Complexity</b>: Linear in N.
//!
//! <b>Note</b>: Non-standard extension.
template <class InputIterator>
BOOST_CONTAINER_FORCEINLINE
flat_set(ordered_unique_range_t, InputIterator first, InputIterator last, const allocator_type& a)
: tree_t(ordered_unique_range, first, last, Compare(), a)
{}
#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
//! <b>Effects</b>: Constructs an empty container and //! <b>Effects</b>: Constructs an empty container and
//! inserts elements from the range [il.begin(), il.end()). //! inserts elements from the range [il.begin(), il.end()).
@@ -1108,39 +1124,57 @@ class flat_set
#endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED #endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
}; };
#if __cplusplus >= 201703L #ifndef BOOST_CONTAINER_NO_CXX17_CTAD
template <typename InputIterator> template <typename InputIterator>
flat_set(InputIterator, InputIterator) -> flat_set(InputIterator, InputIterator) ->
flat_set<typename iterator_traits<InputIterator>::value_type>; flat_set< it_based_value_type_t<InputIterator> >;
template <typename InputIterator, typename Allocator> template < typename InputIterator, typename Allocator
, typename = dtl::require_allocator_t<Allocator>>
flat_set(InputIterator, InputIterator, Allocator const&) -> flat_set(InputIterator, InputIterator, Allocator const&) ->
flat_set<typename iterator_traits<InputIterator>::value_type, std::less<typename iterator_traits<InputIterator>::value_type>, Allocator>; flat_set< it_based_value_type_t<InputIterator>
, std::less<it_based_value_type_t<InputIterator>>
, Allocator>;
template <typename InputIterator, typename Compare> template < typename InputIterator, typename Compare
, typename = dtl::require_nonallocator_t<Compare>>
flat_set(InputIterator, InputIterator, Compare const&) -> flat_set(InputIterator, InputIterator, Compare const&) ->
flat_set<typename iterator_traits<InputIterator>::value_type, Compare>; flat_set< it_based_value_type_t<InputIterator>
, Compare>;
template <typename InputIterator, typename Compare, typename Allocator> template < typename InputIterator, typename Compare, typename Allocator
, typename = dtl::require_nonallocator_t<Compare>
, typename = dtl::require_allocator_t<Allocator>>
flat_set(InputIterator, InputIterator, Compare const&, Allocator const&) -> flat_set(InputIterator, InputIterator, Compare const&, Allocator const&) ->
flat_set<typename iterator_traits<InputIterator>::value_type, Compare, Allocator>; flat_set< it_based_value_type_t<InputIterator>
, Compare
, Allocator>;
template <typename InputIterator> template <typename InputIterator>
flat_set(ordered_unique_range_t, InputIterator, InputIterator) -> flat_set(ordered_unique_range_t, InputIterator, InputIterator) ->
flat_set<typename iterator_traits<InputIterator>::value_type>; flat_set< it_based_value_type_t<InputIterator>>;
template <typename InputIterator, typename Allocator> template < typename InputIterator, typename Allocator
, typename = dtl::require_allocator_t<Allocator>>
flat_set(ordered_unique_range_t, InputIterator, InputIterator, Allocator const&) -> 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>; flat_set< it_based_value_type_t<InputIterator>
, std::less<it_based_value_type_t<InputIterator>>
, Allocator>;
template <typename InputIterator, typename Compare> template < typename InputIterator, typename Compare
, typename = dtl::require_nonallocator_t<Compare>>
flat_set(ordered_unique_range_t, InputIterator, InputIterator, Compare const&) -> flat_set(ordered_unique_range_t, InputIterator, InputIterator, Compare const&) ->
flat_set<typename iterator_traits<InputIterator>::value_type, Compare>; flat_set< it_based_value_type_t<InputIterator>
, Compare>;
template <typename InputIterator, typename Compare, typename Allocator> template < typename InputIterator, typename Compare, typename Allocator
, typename = dtl::require_nonallocator_t<Compare>
, typename = dtl::require_allocator_t<Allocator>>
flat_set(ordered_unique_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) -> flat_set(ordered_unique_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) ->
flat_set<typename iterator_traits<InputIterator>::value_type, Compare, Allocator>; flat_set< it_based_value_type_t<InputIterator>
, Compare
, Allocator>;
#endif #endif
@@ -1320,6 +1354,20 @@ class flat_multiset
: tree_t(ordered_range, first, last, comp, a) : tree_t(ordered_range, first, last, comp, a)
{} {}
//! <b>Effects</b>: Constructs an empty flat_multiset using the specified allocator and
//! inserts elements from the ordered range [first ,last ). This function
//! is more efficient than the normal range creation for ordered ranges.
//!
//! <b>Requires</b>: [first ,last) must be ordered according to the predicate.
//!
//! <b>Complexity</b>: Linear in N.
//!
//! <b>Note</b>: Non-standard extension.
template <class InputIterator>
BOOST_CONTAINER_FORCEINLINE flat_multiset(ordered_range_t, InputIterator first, InputIterator last, const allocator_type &a)
: tree_t(ordered_range, first, last, Compare(), a)
{}
#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
//! @copydoc ::boost::container::flat_set::flat_set(std::initializer_list<value_type) //! @copydoc ::boost::container::flat_set::flat_set(std::initializer_list<value_type)
BOOST_CONTAINER_FORCEINLINE flat_multiset(std::initializer_list<value_type> il) BOOST_CONTAINER_FORCEINLINE flat_multiset(std::initializer_list<value_type> il)
@@ -1805,43 +1853,57 @@ class flat_multiset
#endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED #endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
}; };
#if __cplusplus >= 201703L #ifndef BOOST_CONTAINER_NO_CXX17_CTAD
template <typename InputIterator> template <typename InputIterator>
flat_multiset(InputIterator, InputIterator) -> flat_multiset(InputIterator, InputIterator) ->
flat_multiset<typename iterator_traits<InputIterator>::value_type>; flat_multiset< it_based_value_type_t<InputIterator> >;
template <typename InputIterator, typename Allocator> template < typename InputIterator, typename Allocator
, typename = dtl::require_allocator_t<Allocator>>
flat_multiset(InputIterator, InputIterator, Allocator const&) -> flat_multiset(InputIterator, InputIterator, Allocator const&) ->
flat_multiset< typename iterator_traits<InputIterator>::value_type flat_multiset< it_based_value_type_t<InputIterator>
, std::less<typename iterator_traits<InputIterator>::value_type> , std::less<it_based_value_type_t<InputIterator>>
, Allocator>; , Allocator>;
template <typename InputIterator, typename Compare> template < typename InputIterator, typename Compare
, typename = dtl::require_nonallocator_t<Compare>>
flat_multiset(InputIterator, InputIterator, Compare const&) -> flat_multiset(InputIterator, InputIterator, Compare const&) ->
flat_multiset<typename iterator_traits<InputIterator>::value_type, Compare>; flat_multiset< it_based_value_type_t<InputIterator>
, Compare>;
template <typename InputIterator, typename Compare, typename Allocator> template < typename InputIterator, typename Compare, typename Allocator
, typename = dtl::require_nonallocator_t<Compare>
, typename = dtl::require_allocator_t<Allocator>>
flat_multiset(InputIterator, InputIterator, Compare const&, Allocator const&) -> flat_multiset(InputIterator, InputIterator, Compare const&, Allocator const&) ->
flat_multiset<typename iterator_traits<InputIterator>::value_type, Compare, Allocator>; flat_multiset< it_based_value_type_t<InputIterator>
, Compare
, Allocator>;
template <typename InputIterator> template <typename InputIterator>
flat_multiset(ordered_range_t, InputIterator, InputIterator) -> flat_multiset(ordered_range_t, InputIterator, InputIterator) ->
flat_multiset<typename iterator_traits<InputIterator>::value_type>; flat_multiset< it_based_value_type_t<InputIterator>>;
template <typename InputIterator, typename Allocator> template < typename InputIterator, typename Allocator
, typename = dtl::require_allocator_t<Allocator>>
flat_multiset(ordered_range_t, InputIterator, InputIterator, Allocator const&) -> flat_multiset(ordered_range_t, InputIterator, InputIterator, Allocator const&) ->
flat_multiset< typename iterator_traits<InputIterator>::value_type flat_multiset< it_based_value_type_t<InputIterator>
, std::less<typename iterator_traits<InputIterator>::value_type> , std::less<it_based_value_type_t<InputIterator>>
, Allocator>; , Allocator>;
template <typename InputIterator, typename Compare> template < typename InputIterator, typename Compare
, typename = dtl::require_nonallocator_t<Compare>>
flat_multiset(ordered_range_t, InputIterator, InputIterator, Compare const&) -> flat_multiset(ordered_range_t, InputIterator, InputIterator, Compare const&) ->
flat_multiset< typename iterator_traits<InputIterator>::value_type, Compare>; flat_multiset< it_based_value_type_t<InputIterator>
, Compare>;
template <typename InputIterator, typename Compare, typename Allocator> template < typename InputIterator, typename Compare, typename Allocator
, typename = dtl::require_nonallocator_t<Compare>
, typename = dtl::require_allocator_t<Allocator>>
flat_multiset(ordered_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) -> flat_multiset(ordered_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) ->
flat_multiset<typename iterator_traits<InputIterator>::value_type, Compare, Allocator>; flat_multiset< it_based_value_type_t<InputIterator>
, Compare
, Allocator>;
#endif #endif

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

@@ -1498,7 +1498,7 @@ class list
}; };
#if __cplusplus >= 201703L #ifndef BOOST_CONTAINER_NO_CXX17_CTAD
template <typename InputIterator> template <typename InputIterator>
list(InputIterator, InputIterator) -> list(InputIterator, InputIterator) ->
list<typename iterator_traits<InputIterator>::value_type>; list<typename iterator_traits<InputIterator>::value_type>;

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

@@ -256,6 +256,22 @@ class map
: base_t(ordered_range, first, last, comp, a) : base_t(ordered_range, first, last, comp, a)
{} {}
//! <b>Effects</b>: Constructs an empty map using the specified allocator object and
//! inserts elements from the ordered unique range [first ,last). This function
//! is more efficient than the normal range creation for ordered ranges.
//!
//! <b>Requires</b>: [first ,last) must be ordered according to the predicate and must be
//! unique values.
//!
//! <b>Complexity</b>: Linear in N.
//!
//! <b>Note</b>: Non-standard extension.
template <class InputIterator>
BOOST_CONTAINER_FORCEINLINE map(ordered_unique_range_t, InputIterator first, InputIterator last, const allocator_type& a)
: base_t(ordered_range, first, last, Compare(), a)
{}
#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
//! <b>Effects</b>: Constructs an empty map and //! <b>Effects</b>: Constructs an empty map and
//! inserts elements from the range [il.begin(), il.end()). //! inserts elements from the range [il.begin(), il.end()).
@@ -1279,55 +1295,63 @@ class map
#endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED #endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
}; };
#if __cplusplus >= 201703L #ifndef BOOST_CONTAINER_NO_CXX17_CTAD
template <typename InputIterator> template <typename InputIterator>
map(InputIterator, InputIterator) -> map(InputIterator, InputIterator) ->
map< typename dtl::remove_const< typename iterator_traits<InputIterator>::value_type::first_type>::type map< it_based_non_const_first_type_t<InputIterator>
, typename iterator_traits<InputIterator>::value_type::second_type>; , it_based_second_type_t<InputIterator>>;
template <typename InputIterator, typename Allocator> template < typename InputIterator, typename Allocator
, typename = dtl::require_allocator_t<Allocator>>
map(InputIterator, InputIterator, Allocator const&) -> map(InputIterator, InputIterator, Allocator const&) ->
map< typename dtl::remove_const< typename iterator_traits<InputIterator>::value_type::first_type>::type map< it_based_non_const_first_type_t<InputIterator>
, typename iterator_traits<InputIterator>::value_type::second_type , it_based_second_type_t<InputIterator>
, std::less<typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type> , std::less<it_based_non_const_first_type_t<InputIterator>>
, Allocator>; , Allocator>;
template <typename InputIterator, typename Compare> template < typename InputIterator, typename Compare
, typename = dtl::require_nonallocator_t<Compare>>
map(InputIterator, InputIterator, Compare const&) -> map(InputIterator, InputIterator, Compare const&) ->
map< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type map< it_based_non_const_first_type_t<InputIterator>
, typename iterator_traits<InputIterator>::value_type::second_type , it_based_second_type_t<InputIterator>
, Compare>; , Compare>;
template <typename InputIterator, typename Compare, typename Allocator> template < typename InputIterator, typename Compare, typename Allocator
, typename = dtl::require_nonallocator_t<Compare>
, typename = dtl::require_allocator_t<Allocator>>
map(InputIterator, InputIterator, Compare const&, Allocator const&) -> map(InputIterator, InputIterator, Compare const&, Allocator const&) ->
map< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type map< it_based_non_const_first_type_t<InputIterator>
, typename iterator_traits<InputIterator>::value_type::second_type , it_based_second_type_t<InputIterator>
, Compare , Compare
, Allocator>; , Allocator>;
template <typename InputIterator> template <typename InputIterator>
map(ordered_unique_range_t, InputIterator, InputIterator) -> map(ordered_unique_range_t, InputIterator, InputIterator) ->
map< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type map< it_based_non_const_first_type_t<InputIterator>
, typename iterator_traits<InputIterator>::value_type::second_type>; , it_based_second_type_t<InputIterator>>;
template <typename InputIterator, typename Allocator> template < typename InputIterator, typename Allocator
, typename = dtl::require_allocator_t<Allocator>>
map(ordered_unique_range_t, InputIterator, InputIterator, Allocator const&) -> map(ordered_unique_range_t, InputIterator, InputIterator, Allocator const&) ->
map< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type map< it_based_non_const_first_type_t<InputIterator>
, typename iterator_traits<InputIterator>::value_type::second_type , it_based_second_type_t<InputIterator>
, std::less<typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type> , std::less<it_based_non_const_first_type_t<InputIterator>>
, Allocator>; , Allocator>;
template <typename InputIterator, typename Compare> template < typename InputIterator, typename Compare
, typename = dtl::require_nonallocator_t<Compare>>
map(ordered_unique_range_t, InputIterator, InputIterator, Compare const&) -> map(ordered_unique_range_t, InputIterator, InputIterator, Compare const&) ->
map< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type map< it_based_non_const_first_type_t<InputIterator>
, typename iterator_traits<InputIterator>::value_type::second_type , it_based_second_type_t<InputIterator>
, Compare>; , Compare>;
template <typename InputIterator, typename Compare, typename Allocator> template < typename InputIterator, typename Compare, typename Allocator
, typename = dtl::require_nonallocator_t<Compare>
, typename = dtl::require_allocator_t<Allocator>>
map(ordered_unique_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) -> 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 map< it_based_non_const_first_type_t<InputIterator>
, typename iterator_traits<InputIterator>::value_type::second_type , it_based_second_type_t<InputIterator>
, Compare , Compare
, Allocator>; , Allocator>;
@@ -1552,6 +1576,20 @@ class multimap
: base_t(ordered_range, first, last, comp, a) : base_t(ordered_range, first, last, comp, a)
{} {}
//! <b>Effects</b>: Constructs an empty multimap using the specified allocator and
//! inserts elements from the ordered range [first ,last). This function
//! is more efficient than the normal range creation for ordered ranges.
//!
//! <b>Requires</b>: [first ,last) must be ordered according to the predicate.
//!
//! <b>Complexity</b>: Linear in N.
//!
//! <b>Note</b>: Non-standard extension.
template <class InputIterator>
BOOST_CONTAINER_FORCEINLINE multimap(ordered_range_t, InputIterator first, InputIterator last, const allocator_type& a)
: base_t(ordered_range, first, last, Compare(), a)
{}
#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
//! <b>Effects</b>: Constructs an empty multimap and //! <b>Effects</b>: Constructs an empty multimap and
//! and inserts elements from the range [il.begin(), il.end()). //! and inserts elements from the range [il.begin(), il.end()).
@@ -2184,58 +2222,65 @@ class multimap
#endif //#if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) #endif //#if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
}; };
#if __cplusplus >= 201703L #ifndef BOOST_CONTAINER_NO_CXX17_CTAD
template <typename InputIterator> template <typename InputIterator>
multimap(InputIterator, InputIterator) -> multimap(InputIterator, InputIterator) ->
multimap<typename dtl::remove_const< typename iterator_traits<InputIterator>::value_type::first_type>::type multimap< it_based_non_const_first_type_t<InputIterator>
, typename iterator_traits<InputIterator>::value_type::second_type>; , it_based_second_type_t<InputIterator>>;
template <typename InputIterator, typename Allocator> template < typename InputIterator, typename Allocator
, typename = dtl::require_allocator_t<Allocator>>
multimap(InputIterator, InputIterator, Allocator const&) -> multimap(InputIterator, InputIterator, Allocator const&) ->
multimap<typename dtl::remove_const< typename iterator_traits<InputIterator>::value_type::first_type>::type multimap< it_based_non_const_first_type_t<InputIterator>
, typename iterator_traits<InputIterator>::value_type::second_type , it_based_second_type_t<InputIterator>
, std::less<typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type> , std::less<it_based_non_const_first_type_t<InputIterator>>
, Allocator>; , Allocator>;
template <typename InputIterator, typename Compare> template < typename InputIterator, typename Compare
, typename = dtl::require_nonallocator_t<Compare>>
multimap(InputIterator, InputIterator, Compare const&) -> multimap(InputIterator, InputIterator, Compare const&) ->
multimap< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type multimap< it_based_non_const_first_type_t<InputIterator>
, typename iterator_traits<InputIterator>::value_type::second_type , it_based_second_type_t<InputIterator>
, Compare>; , Compare>;
template <typename InputIterator, typename Compare, typename Allocator> template < typename InputIterator, typename Compare, typename Allocator
, typename = dtl::require_nonallocator_t<Compare>
, typename = dtl::require_allocator_t<Allocator>>
multimap(InputIterator, InputIterator, Compare const&, Allocator const&) -> multimap(InputIterator, InputIterator, Compare const&, Allocator const&) ->
multimap< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type multimap< it_based_non_const_first_type_t<InputIterator>
, typename iterator_traits<InputIterator>::value_type::second_type , it_based_second_type_t<InputIterator>
, Compare , Compare
, Allocator>; , Allocator>;
template <typename InputIterator> template <typename InputIterator>
multimap(ordered_range_t, InputIterator, InputIterator) -> multimap(ordered_range_t, InputIterator, InputIterator) ->
multimap< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type multimap< it_based_non_const_first_type_t<InputIterator>
, typename iterator_traits<InputIterator>::value_type::second_type>; , it_based_second_type_t<InputIterator>>;
template <typename InputIterator, typename Allocator> template < typename InputIterator, typename Allocator
, typename = dtl::require_allocator_t<Allocator>>
multimap(ordered_range_t, InputIterator, InputIterator, Allocator const&) -> multimap(ordered_range_t, InputIterator, InputIterator, Allocator const&) ->
multimap< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type multimap< it_based_non_const_first_type_t<InputIterator>
, typename iterator_traits<InputIterator>::value_type::second_type , it_based_second_type_t<InputIterator>
, std::less<typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type> , std::less<it_based_non_const_first_type_t<InputIterator>>
, Allocator>; , Allocator>;
template <typename InputIterator, typename Compare> template < typename InputIterator, typename Compare
, typename = dtl::require_nonallocator_t<Compare>>
multimap(ordered_range_t, InputIterator, InputIterator, Compare const&) -> multimap(ordered_range_t, InputIterator, InputIterator, Compare const&) ->
multimap< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type multimap< it_based_non_const_first_type_t<InputIterator>
, typename iterator_traits<InputIterator>::value_type::second_type , it_based_second_type_t<InputIterator>
, Compare>; , Compare>;
template <typename InputIterator, typename Compare, typename Allocator> template < typename InputIterator, typename Compare, typename Allocator
, typename = dtl::require_nonallocator_t<Compare>
, typename = dtl::require_allocator_t<Allocator>>
multimap(ordered_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) -> multimap(ordered_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) ->
multimap< typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type multimap< it_based_non_const_first_type_t<InputIterator>
, typename iterator_traits<InputIterator>::value_type::second_type , it_based_second_type_t<InputIterator>
, Compare , Compare
, Allocator>; , Allocator>;
#endif #endif
#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED

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

@@ -227,6 +227,21 @@ class set
: base_t(ordered_range, first, last, comp, a) : base_t(ordered_range, first, last, comp, a)
{} {}
//! <b>Effects</b>: Constructs an empty set using the specified allocator and
//! inserts elements from the ordered unique range [first ,last). This function
//! is more efficient than the normal range creation for ordered ranges.
//!
//! <b>Requires</b>: [first ,last) must be ordered according to the predicate and must be
//! unique values.
//!
//! <b>Complexity</b>: Linear in N.
//!
//! <b>Note</b>: Non-standard extension.
template <class InputIterator>
BOOST_CONTAINER_FORCEINLINE set(ordered_unique_range_t, InputIterator first, InputIterator last, const allocator_type& a)
: base_t(ordered_range, first, last, Compare(), a)
{}
#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
//! <b>Effects</b>: Constructs an empty set and //! <b>Effects</b>: Constructs an empty set and
//! inserts elements from the range [il.begin(), il.end()). //! inserts elements from the range [il.begin(), il.end()).
@@ -944,39 +959,57 @@ class set
#endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED #endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
}; };
#if __cplusplus >= 201703L #ifndef BOOST_CONTAINER_NO_CXX17_CTAD
template <typename InputIterator> template <typename InputIterator>
set(InputIterator, InputIterator) -> set(InputIterator, InputIterator) ->
set<typename iterator_traits<InputIterator>::value_type>; set< it_based_value_type_t<InputIterator> >;
template <typename InputIterator, typename Allocator> template < typename InputIterator, typename Allocator
, typename = dtl::require_allocator_t<Allocator>>
set(InputIterator, InputIterator, Allocator const&) -> set(InputIterator, InputIterator, Allocator const&) ->
set<typename iterator_traits<InputIterator>::value_type, std::less<typename iterator_traits<InputIterator>::value_type>, Allocator>; set< it_based_value_type_t<InputIterator>
, std::less<it_based_value_type_t<InputIterator>>
, Allocator>;
template <typename InputIterator, typename Compare> template < typename InputIterator, typename Compare
, typename = dtl::require_nonallocator_t<Compare>>
set(InputIterator, InputIterator, Compare const&) -> set(InputIterator, InputIterator, Compare const&) ->
set<typename iterator_traits<InputIterator>::value_type, Compare>; set< it_based_value_type_t<InputIterator>
, Compare>;
template <typename InputIterator, typename Compare, typename Allocator> template < typename InputIterator, typename Compare, typename Allocator
, typename = dtl::require_nonallocator_t<Compare>
, typename = dtl::require_allocator_t<Allocator>>
set(InputIterator, InputIterator, Compare const&, Allocator const&) -> set(InputIterator, InputIterator, Compare const&, Allocator const&) ->
set<typename iterator_traits<InputIterator>::value_type, Compare, Allocator>; set< it_based_value_type_t<InputIterator>
, Compare
, Allocator>;
template <typename InputIterator> template <typename InputIterator>
set(ordered_unique_range_t, InputIterator, InputIterator) -> set(ordered_unique_range_t, InputIterator, InputIterator) ->
set<typename iterator_traits<InputIterator>::value_type>; set< it_based_value_type_t<InputIterator>>;
template <typename InputIterator, typename Allocator> template < typename InputIterator, typename Allocator
, typename = dtl::require_allocator_t<Allocator>>
set(ordered_unique_range_t, InputIterator, InputIterator, Allocator const&) -> 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>; set< it_based_value_type_t<InputIterator>
, std::less<it_based_value_type_t<InputIterator>>
, Allocator>;
template <typename InputIterator, typename Compare> template < typename InputIterator, typename Compare
, typename = dtl::require_nonallocator_t<Compare>>
set(ordered_unique_range_t, InputIterator, InputIterator, Compare const&) -> set(ordered_unique_range_t, InputIterator, InputIterator, Compare const&) ->
set<typename iterator_traits<InputIterator>::value_type, Compare>; set< it_based_value_type_t<InputIterator>
, Compare>;
template <typename InputIterator, typename Compare, typename Allocator> template < typename InputIterator, typename Compare, typename Allocator
, typename = dtl::require_nonallocator_t<Compare>
, typename = dtl::require_allocator_t<Allocator>>
set(ordered_unique_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) -> set(ordered_unique_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) ->
set<typename iterator_traits<InputIterator>::value_type, Compare, Allocator>; set< it_based_value_type_t<InputIterator>
, Compare
, Allocator>;
#endif #endif
@@ -1150,6 +1183,20 @@ class multiset
: base_t(ordered_range, first, last, comp, a) : base_t(ordered_range, first, last, comp, a)
{} {}
//! <b>Effects</b>: Constructs an empty multiset using the specified allocator and
//! inserts elements from the ordered range [first ,last ). This function
//! is more efficient than the normal range creation for ordered ranges.
//!
//! <b>Requires</b>: [first ,last) must be ordered according to the predicate.
//!
//! <b>Complexity</b>: Linear in N.
//!
//! <b>Note</b>: Non-standard extension.
template <class InputIterator>
BOOST_CONTAINER_FORCEINLINE multiset(ordered_range_t, InputIterator first, InputIterator last, const allocator_type &a)
: base_t(ordered_range, first, last, Compare(), a)
{}
#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
//! @copydoc ::boost::container::set::set(std::initializer_list<value_type>) //! @copydoc ::boost::container::set::set(std::initializer_list<value_type>)
BOOST_CONTAINER_FORCEINLINE multiset(std::initializer_list<value_type> il) BOOST_CONTAINER_FORCEINLINE multiset(std::initializer_list<value_type> il)
@@ -1573,43 +1620,57 @@ class multiset
#endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED #endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
}; };
#if __cplusplus >= 201703L #ifndef BOOST_CONTAINER_NO_CXX17_CTAD
template <typename InputIterator> template <typename InputIterator>
multiset(InputIterator, InputIterator) -> multiset(InputIterator, InputIterator) ->
multiset<typename iterator_traits<InputIterator>::value_type>; multiset< it_based_value_type_t<InputIterator> >;
template <typename InputIterator, typename Allocator> template < typename InputIterator, typename Allocator
, typename = dtl::require_allocator_t<Allocator>>
multiset(InputIterator, InputIterator, Allocator const&) -> multiset(InputIterator, InputIterator, Allocator const&) ->
multiset< typename iterator_traits<InputIterator>::value_type multiset< it_based_value_type_t<InputIterator>
, std::less<typename iterator_traits<InputIterator>::value_type> , std::less<it_based_value_type_t<InputIterator>>
, Allocator>; , Allocator>;
template <typename InputIterator, typename Compare> template < typename InputIterator, typename Compare
, typename = dtl::require_nonallocator_t<Compare>>
multiset(InputIterator, InputIterator, Compare const&) -> multiset(InputIterator, InputIterator, Compare const&) ->
multiset<typename iterator_traits<InputIterator>::value_type, Compare>; multiset< it_based_value_type_t<InputIterator>
, Compare>;
template <typename InputIterator, typename Compare, typename Allocator> template < typename InputIterator, typename Compare, typename Allocator
, typename = dtl::require_nonallocator_t<Compare>
, typename = dtl::require_allocator_t<Allocator>>
multiset(InputIterator, InputIterator, Compare const&, Allocator const&) -> multiset(InputIterator, InputIterator, Compare const&, Allocator const&) ->
multiset<typename iterator_traits<InputIterator>::value_type, Compare, Allocator>; multiset< it_based_value_type_t<InputIterator>
, Compare
, Allocator>;
template <typename InputIterator> template <typename InputIterator>
multiset(ordered_range_t, InputIterator, InputIterator) -> multiset(ordered_range_t, InputIterator, InputIterator) ->
multiset<typename iterator_traits<InputIterator>::value_type>; multiset< it_based_value_type_t<InputIterator>>;
template <typename InputIterator, typename Allocator> template < typename InputIterator, typename Allocator
, typename = dtl::require_allocator_t<Allocator>>
multiset(ordered_range_t, InputIterator, InputIterator, Allocator const&) -> multiset(ordered_range_t, InputIterator, InputIterator, Allocator const&) ->
multiset< typename iterator_traits<InputIterator>::value_type multiset< it_based_value_type_t<InputIterator>
, std::less<typename iterator_traits<InputIterator>::value_type> , std::less<it_based_value_type_t<InputIterator>>
, Allocator>; , Allocator>;
template <typename InputIterator, typename Compare> template < typename InputIterator, typename Compare
, typename = dtl::require_nonallocator_t<Compare>>
multiset(ordered_range_t, InputIterator, InputIterator, Compare const&) -> multiset(ordered_range_t, InputIterator, InputIterator, Compare const&) ->
multiset< typename iterator_traits<InputIterator>::value_type, Compare>; multiset< it_based_value_type_t<InputIterator>
, Compare>;
template <typename InputIterator, typename Compare, typename Allocator> template < typename InputIterator, typename Compare, typename Allocator
, typename = dtl::require_nonallocator_t<Compare>
, typename = dtl::require_allocator_t<Allocator>>
multiset(ordered_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) -> multiset(ordered_range_t, InputIterator, InputIterator, Compare const&, Allocator const&) ->
multiset<typename iterator_traits<InputIterator>::value_type, Compare, Allocator>; multiset< it_based_value_type_t<InputIterator>
, Compare
, Allocator>;
#endif #endif

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

@@ -1668,7 +1668,7 @@ class slist
#endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED #endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
}; };
#if __cplusplus >= 201703L #ifndef BOOST_CONTAINER_NO_CXX17_CTAD
template <typename InpIt> template <typename InpIt>
slist(InpIt, InpIt) -> slist(InpIt, InpIt) ->

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

@@ -2142,7 +2142,7 @@ class stable_vector
#endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED #endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
}; };
#if __cplusplus >= 201703L #ifndef BOOST_CONTAINER_NO_CXX17_CTAD
template <typename InputIterator> template <typename InputIterator>
stable_vector(InputIterator, InputIterator) -> stable_vector(InputIterator, InputIterator) ->

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

@@ -2978,7 +2978,7 @@ class basic_string
#endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED #endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
}; };
#if __cplusplus >= 201703L #ifndef BOOST_CONTAINER_NO_CXX17_CTAD
template <typename InputIterator> template <typename InputIterator>
basic_string(InputIterator, InputIterator) -> basic_string(InputIterator, InputIterator) ->

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

@@ -3370,7 +3370,7 @@ class vector
#endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED #endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
}; };
#if __cplusplus >= 201703L #ifndef BOOST_CONTAINER_NO_CXX17_CTAD
template <typename InputIterator> template <typename InputIterator>
vector(InputIterator, InputIterator) -> vector(InputIterator, InputIterator) ->

2
test/deque_test.cpp
View File

@@ -268,7 +268,7 @@ bool do_test()
if(!test::CheckEqualContainers(cntdeque, stddeque)) return 1; if(!test::CheckEqualContainers(cntdeque, stddeque)) return 1;
} }
#if __cplusplus >= 201703L #ifndef BOOST_CONTAINER_NO_CXX17_CTAD
//Check Constructor Template Auto Deduction //Check Constructor Template Auto Deduction
{ {
auto gold = MyStdDeque{ 1, 2, 3 }; auto gold = MyStdDeque{ 1, 2, 3 };

106
test/flat_map_test.cpp
View File

@@ -178,28 +178,98 @@ bool flat_tree_ordered_insertion_test()
bool constructor_template_auto_deduction_test() bool constructor_template_auto_deduction_test()
{ {
#if __cplusplus >= 201703L
#ifndef BOOST_CONTAINER_NO_CXX17_CTAD
using namespace boost::container; using namespace boost::container;
const std::size_t NumElements = 100; const std::size_t NumElements = 100;
//Ordered insertion map
{ {
std::map<int, int> int_map; std::map<int, int> int_map;
for(std::size_t i = 0; i != NumElements; ++i){ for(std::size_t i = 0; i != NumElements; ++i){
int_map.insert(std::map<int, int>::value_type(static_cast<int>(i), static_cast<int>(i))); int_map.insert(std::map<int, int>::value_type(static_cast<int>(i), static_cast<int>(i)));
} }
//Construction insertion
auto fmap = flat_map(ordered_unique_range, int_map.begin(), int_map.end());
if(!CheckEqualContainers(int_map, fmap))
return false;
std::multimap<int, int> int_mmap; std::multimap<int, int> int_mmap;
for(std::size_t i = 0; i != NumElements; ++i){ for (std::size_t i = 0; i != NumElements; ++i) {
int_mmap.insert(std::multimap<int, int>::value_type(static_cast<int>(i), static_cast<int>(i))); int_mmap.insert(std::multimap<int, int>::value_type(static_cast<int>(i), static_cast<int>(i)));
} }
//Construction insertion
auto fmmap = flat_multimap(ordered_range, int_mmap.begin(), int_mmap.end()); typedef std::less<int> comp_int_t;
if(!CheckEqualContainers(int_mmap, fmmap)) typedef std::allocator<std::pair<int, int> > alloc_pair_int_t;
return false;
//range
{
auto fmap = flat_map(int_map.begin(), int_map.end());
if (!CheckEqualContainers(int_map, fmap))
return false;
auto fmmap = flat_multimap(int_mmap.begin(), int_mmap.end());
if (!CheckEqualContainers(int_mmap, fmmap))
return false;
}
//range+comp
{
auto fmap = flat_map(int_map.begin(), int_map.end(), comp_int_t());
if (!CheckEqualContainers(int_map, fmap))
return false;
auto fmmap = flat_multimap(int_mmap.begin(), int_mmap.end(), comp_int_t());
if (!CheckEqualContainers(int_mmap, fmmap))
return false;
}
//range+comp+alloc
{
auto fmap = flat_map(int_map.begin(), int_map.end(), comp_int_t(), alloc_pair_int_t());
if (!CheckEqualContainers(int_map, fmap))
return false;
auto fmmap = flat_multimap(int_mmap.begin(), int_mmap.end(), comp_int_t(), alloc_pair_int_t());
if (!CheckEqualContainers(int_mmap, fmmap))
return false;
}
//range+alloc
{
auto fmap = flat_map(int_map.begin(), int_map.end(), alloc_pair_int_t());
if (!CheckEqualContainers(int_map, fmap))
return false;
auto fmmap = flat_multimap(int_mmap.begin(), int_mmap.end(), alloc_pair_int_t());
if (!CheckEqualContainers(int_mmap, fmmap))
return false;
}
//ordered_unique_range / ordered_range
//range
{
auto fmap = flat_map(ordered_unique_range, int_map.begin(), int_map.end());
if(!CheckEqualContainers(int_map, fmap))
return false;
auto fmmap = flat_multimap(ordered_range, int_mmap.begin(), int_mmap.end());
if(!CheckEqualContainers(int_mmap, fmmap))
return false;
}
//range+comp
{
auto fmap = flat_map(ordered_unique_range, int_map.begin(), int_map.end(), comp_int_t());
if (!CheckEqualContainers(int_map, fmap))
return false;
auto fmmap = flat_multimap(ordered_range, int_mmap.begin(), int_mmap.end(), comp_int_t());
if (!CheckEqualContainers(int_mmap, fmmap))
return false;
}
//range+comp+alloc
{
auto fmap = flat_map(ordered_unique_range, int_map.begin(), int_map.end(), comp_int_t(), alloc_pair_int_t());
if (!CheckEqualContainers(int_map, fmap))
return false;
auto fmmap = flat_multimap(ordered_range, int_mmap.begin(), int_mmap.end(), comp_int_t(), alloc_pair_int_t());
if (!CheckEqualContainers(int_mmap, fmmap))
return false;
}
//range+alloc
{
auto fmap = flat_map(ordered_unique_range, int_map.begin(), int_map.end(),alloc_pair_int_t());
if (!CheckEqualContainers(int_map, fmap))
return false;
auto fmmap = flat_multimap(ordered_range, int_mmap.begin(), int_mmap.end(),alloc_pair_int_t());
if (!CheckEqualContainers(int_mmap, fmmap))
return false;
}
} }
#endif #endif
@@ -476,7 +546,7 @@ bool test_heterogeneous_lookups()
int main() int main()
{ {
using namespace boost::container::test; using namespace boost::container::test;
/*
//Allocator argument container //Allocator argument container
{ {
flat_map<int, int> map_((flat_map<int, int>::allocator_type())); flat_map<int, int> map_((flat_map<int, int>::allocator_type()));
@@ -530,7 +600,7 @@ int main()
if (!test_heterogeneous_lookups()) if (!test_heterogeneous_lookups())
return 1; return 1;
*/
//////////////////////////////////// ////////////////////////////////////
// Testing allocator implementations // Testing allocator implementations
//////////////////////////////////// ////////////////////////////////////
@@ -546,7 +616,7 @@ int main()
std::cout << "Error in map_test<std::allocator<void> >" << std::endl; std::cout << "Error in map_test<std::allocator<void> >" << std::endl;
return 1; return 1;
} }
/*
if (0 != test::map_test if (0 != test::map_test
< GetMapContainer<new_allocator<void> >::apply<int>::map_type < GetMapContainer<new_allocator<void> >::apply<int>::map_type
, MyStdMap , MyStdMap
@@ -581,9 +651,9 @@ int main()
, MyStdMultiMap>()) { , MyStdMultiMap>()) {
std::cout << "Error in map_test<new_allocator<void> >" << std::endl; std::cout << "Error in map_test<new_allocator<void> >" << std::endl;
return 1; return 1;
}*/ }
} }
/*
if(!boost::container::test::test_map_support_for_initialization_list_for<flat_map<int, int> >()) if(!boost::container::test::test_map_support_for_initialization_list_for<flat_map<int, int> >())
return 1; return 1;
@@ -628,7 +698,7 @@ int main()
return 1; return 1;
} }
} }
*/
return 0; return 0;
} }

131
test/flat_set_test.cpp
View File

@@ -276,6 +276,106 @@ bool flat_tree_ordered_insertion_test()
return true; return true;
} }
bool constructor_template_auto_deduction_test()
{
#ifndef BOOST_CONTAINER_NO_CXX17_CTAD
using namespace boost::container;
const std::size_t NumElements = 100;
{
std::set<int> int_set;
for (std::size_t i = 0; i != NumElements; ++i) {
int_set.insert(static_cast<int>(i));
}
std::multiset<int> int_mset;
for (std::size_t i = 0; i != NumElements; ++i) {
int_mset.insert(static_cast<int>(i));
}
typedef std::less<int> comp_int_t;
typedef std::allocator<int> alloc_int_t;
//range
{
auto fset = flat_set(int_set.begin(), int_set.end());
if (!CheckEqualContainers(int_set, fset))
return false;
auto fmset = flat_multiset(int_mset.begin(), int_mset.end());
if (!CheckEqualContainers(int_mset, fmset))
return false;
}
//range+comp
{
auto fset = flat_set(int_set.begin(), int_set.end(), comp_int_t());
if (!CheckEqualContainers(int_set, fset))
return false;
auto fmset = flat_multiset(int_mset.begin(), int_mset.end(), comp_int_t());
if (!CheckEqualContainers(int_mset, fmset))
return false;
}
//range+comp+alloc
{
auto fset = flat_set(int_set.begin(), int_set.end(), comp_int_t(), alloc_int_t());
if (!CheckEqualContainers(int_set, fset))
return false;
auto fmset = flat_multiset(int_mset.begin(), int_mset.end(), comp_int_t(), alloc_int_t());
if (!CheckEqualContainers(int_mset, fmset))
return false;
}
//range+alloc
{
auto fset = flat_set(int_set.begin(), int_set.end(), alloc_int_t());
if (!CheckEqualContainers(int_set, fset))
return false;
auto fmset = flat_multiset(int_mset.begin(), int_mset.end(), alloc_int_t());
if (!CheckEqualContainers(int_mset, fmset))
return false;
}
//ordered_unique_range / ordered_range
//range
{
auto fset = flat_set(ordered_unique_range, int_set.begin(), int_set.end());
if (!CheckEqualContainers(int_set, fset))
return false;
auto fmset = flat_multiset(ordered_range, int_mset.begin(), int_mset.end());
if (!CheckEqualContainers(int_mset, fmset))
return false;
}
//range+comp
{
auto fset = flat_set(ordered_unique_range, int_set.begin(), int_set.end(), comp_int_t());
if (!CheckEqualContainers(int_set, fset))
return false;
auto fmset = flat_multiset(ordered_range, int_mset.begin(), int_mset.end(), comp_int_t());
if (!CheckEqualContainers(int_mset, fmset))
return false;
}
//range+comp+alloc
{
auto fset = flat_set(ordered_unique_range, int_set.begin(), int_set.end(), comp_int_t(), alloc_int_t());
if (!CheckEqualContainers(int_set, fset))
return false;
auto fmset = flat_multiset(ordered_range, int_mset.begin(), int_mset.end(), comp_int_t(), alloc_int_t());
if (!CheckEqualContainers(int_mset, fmset))
return false;
}
//range+alloc
{
auto fset = flat_set(ordered_unique_range, int_set.begin(), int_set.end(), alloc_int_t());
if (!CheckEqualContainers(int_set, fset))
return false;
auto fmset = flat_multiset(ordered_range, int_mset.begin(), int_mset.end(), alloc_int_t());
if (!CheckEqualContainers(int_mset, fmset))
return false;
}
}
#endif
return true;
}
template< class RandomIt > template< class RandomIt >
void random_shuffle( RandomIt first, RandomIt last ) void random_shuffle( RandomIt first, RandomIt last )
{ {
@@ -594,6 +694,13 @@ int main()
return 1; return 1;
} }
////////////////////////////////////
// Constructor Template Auto Deduction test
////////////////////////////////////
if (!constructor_template_auto_deduction_test()) {
return 1;
}
//////////////////////////////////// ////////////////////////////////////
// Extract/Adopt test // Extract/Adopt test
//////////////////////////////////// ////////////////////////////////////
@@ -706,30 +813,6 @@ int main()
} }
} }
#if __cplusplus >= 201703L
////////////////////////////////////
// Constructor Template Auto Deduction
////////////////////////////////////
{
auto gold = std::set({ 1, 2, 3 });
auto test = boost::container::flat_set(gold.begin(), gold.end());
if (test.size() != 3)
return 1;
test = boost::container::flat_set(ordered_unique_range, gold.begin(), gold.end());
if (test.size() != 3)
return 1;
}
{
auto gold = std::multiset({ 1, 2, 3 });
auto test = boost::container::flat_multiset(gold.begin(), gold.end());
if (test.size() != 3)
return 1;
test = boost::container::flat_multiset(ordered_range, gold.begin(), gold.end());
if (test.size() != 3)
return 1;
}
#endif
return 0; return 0;
} }

2
test/list_test.cpp
View File

@@ -214,7 +214,7 @@ int main ()
} }
} }
#if __cplusplus >= 201703L #ifndef BOOST_CONTAINER_NO_CXX17_CTAD
//////////////////////////////////// ////////////////////////////////////
// Constructor Template Auto Deduction Tests // Constructor Template Auto Deduction Tests
//////////////////////////////////// ////////////////////////////////////

125
test/map_test.cpp
View File

@@ -337,6 +337,106 @@ bool test_heterogeneous_lookups()
return true; return true;
} }
bool constructor_template_auto_deduction_test()
{
#ifndef BOOST_CONTAINER_NO_CXX17_CTAD
using namespace boost::container;
const std::size_t NumElements = 100;
{
std::map<int, int> int_map;
for(std::size_t i = 0; i != NumElements; ++i){
int_map.insert(std::map<int, int>::value_type(static_cast<int>(i), static_cast<int>(i)));
}
std::multimap<int, int> int_mmap;
for (std::size_t i = 0; i != NumElements; ++i) {
int_mmap.insert(std::multimap<int, int>::value_type(static_cast<int>(i), static_cast<int>(i)));
}
typedef std::less<int> comp_int_t;
typedef std::allocator<std::pair<const int, int> > alloc_pair_int_t;
//range
{
auto fmap = map(int_map.begin(), int_map.end());
if (!CheckEqualContainers(int_map, fmap))
return false;
auto fmmap = multimap(int_mmap.begin(), int_mmap.end());
if (!CheckEqualContainers(int_mmap, fmmap))
return false;
}
//range+comp
{
auto fmap = map(int_map.begin(), int_map.end(), comp_int_t());
if (!CheckEqualContainers(int_map, fmap))
return false;
auto fmmap = multimap(int_mmap.begin(), int_mmap.end(), comp_int_t());
if (!CheckEqualContainers(int_mmap, fmmap))
return false;
}
//range+comp+alloc
{
auto fmap = map(int_map.begin(), int_map.end(), comp_int_t(), alloc_pair_int_t());
if (!CheckEqualContainers(int_map, fmap))
return false;
auto fmmap = multimap(int_mmap.begin(), int_mmap.end(), comp_int_t(), alloc_pair_int_t());
if (!CheckEqualContainers(int_mmap, fmmap))
return false;
}
//range+alloc
{
auto fmap = map(int_map.begin(), int_map.end(), alloc_pair_int_t());
if (!CheckEqualContainers(int_map, fmap))
return false;
auto fmmap = multimap(int_mmap.begin(), int_mmap.end(), alloc_pair_int_t());
if (!CheckEqualContainers(int_mmap, fmmap))
return false;
}
//ordered_unique_range / ordered_range
//range
{
auto fmap = map(ordered_unique_range, int_map.begin(), int_map.end());
if(!CheckEqualContainers(int_map, fmap))
return false;
auto fmmap = multimap(ordered_range, int_mmap.begin(), int_mmap.end());
if(!CheckEqualContainers(int_mmap, fmmap))
return false;
}
//range+comp
{
auto fmap = map(ordered_unique_range, int_map.begin(), int_map.end(), comp_int_t());
if (!CheckEqualContainers(int_map, fmap))
return false;
auto fmmap = multimap(ordered_range, int_mmap.begin(), int_mmap.end(), comp_int_t());
if (!CheckEqualContainers(int_mmap, fmmap))
return false;
}
//range+comp+alloc
{
auto fmap = map(ordered_unique_range, int_map.begin(), int_map.end(), comp_int_t(), alloc_pair_int_t());
if (!CheckEqualContainers(int_map, fmap))
return false;
auto fmmap = multimap(ordered_range, int_mmap.begin(), int_mmap.end(), comp_int_t(), alloc_pair_int_t());
if (!CheckEqualContainers(int_mmap, fmmap))
return false;
}
//range+alloc
{
auto fmap = map(ordered_unique_range, int_map.begin(), int_map.end(),alloc_pair_int_t());
if (!CheckEqualContainers(int_map, fmap))
return false;
auto fmmap = multimap(ordered_range, int_mmap.begin(), int_mmap.end(),alloc_pair_int_t());
if (!CheckEqualContainers(int_mmap, fmmap))
return false;
}
}
#endif
return true;
}
}}} //namespace boost::container::test }}} //namespace boost::container::test
int main () int main ()
@@ -474,30 +574,19 @@ int main ()
} }
} }
#if __cplusplus >= 201703L
////////////////////////////////////
// Constructor Template Auto Deduction
////////////////////////////////////
{
auto gold = std::map<int, int>({ {1,1}, {2,2}, {3,3} } );
auto test = boost::container::map(gold.begin(), gold.end());
if (test.size() != 3)
return 1;
}
{
auto gold = std::multimap<int, int>({ {1,1}, {2,2}, {3,3} } );
auto test = boost::container::multimap(gold.begin(), gold.end());
if (test.size() != 3)
return 1;
}
#endif
//////////////////////////////////// ////////////////////////////////////
// Node extraction/insertion testing functions // Node extraction/insertion testing functions
//////////////////////////////////// ////////////////////////////////////
if(!node_type_test()) if(!node_type_test())
return 1; return 1;
////////////////////////////////////
// Constructor Template Auto Deduction test
////////////////////////////////////
if (!test::constructor_template_auto_deduction_test()) {
return 1;
}
if (!boost::container::test::instantiate_constructors<map<int, int>, multimap<int, int> >()) if (!boost::container::test::instantiate_constructors<map<int, int>, multimap<int, int> >())
return 1; return 1;

107
test/set_test.cpp
View File

@@ -206,6 +206,104 @@ struct alloc_propagate_base<boost_container_multiset>
}; };
}; };
bool constructor_template_auto_deduction_test()
{
#ifndef BOOST_CONTAINER_NO_CXX17_CTAD
using namespace boost::container;
const std::size_t NumElements = 100;
{
std::set<int> int_set;
for (std::size_t i = 0; i != NumElements; ++i) {
int_set.insert(static_cast<int>(i));
}
std::multiset<int> int_mset;
for (std::size_t i = 0; i != NumElements; ++i) {
int_mset.insert(static_cast<int>(i));
}
typedef std::less<int> comp_int_t;
typedef std::allocator<int> alloc_int_t;
//range
{
auto fset = set(int_set.begin(), int_set.end());
if (!CheckEqualContainers(int_set, fset))
return false;
auto fmset = multiset(int_mset.begin(), int_mset.end());
if (!CheckEqualContainers(int_mset, fmset))
return false;
}
//range+comp
{
auto fset = set(int_set.begin(), int_set.end(), comp_int_t());
if (!CheckEqualContainers(int_set, fset))
return false;
auto fmset = multiset(int_mset.begin(), int_mset.end(), comp_int_t());
if (!CheckEqualContainers(int_mset, fmset))
return false;
}
//range+comp+alloc
{
auto fset = set(int_set.begin(), int_set.end(), comp_int_t(), alloc_int_t());
if (!CheckEqualContainers(int_set, fset))
return false;
auto fmset = multiset(int_mset.begin(), int_mset.end(), comp_int_t(), alloc_int_t());
if (!CheckEqualContainers(int_mset, fmset))
return false;
}
//range+alloc
{
auto fset = set(int_set.begin(), int_set.end(), alloc_int_t());
if (!CheckEqualContainers(int_set, fset))
return false;
auto fmset = multiset(int_mset.begin(), int_mset.end(), alloc_int_t());
if (!CheckEqualContainers(int_mset, fmset))
return false;
}
//ordered_unique_range / ordered_range
//range
{
auto fset = set(ordered_unique_range, int_set.begin(), int_set.end());
if (!CheckEqualContainers(int_set, fset))
return false;
auto fmset = multiset(ordered_range, int_mset.begin(), int_mset.end());
if (!CheckEqualContainers(int_mset, fmset))
return false;
}
//range+comp
{
auto fset = set(ordered_unique_range, int_set.begin(), int_set.end(), comp_int_t());
if (!CheckEqualContainers(int_set, fset))
return false;
auto fmset = multiset(ordered_range, int_mset.begin(), int_mset.end(), comp_int_t());
if (!CheckEqualContainers(int_mset, fmset))
return false;
}
//range+comp+alloc
{
auto fset = set(ordered_unique_range, int_set.begin(), int_set.end(), comp_int_t(), alloc_int_t());
if (!CheckEqualContainers(int_set, fset))
return false;
auto fmset = multiset(ordered_range, int_mset.begin(), int_mset.end(), comp_int_t(), alloc_int_t());
if (!CheckEqualContainers(int_mset, fmset))
return false;
}
//range+alloc
{
auto fset = set(ordered_unique_range, int_set.begin(), int_set.end(), alloc_int_t());
if (!CheckEqualContainers(int_set, fset))
return false;
auto fmset = multiset(ordered_range, int_mset.begin(), int_mset.end(), alloc_int_t());
if (!CheckEqualContainers(int_mset, fmset))
return false;
}
}
#endif
return true;
}
}}} //boost::container::test }}} //boost::container::test
template<class VoidAllocator, boost::container::tree_type_enum tree_type_value> template<class VoidAllocator, boost::container::tree_type_enum tree_type_value>
@@ -360,6 +458,13 @@ int main ()
test_merge_from_different_comparison(); test_merge_from_different_comparison();
////////////////////////////////////
// Constructor Template Auto Deduction test
////////////////////////////////////
if (!test::constructor_template_auto_deduction_test()) {
return 1;
}
if(!test_heterogeneous_lookups()) if(!test_heterogeneous_lookups())
return 1; return 1;
@@ -500,7 +605,7 @@ int main ()
if(!node_type_test()) if(!node_type_test())
return 1; return 1;
#if __cplusplus >= 201703L #ifndef BOOST_CONTAINER_NO_CXX17_CTAD
//////////////////////////////////// ////////////////////////////////////
// Constructor Template Auto Deduction // Constructor Template Auto Deduction
//////////////////////////////////// ////////////////////////////////////

2
test/slist_test.cpp
View File

@@ -217,7 +217,7 @@ int main ()
return 1; return 1;
} }
} }
#if __cplusplus >= 201703L #ifndef BOOST_CONTAINER_NO_CXX17_CTAD
//////////////////////////////////// ////////////////////////////////////
// Constructor Template Auto Deduction Tests // Constructor Template Auto Deduction Tests
//////////////////////////////////// ////////////////////////////////////

2
test/stable_vector_test.cpp
View File

@@ -177,7 +177,7 @@ int main()
} }
} }
#if __cplusplus >= 201703L #ifndef BOOST_CONTAINER_NO_CXX17_CTAD
//////////////////////////////////// ////////////////////////////////////
// Constructor Template Auto Deduction testing // Constructor Template Auto Deduction testing
//////////////////////////////////// ////////////////////////////////////

2
test/string_test.cpp
View File

@@ -456,7 +456,7 @@ int string_test()
return 1; return 1;
} }
#if __cplusplus >= 201703L #ifndef BOOST_CONTAINER_NO_CXX17_CTAD
//Chect Constructor Template Auto Deduction //Chect Constructor Template Auto Deduction
{ {
auto gold = StdString(string_literals<CharType>::String()); auto gold = StdString(string_literals<CharType>::String());

10
test/vector_test.cpp
View File

@@ -61,15 +61,15 @@ struct X;
template<typename T> template<typename T>
struct XRef struct XRef
{ {
explicit XRef(T* ptr) noexcept : ptr(ptr) {} explicit XRef(T* ptr) : ptr(ptr) {}
operator T*() const noexcept { return ptr; } operator T*() const { return ptr; }
T* ptr; T* ptr;
}; };
struct X struct X
{ {
XRef<X const> operator&() const noexcept { return XRef<X const>(this); } XRef<X const> operator&() const { return XRef<X const>(this); }
XRef<X> operator&() noexcept { return XRef<X>(this); } XRef<X> operator&() { return XRef<X>(this); }
}; };
@@ -260,7 +260,7 @@ int main()
} }
} }
#if __cplusplus >= 201703L #ifndef BOOST_CONTAINER_NO_CXX17_CTAD
//////////////////////////////////// ////////////////////////////////////
// Constructor Template Auto Deduction testing // Constructor Template Auto Deduction testing
//////////////////////////////////// ////////////////////////////////////