* include/ext/alloc_traits.h (__allocator_always_compares_equal): New
trait, provide partial specializations for known allocators.
(__alloc_traits::construct, __alloc_traits::destroy): Overload for
non-standard pointer types.
(__alloc_traits::_S_always_equal): New trait for use with noexcept.
(__alloc_traits::_S_nothrow_move): Likewise.
(__alloc_traits::_S_nothrow_swap): Likewise.
This adds some new traits to __gnu_ext::__alloc_traits which allow
compile-time detection of allocator types that always compare equal,
allowing container operations to be more efficient and marked noexcept
when appropriate.
Tested x86_64-linux, committed to trunk.
Index: include/ext/alloc_traits.h
===================================================================
--- include/ext/alloc_traits.h (revision 176072)
+++ include/ext/alloc_traits.h (working copy)
@@ -37,15 +37,56 @@
# include <bits/allocator.h> // for __alloc_swap
#endif
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+ template<typename> struct allocator;
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
- /**
- * @brief Uniform interface to C++98 and C++0x allocators.
- * @ingroup allocators
- */
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
template<typename _Alloc>
+ struct __allocator_always_compares_equal
+ { static const bool value = false; };
+
+ template<typename _Tp>
+ struct __allocator_always_compares_equal<std::allocator<_Tp>>
+ { static const bool value = true; };
+
+ template<typename, typename> struct array_allocator;
+
+ template<typename _Tp, typename _Array>
+ struct __allocator_always_compares_equal<array_allocator<_Tp, _Array>>
+ { static const bool value = true; };
+
+ template<typename> struct mt_allocator;
+
+ template<typename _Tp>
+ struct __allocator_always_compares_equal<mt_allocator<_Tp>>
+ { static const bool value = true; };
+
+ template<typename> struct new_allocator;
+
+ template<typename _Tp>
+ struct __allocator_always_compares_equal<new_allocator<_Tp>>
+ { static const bool value = true; };
+
+ template<typename> struct pool_allocator;
+
+ template<typename _Tp>
+ struct __allocator_always_compares_equal<pool_allocator<_Tp>>
+ { static const bool value = true; };
+#endif
+
+/**
+ * @brief Uniform interface to C++98 and C++0x allocators.
+ * @ingroup allocators
+*/
+template<typename _Alloc>
struct __alloc_traits
#ifdef __GXX_EXPERIMENTAL_CXX0X__
: std::allocator_traits<_Alloc>
@@ -66,6 +107,27 @@
using _Base_type::construct;
using _Base_type::destroy;
+ private:
+ template<typename _Ptr>
+ struct __is_custom_pointer
+ : std::integral_constant<bool, std::is_same<pointer, _Ptr>::value
+ && !std::is_pointer<_Ptr>::value>
+ { };
+
+ public:
+ template<typename _Ptr, typename... _Args>
+ static typename std::enable_if<__is_custom_pointer<_Ptr>::value>::type
+ construct(_Alloc& __a, _Ptr __p, _Args&&... __args)
+ {
+ _Base_type::construct(__a, std::addressof(*__p),
+ std::forward<_Args>(__args)...);
+ }
+
+ template<typename _Ptr>
+ static typename std::enable_if<__is_custom_pointer<_Ptr>::value>::type
+ destroy(_Alloc& __a, _Ptr __p)
+ { _Base_type::destroy(__a, std::addressof(*__p)); }
+
static _Alloc _S_select_on_copy(const _Alloc& __a)
{ return _Base_type::select_on_container_copy_construction(__a); }
@@ -81,6 +143,19 @@
static constexpr bool _S_propagate_on_swap()
{ return _Base_type::propagate_on_container_swap::value; }
+ static constexpr bool _S_always_equal()
+ { return __allocator_always_compares_equal<_Alloc>::value; }
+
+ static constexpr bool _S_nothrow_move()
+ { return _S_propagate_on_move_assign() || _S_always_equal(); }
+
+ static constexpr bool _S_nothrow_swap()
+ {
+ using std::swap;
+ return !_S_propagate_on_swap()
+ || noexcept(swap(std::declval<_Alloc&>(),
std::declval<_Alloc&>()));
+ }
+
#else
typedef typename _Alloc::pointer pointer;
