* doc/xml/manual/intro.xml: Document LWG 2108 status.
* include/bits/alloc_traits.h (allocator_traits::is_always_equal):
Define.
* include/bits/allocator.h (allocator::is_always_equal): Likewise.
* include/bits/forward_list.h
(forward_list::operator=(forward_list&&)): Use __bool_constant.
(forward_list::swap(forward_list&)): Add noexcept.
* include/bits/hashtable.h (_Hashtable::operator=(_Hashtable&&)):
Likewise.
(_Hashtable::swap(_Hashtable&)): Likewise.
* include/bits/stl_deque.h (_Deque_base::_Deque_base(_Deque_base&&)):
Use _Alloc_traits::is_always_equal.
(deque::operator=(deque&&)): Likewise.
(deque::_M_move_assign1(deque&&, false_type)): Add comment and use
__bool_constant.
(swap(deque&, deque&)): Add noexcept.
* include/bits/stl_list.h (list::operator=(list&&)): Use
__bool_constant.
(swap(list&, list&)): Add noexcept.
* include/bits/stl_map.h (map::swap(map&)): Include _Compare in
noexcept.
(swap(map&, map&)): Add noexcept.
* include/bits/stl_multimap.h (multimap::swap(multimap&)): Include
_Compare in noexcept.
(swap(multimap&, multimap&)): Add noexcept.
* include/bits/stl_multiset.h (multiset::swap(multiset&)): Include
_Compare in noexcept.
(swap(multiset&, multiset&)): Add noexcept.
* include/bits/stl_set.h (set::swap(set&)): Include _Compare in
noexcept.
(swap(set&, set&)): Add noexcept.
* include/bits/stl_tree.h (_Rb_tree::operator=(_Rb_tree&&)): Include
_Compare in noexcept.
(_Rb_tree::_Rb_tree(_Rb_tree&&, _Node_alloc_type&&)): Use
is_always_equal.
* include/bits/stl_vector.h (vector::operator=(vector&&)): Use
__bool_constant.
(swap(vector&, vector&)): Add noexcept.
* include/bits/unordered_map.h (swap(unordered_map&, unordered_map&),
swap(unordered_multimap& unordered_multimap&)): Add noexcept.
* include/bits/unordered_set.h (swap(unordered_set&, unordered_set&),
swap(unordered_multiset& unordered_multiset&)): Add noexcept.
* include/ext/alloc_traits.h (__allocator_always_compares_equal):
Remove.
(__alloc_traits::_S_always_equal()): Use is_always_equal instead of
__allocator_always_compares_equal.
* include/ext/array_allocator.h (array_allocator::is_always_equal):
Define.
* include/std/scoped_allocator (__any_of, __propagate_on_copy,
__propagate_on_move, __propagate_on_swap): Remove.
(scoped_allocator_adaptor::propagate_on_container_copy_assignment,
scoped_allocator_adaptor::propagate_on_container_move_assignment,
scoped_allocator_adaptor::propagate_on_container_swap): Define with
__and_ instead of __any_of.
(scoped_allocator_adaptor::is_always_equal): Define.
* testsuite/20_util/allocator_traits/members/is_always_equal.cc: New.
* testsuite/20_util/scoped_allocator/propagation.cc: Make traits
derive from true_type or false_type.
* testsuite/23_containers/deque/allocator/move_assign-2.cc: Add
is_always_equal member and remove the trait specialization.
* testsuite/23_containers/vector/52591.cc: Likewise.
* testsuite/23_containers/deque/requirements/dr438/assign_neg.cc:
Adjust dg-error line number.
* testsuite/23_containers/deque/requirements/dr438/
constructor_1_neg.cc: Likewise.
* testsuite/23_containers/deque/requirements/dr438/
constructor_2_neg.cc: Likewise.
* testsuite/23_containers/deque/requirements/dr438/insert_neg.cc:
Likewise.
* testsuite/23_containers/list/requirements/dr438/assign_neg.cc:
Likewise.
* testsuite/23_containers/list/requirements/dr438/constructor_1_neg.cc:
Likewise.
* testsuite/23_containers/list/requirements/dr438/insert_neg.cc:
Likewise.
* testsuite/23_containers/vector/requirements/dr438/assign_neg.cc:
Likewise.
* testsuite/23_containers/vector/requirements/dr438/
constructor_1_neg.cc: Likewise.
* testsuite/23_containers/vector/requirements/dr438/
constructor_2_neg.cc: Likewise.
* testsuite/23_containers/vector/requirements/dr438/insert_neg.cc:
Likewise.
From-SVN: r225081
2015-06-26 Jonathan Wakely <jwakely@redhat.com>
+ * doc/xml/manual/intro.xml: Document LWG 2108 status.
+ * include/bits/alloc_traits.h (allocator_traits::is_always_equal):
+ Define.
+ * include/bits/allocator.h (allocator::is_always_equal): Likewise.
+ * include/bits/forward_list.h
+ (forward_list::operator=(forward_list&&)): Use __bool_constant.
+ (forward_list::swap(forward_list&)): Add noexcept.
+ * include/bits/hashtable.h (_Hashtable::operator=(_Hashtable&&)):
+ Likewise.
+ (_Hashtable::swap(_Hashtable&)): Likewise.
+ * include/bits/stl_deque.h (_Deque_base::_Deque_base(_Deque_base&&)):
+ Use _Alloc_traits::is_always_equal.
+ (deque::operator=(deque&&)): Likewise.
+ (deque::_M_move_assign1(deque&&, false_type)): Add comment and use
+ __bool_constant.
+ (swap(deque&, deque&)): Add noexcept.
+ * include/bits/stl_list.h (list::operator=(list&&)): Use
+ __bool_constant.
+ (swap(list&, list&)): Add noexcept.
+ * include/bits/stl_map.h (map::swap(map&)): Include _Compare in
+ noexcept.
+ (swap(map&, map&)): Add noexcept.
+ * include/bits/stl_multimap.h (multimap::swap(multimap&)): Include
+ _Compare in noexcept.
+ (swap(multimap&, multimap&)): Add noexcept.
+ * include/bits/stl_multiset.h (multiset::swap(multiset&)): Include
+ _Compare in noexcept.
+ (swap(multiset&, multiset&)): Add noexcept.
+ * include/bits/stl_set.h (set::swap(set&)): Include _Compare in
+ noexcept.
+ (swap(set&, set&)): Add noexcept.
+ * include/bits/stl_tree.h (_Rb_tree::operator=(_Rb_tree&&)): Include
+ _Compare in noexcept.
+ (_Rb_tree::_Rb_tree(_Rb_tree&&, _Node_alloc_type&&)): Use
+ is_always_equal.
+ * include/bits/stl_vector.h (vector::operator=(vector&&)): Use
+ __bool_constant.
+ (swap(vector&, vector&)): Add noexcept.
+ * include/bits/unordered_map.h (swap(unordered_map&, unordered_map&),
+ swap(unordered_multimap& unordered_multimap&)): Add noexcept.
+ * include/bits/unordered_set.h (swap(unordered_set&, unordered_set&),
+ swap(unordered_multiset& unordered_multiset&)): Add noexcept.
+ * include/ext/alloc_traits.h (__allocator_always_compares_equal):
+ Remove.
+ (__alloc_traits::_S_always_equal()): Use is_always_equal instead of
+ __allocator_always_compares_equal.
+ * include/ext/array_allocator.h (array_allocator::is_always_equal):
+ Define.
+ * include/std/scoped_allocator (__any_of, __propagate_on_copy,
+ __propagate_on_move, __propagate_on_swap): Remove.
+ (scoped_allocator_adaptor::propagate_on_container_copy_assignment,
+ scoped_allocator_adaptor::propagate_on_container_move_assignment,
+ scoped_allocator_adaptor::propagate_on_container_swap): Define with
+ __and_ instead of __any_of.
+ (scoped_allocator_adaptor::is_always_equal): Define.
+ * testsuite/20_util/allocator_traits/members/is_always_equal.cc: New.
+ * testsuite/20_util/scoped_allocator/propagation.cc: Make traits
+ derive from true_type or false_type.
+ * testsuite/23_containers/deque/allocator/move_assign-2.cc: Add
+ is_always_equal member and remove the trait specialization.
+ * testsuite/23_containers/vector/52591.cc: Likewise.
+ * testsuite/23_containers/deque/requirements/dr438/assign_neg.cc:
+ Adjust dg-error line number.
+ * testsuite/23_containers/deque/requirements/dr438/
+ constructor_1_neg.cc: Likewise.
+ * testsuite/23_containers/deque/requirements/dr438/
+ constructor_2_neg.cc: Likewise.
+ * testsuite/23_containers/deque/requirements/dr438/insert_neg.cc:
+ Likewise.
+ * testsuite/23_containers/list/requirements/dr438/assign_neg.cc:
+ Likewise.
+ * testsuite/23_containers/list/requirements/dr438/constructor_1_neg.cc:
+ Likewise.
+ * testsuite/23_containers/list/requirements/dr438/insert_neg.cc:
+ Likewise.
+ * testsuite/23_containers/vector/requirements/dr438/assign_neg.cc:
+ Likewise.
+ * testsuite/23_containers/vector/requirements/dr438/
+ constructor_1_neg.cc: Likewise.
+ * testsuite/23_containers/vector/requirements/dr438/
+ constructor_2_neg.cc: Likewise.
+ * testsuite/23_containers/vector/requirements/dr438/insert_neg.cc:
+ Likewise.
+
* include/bits/stl_bvector.h (vector<bool>::vector()): Add noexcept.
* include/bits/stl_map.h (map::map()): Likewise.
* include/bits/stl_multimap.h (multimap::multimap()): Likewise.
<listitem><para>Change the <code>reference</code> type.
</para></listitem></varlistentry>
+ <varlistentry><term><link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="../ext/lwg-defects.html#2108">2108</link>:
+ <emphasis>No way to identify allocator types that always compare equal</emphasis>
+ </term>
+ <listitem><para>Define and use <code>is_always_equal</code> even for C++11.
+ </para></listitem></varlistentry>
+
<varlistentry><term><link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="../ext/lwg-defects.html#2118">2118</link>:
<emphasis><code>unique_ptr</code> for array does not support cv qualification conversion of actual argument</emphasis>
</term>
#define _GLIBCXX_ALLOC_TR_NESTED_TYPE(_NTYPE, _ALT) \
private: \
- template<typename _Tp> \
- static typename _Tp::_NTYPE _S_##_NTYPE##_helper(_Tp*); \
- static _ALT _S_##_NTYPE##_helper(...); \
+ template<typename _Tp> \
+ static typename _Tp::_NTYPE _S_##_NTYPE##_helper(_Tp*); \
+ static _ALT _S_##_NTYPE##_helper(...); \
typedef decltype(_S_##_NTYPE##_helper((_Alloc*)0)) __##_NTYPE; \
public:
*/
typedef __propagate_on_container_swap propagate_on_container_swap;
+_GLIBCXX_ALLOC_TR_NESTED_TYPE(is_always_equal,
+ typename is_empty<_Alloc>::type)
+
+ /**
+ * @brief Whether all instances of the allocator type compare equal.
+ *
+ * @c Alloc::is_always_equal if that type exists,
+ * otherwise @c is_empty<Alloc>::type
+ */
+ typedef __is_always_equal is_always_equal;
+
#undef _GLIBCXX_ALLOC_TR_NESTED_TYPE
template<typename _Tp>
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 2103. std::allocator propagate_on_container_move_assignment
typedef true_type propagate_on_container_move_assignment;
+
+ typedef true_type is_always_equal;
#endif
};
constexpr bool __move_storage =
_Node_alloc_traits::_S_propagate_on_move_assign()
|| _Node_alloc_traits::_S_always_equal();
- _M_move_assign(std::move(__list),
- integral_constant<bool, __move_storage>());
+ _M_move_assign(std::move(__list), __bool_constant<__move_storage>());
return *this;
}
inline void
swap(forward_list<_Tp, _Alloc>& __lx,
forward_list<_Tp, _Alloc>& __ly)
+ noexcept(noexcept(__lx.swap(__ly)))
{ __lx.swap(__ly); }
_GLIBCXX_END_NAMESPACE_CONTAINER
_Hashtable&
operator=(_Hashtable&& __ht)
- noexcept(__node_alloc_traits::_S_nothrow_move())
+ noexcept(__node_alloc_traits::_S_nothrow_move()
+ && is_nothrow_move_assignable<_H1>::value
+ && is_nothrow_move_assignable<_Equal>::value)
{
constexpr bool __move_storage =
- __node_alloc_traits::_S_propagate_on_move_assign()
- || __node_alloc_traits::_S_always_equal();
- _M_move_assign(std::move(__ht),
- integral_constant<bool, __move_storage>());
+ __node_alloc_traits::_S_propagate_on_move_assign()
+ || __node_alloc_traits::_S_always_equal();
+ _M_move_assign(std::move(__ht), __bool_constant<__move_storage>());
return *this;
}
void
swap(_Hashtable&)
- noexcept(__node_alloc_traits::_S_nothrow_swap());
+ noexcept(__node_alloc_traits::_S_nothrow_swap()
+ && __is_nothrow_swappable<_H1>::value
+ && __is_nothrow_swappable<_Equal>::value);
// Basic container operations
iterator
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
_H1, _H2, _Hash, _RehashPolicy, _Traits>::
swap(_Hashtable& __x)
- noexcept(__node_alloc_traits::_S_nothrow_swap())
+ noexcept(__node_alloc_traits::_S_nothrow_swap()
+ && __is_nothrow_swappable<_H1>::value
+ && __is_nothrow_swappable<_Equal>::value)
{
// The only base class with member variables is hash_code_base.
// We define _Hash_code_base::_M_swap because different
}
_Deque_base(_Deque_base&& __x)
- : _Deque_base(std::move(__x),
- __gnu_cxx::__allocator_always_compares_equal<_Alloc>{})
+ : _Deque_base(std::move(__x), typename _Alloc_traits::is_always_equal{})
{ }
_Deque_base(_Deque_base&& __x, const allocator_type& __a, size_type __n)
deque&
operator=(deque&& __x) noexcept(_Alloc_traits::_S_always_equal())
{
- constexpr bool __always_equal = _Alloc_traits::_S_always_equal();
- _M_move_assign1(std::move(__x),
- integral_constant<bool, __always_equal>());
+ using __always_equal = typename _Alloc_traits::is_always_equal;
+ _M_move_assign1(std::move(__x), __always_equal{});
return *this;
}
std::__alloc_on_move(_M_get_Tp_allocator(), __x._M_get_Tp_allocator());
}
+ // When the allocators are not equal the operation could throw, because
+ // we might need to allocate a new map for __x after moving from it
+ // or we might need to allocate new elements for *this.
void
_M_move_assign1(deque&& __x, /* always equal: */ false_type)
{
constexpr bool __move_storage =
_Alloc_traits::_S_propagate_on_move_assign();
- _M_move_assign2(std::move(__x),
- integral_constant<bool, __move_storage>());
+ _M_move_assign2(std::move(__x), __bool_constant<__move_storage>());
}
// Destroy all elements and deallocate all memory, then replace
template<typename _Tp, typename _Alloc>
inline void
swap(deque<_Tp,_Alloc>& __x, deque<_Tp,_Alloc>& __y)
+#if __cplusplus >= 201103L
+ noexcept(noexcept(__x.swap(__y)))
+#endif
{ __x.swap(__y); }
#undef _GLIBCXX_DEQUE_BUF_SIZE
constexpr bool __move_storage =
_Node_alloc_traits::_S_propagate_on_move_assign()
|| _Node_alloc_traits::_S_always_equal();
- _M_move_assign(std::move(__x),
- integral_constant<bool, __move_storage>());
+ _M_move_assign(std::move(__x), __bool_constant<__move_storage>());
return *this;
}
template<typename _Tp, typename _Alloc>
inline void
swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y)
+#if __cplusplus >= 201103L
+ noexcept(noexcept(__x.swap(__y)))
+#endif
{ __x.swap(__y); }
_GLIBCXX_END_NAMESPACE_CONTAINER
void
swap(map& __x)
#if __cplusplus >= 201103L
- noexcept(_Alloc_traits::_S_nothrow_swap())
+ noexcept(_Alloc_traits::_S_nothrow_swap()
+ && __is_nothrow_swappable<_Compare>::value)
#endif
{ _M_t.swap(__x._M_t); }
inline void
swap(map<_Key, _Tp, _Compare, _Alloc>& __x,
map<_Key, _Tp, _Compare, _Alloc>& __y)
+#if __cplusplus >= 201103L
+ noexcept(noexcept(__x.swap(__y)))
+#endif
{ __x.swap(__y); }
_GLIBCXX_END_NAMESPACE_CONTAINER
void
swap(multimap& __x)
#if __cplusplus >= 201103L
- noexcept(_Alloc_traits::_S_nothrow_swap())
+ noexcept(_Alloc_traits::_S_nothrow_swap()
+ && __is_nothrow_swappable<_Compare>::value)
#endif
{ _M_t.swap(__x._M_t); }
inline void
swap(multimap<_Key, _Tp, _Compare, _Alloc>& __x,
multimap<_Key, _Tp, _Compare, _Alloc>& __y)
+#if __cplusplus >= 201103L
+ noexcept(noexcept(__x.swap(__y)))
+#endif
{ __x.swap(__y); }
_GLIBCXX_END_NAMESPACE_CONTAINER
void
swap(multiset& __x)
#if __cplusplus >= 201103L
- noexcept(_Alloc_traits::_S_nothrow_swap())
+ noexcept(_Alloc_traits::_S_nothrow_swap()
+ && __is_nothrow_swappable<_Compare>::value)
#endif
{ _M_t.swap(__x._M_t); }
inline void
swap(multiset<_Key, _Compare, _Alloc>& __x,
multiset<_Key, _Compare, _Alloc>& __y)
+#if __cplusplus >= 201103L
+ noexcept(noexcept(__x.swap(__y)))
+#endif
{ __x.swap(__y); }
_GLIBCXX_END_NAMESPACE_CONTAINER
void
swap(set& __x)
#if __cplusplus >= 201103L
- noexcept(_Alloc_traits::_S_nothrow_swap())
+ noexcept(_Alloc_traits::_S_nothrow_swap()
+ && __is_nothrow_swappable<_Compare>::value)
#endif
{ _M_t.swap(__x._M_t); }
template<typename _Key, typename _Compare, typename _Alloc>
inline void
swap(set<_Key, _Compare, _Alloc>& __x, set<_Key, _Compare, _Alloc>& __y)
+#if __cplusplus >= 201103L
+ noexcept(noexcept(__x.swap(__y)))
+#endif
{ __x.swap(__y); }
_GLIBCXX_END_NAMESPACE_CONTAINER
#if __cplusplus >= 201103L
_Rb_tree&
- operator=(_Rb_tree&&) noexcept(_Alloc_traits::_S_nothrow_move());
+ operator=(_Rb_tree&&)
+ noexcept(_Alloc_traits::_S_nothrow_move()
+ && is_nothrow_move_assignable<_Compare>::value);
template<typename _Iterator>
void
_Rb_tree(_Rb_tree&& __x, _Node_allocator&& __a)
: _M_impl(__x._M_impl._M_key_compare, std::move(__a))
{
- using __eq = integral_constant<bool, _Alloc_traits::_S_always_equal()>;
+ using __eq = typename _Alloc_traits::is_always_equal;
if (__x._M_root() != nullptr)
_M_move_data(__x, __eq());
}
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>&
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
operator=(_Rb_tree&& __x)
- noexcept(_Alloc_traits::_S_nothrow_move())
+ noexcept(_Alloc_traits::_S_nothrow_move()
+ && is_nothrow_move_assignable<_Compare>::value)
{
_M_impl._M_key_compare = __x._M_impl._M_key_compare;
if (_Alloc_traits::_S_propagate_on_move_assign()
constexpr bool __move_storage =
_Alloc_traits::_S_propagate_on_move_assign()
|| _Alloc_traits::_S_always_equal();
- _M_move_assign(std::move(__x),
- integral_constant<bool, __move_storage>());
+ _M_move_assign(std::move(__x), __bool_constant<__move_storage>());
return *this;
}
template<typename _Tp, typename _Alloc>
inline void
swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y)
+#if __cplusplus >= 201103L
+ noexcept(noexcept(__x.swap(__y)))
+#endif
{ __x.swap(__y); }
_GLIBCXX_END_NAMESPACE_CONTAINER
inline void
swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+ noexcept(noexcept(__x.swap(__y)))
{ __x.swap(__y); }
template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
inline void
swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+ noexcept(noexcept(__x.swap(__y)))
{ __x.swap(__y); }
template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
inline void
swap(unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
unordered_set<_Value, _Hash, _Pred, _Alloc>& __y)
+ noexcept(noexcept(__x.swap(__y)))
{ __x.swap(__y); }
template<class _Value, class _Hash, class _Pred, class _Alloc>
inline void
swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
+ noexcept(noexcept(__x.swap(__y)))
{ __x.swap(__y); }
template<class _Value, class _Hash, class _Pred, class _Alloc>
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
-#if __cplusplus >= 201103L
- template<typename _Alloc>
- struct __allocator_always_compares_equal : std::false_type { };
-
- template<typename _Tp>
- struct __allocator_always_compares_equal<std::allocator<_Tp>>
- : std::true_type { };
-
- template<typename, typename> struct array_allocator;
-
- template<typename _Tp, typename _Array>
- struct __allocator_always_compares_equal<array_allocator<_Tp, _Array>>
- : std::true_type { };
-
- template<typename> struct bitmap_allocator;
-
- template<typename _Tp>
- struct __allocator_always_compares_equal<bitmap_allocator<_Tp>>
- : std::true_type { };
-
- template<typename> struct malloc_allocator;
-
- template<typename _Tp>
- struct __allocator_always_compares_equal<malloc_allocator<_Tp>>
- : std::true_type { };
-
- template<typename> struct mt_allocator;
-
- template<typename _Tp>
- struct __allocator_always_compares_equal<mt_allocator<_Tp>>
- : std::true_type { };
-
- template<typename> struct new_allocator;
-
- template<typename _Tp>
- struct __allocator_always_compares_equal<new_allocator<_Tp>>
- : std::true_type { };
-
- template<typename> struct pool_allocator;
-
- template<typename _Tp>
- struct __allocator_always_compares_equal<pool_allocator<_Tp>>
- : std::true_type { };
-#endif
-
/**
- * @brief Uniform interface to C++98 and C++0x allocators.
+ * @brief Uniform interface to C++98 and C++11 allocators.
* @ingroup allocators
*/
template<typename _Alloc>
{ return _Base_type::propagate_on_container_swap::value; }
static constexpr bool _S_always_equal()
- { return __allocator_always_compares_equal<_Alloc>::value; }
+ { return _Base_type::is_always_equal::value; }
static constexpr bool _S_nothrow_move()
{ return _S_propagate_on_move_assign() || _S_always_equal(); }
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 2103. std::allocator propagate_on_container_move_assignment
typedef std::true_type propagate_on_container_move_assignment;
+
+ typedef std::true_type is_always_equal;
#endif
private:
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
- template<template<typename> class _Pred, typename... _Allocs>
- struct __any_of;
-
- template<template<typename> class _Pred, typename _Alloc, typename... _Allocs>
- struct __any_of<_Pred, _Alloc, _Allocs...>
- : __or_<_Pred<_Alloc>, __any_of<_Pred, _Allocs...>>
- { };
-
- template<template<typename> class _Pred, typename _Alloc>
- struct __any_of<_Pred, _Alloc>
- : _Pred<_Alloc>
- { };
-
/**
* @addtogroup allocators
* @{
*/
- template<typename _Alloc>
- struct __propagate_on_copy
- : allocator_traits<_Alloc>::propagate_on_container_copy_assignment
- { };
- template<typename _Alloc>
- struct __propagate_on_move
- : allocator_traits<_Alloc>::propagate_on_container_move_assignment
- { };
- template<typename _Alloc>
- struct __propagate_on_swap
- : allocator_traits<_Alloc>::propagate_on_container_swap
- { };
-
-
template<typename _Alloc>
inline auto
__do_outermost(_Alloc& __a, _Alloc*) -> decltype(__a.outer_allocator())
typedef typename __traits::void_pointer void_pointer;
typedef typename __traits::const_void_pointer const_void_pointer;
- typedef typename conditional<
- __any_of<__propagate_on_copy, _OuterAlloc, _InnerAllocs...>::value,
- true_type, false_type>::type propagate_on_container_copy_assignment;
- typedef typename conditional<
- __any_of<__propagate_on_move, _OuterAlloc, _InnerAllocs...>::value,
- true_type, false_type>::type propagate_on_container_move_assignment;
- typedef typename conditional<
- __any_of<__propagate_on_swap, _OuterAlloc, _InnerAllocs...>::value,
- true_type, false_type>::type propagate_on_container_swap;
+ typedef typename __or_<
+ typename __traits::propagate_on_container_copy_assignment,
+ typename allocator_traits<_InnerAllocs>::
+ propagate_on_container_copy_assignment...>::type
+ propagate_on_container_copy_assignment;
+
+ typedef typename __or_<
+ typename __traits::propagate_on_container_move_assignment,
+ typename allocator_traits<_InnerAllocs>::
+ propagate_on_container_move_assignment...>::type
+ propagate_on_container_move_assignment;
+
+ typedef typename __or_<
+ typename __traits::propagate_on_container_swap,
+ typename allocator_traits<_InnerAllocs>::
+ propagate_on_container_swap...>::type
+ propagate_on_container_swap;
+
+ typedef typename __and_<
+ typename __traits::is_always_equal,
+ typename allocator_traits<_InnerAllocs>::is_always_equal...>::type
+ is_always_equal;
template <class _Tp>
struct rebind
--- /dev/null
+// Copyright (C) 2015 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// { dg-options "-std=gnu++11" }
+// { dg-do compile }
+
+#include <type_traits>
+#include <memory>
+
+template<typename T, typename Base>
+ struct Alloc : Base
+ {
+ typedef T value_type;
+ Alloc();
+ template <typename U>
+ Alloc(const Alloc<U, Base>&);
+ T* allocate(std::size_t);
+ void deallocate(T*, std::size_t);
+ };
+
+template<bool> struct Empty { };
+template<> struct Empty<false> { int x; };
+
+template<bool B>
+ struct WithType
+ { using is_always_equal = std::integral_constant<bool, B>; };
+
+struct EmptyAndTrue : Empty<true>, WithType<true> { };
+struct EmptyButFalse : Empty<true>, WithType<false> { };
+
+struct NotEmptyButTrue : Empty<false>, WithType<true> { };
+struct NotEmptyAndFalse : Empty<false>, WithType<false> { };
+
+template<typename Base>
+ constexpr bool test()
+ {
+ using traits = std::allocator_traits<Alloc<int, Base>>;
+ using test_type = typename traits::is_always_equal;
+ static_assert(std::is_base_of<std::true_type, test_type>::value
+ || std::is_base_of<std::false_type, test_type>::value,
+ "has correct base characteristic");
+ return test_type::value;
+ }
+
+static_assert( test<Empty<true>>(), "empty type is always equal" );
+static_assert( !test<Empty<false>>(), "non-empty type is not always equal" );
+
+static_assert( test<EmptyAndTrue>(), "nested type is used" );
+static_assert( !test<EmptyButFalse>(), "nested type is used" );
+
+static_assert( test<NotEmptyButTrue>(), "nested type is used" );
+static_assert( !test<NotEmptyAndFalse>(), "nested type is used" );
struct test_allocator : minimal_allocator<T>
{
struct propagate_on_container_copy_assignment
- { static const bool value = copy; };
+ : std::integral_constant<bool, copy> { };
struct propagate_on_container_move_assignment
- { static const bool value = move; };
+ : std::integral_constant<bool, move> { };
struct propagate_on_container_swap
- { static const bool value = swap; };
+ : std::integral_constant<bool, swap> { };
};
template<typename A>
template<typename U> A2(const A2<U>&) { }
using propagate_on_container_move_assignment = std::false_type;
-};
-namespace __gnu_cxx
-{
- template<typename T>
- struct __allocator_always_compares_equal<A2<T>> : std::true_type
- { };
-}
+ using is_always_equal = std::true_type;
+};
void test02()
{
// <http://www.gnu.org/licenses/>.
// { dg-do compile }
-// { dg-prune-output 1881 }
+// { dg-prune-output 1879 }
#include <deque>
// <http://www.gnu.org/licenses/>.
// { dg-do compile }
-// { dg-prune-output 1814 }
+// { dg-prune-output 1812 }
#include <deque>
// <http://www.gnu.org/licenses/>.
// { dg-do compile }
-// { dg-prune-output 1814 }
+// { dg-prune-output 1812 }
#include <deque>
#include <utility>
// <http://www.gnu.org/licenses/>.
// { dg-do compile }
-// { dg-prune-output 1965 }
+// { dg-prune-output 1963 }
#include <deque>
// <http://www.gnu.org/licenses/>.
// { dg-do compile }
-// { dg-prune-output 1741 }
+// { dg-prune-output 1740 }
#include <list>
// <http://www.gnu.org/licenses/>.
// { dg-do compile }
-// { dg-prune-output 1693 }
+// { dg-prune-output 1692 }
#include <list>
// <http://www.gnu.org/licenses/>.
// { dg-do compile }
-// { dg-prune-output 1693 }
+// { dg-prune-output 1692 }
#include <list>
template<typename U> A2(const A2<U>&) { }
using propagate_on_container_move_assignment = std::false_type;
+ using is_always_equal = std::true_type;
};
-namespace __gnu_cxx
-{
- template<typename T>
- struct __allocator_always_compares_equal<A2<T>> : std::true_type
- { };
-}
-
void test02()
{
using test_type = std::vector<C, A2<C>>;
// <http://www.gnu.org/licenses/>.
// { dg-do compile }
-// { dg-prune-output 1326 }
+// { dg-prune-output 1325 }
#include <vector>
// <http://www.gnu.org/licenses/>.
// { dg-do compile }
-// { dg-prune-output 1252 }
+// { dg-prune-output 1251 }
#include <vector>
// <http://www.gnu.org/licenses/>.
// { dg-do compile }
-// { dg-prune-output 1252 }
+// { dg-prune-output 1251 }
#include <vector>
#include <utility>
// <http://www.gnu.org/licenses/>.
// { dg-do compile }
-// { dg-prune-output 1367 }
+// { dg-prune-output 1366 }
#include <vector>
projects / gcc.git / commitdiff