|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r78370 - trunk/boost/unordered/detail
From: dnljms_at_[hidden]
Date: 2012-05-07 14:10:28
Author: danieljames
Date: 2012-05-07 14:10:27 EDT (Mon, 07 May 2012)
New Revision: 78370
URL: http://svn.boost.org/trac/boost/changeset/78370
Log:
Unordered: allocator_helpers cleanup.
Text files modified:
trunk/boost/unordered/detail/allocator_helpers.hpp | 342 +++++++++++++++++++++++----------------
1 files changed, 204 insertions(+), 138 deletions(-)
Modified: trunk/boost/unordered/detail/allocator_helpers.hpp
==============================================================================
--- trunk/boost/unordered/detail/allocator_helpers.hpp (original)
+++ trunk/boost/unordered/detail/allocator_helpers.hpp 2012-05-07 14:10:27 EDT (Mon, 07 May 2012)
@@ -19,8 +19,15 @@
#include <boost/assert.hpp>
#include <boost/utility/addressof.hpp>
-#if !defined(BOOST_UNORDERED_USE_ALLOCATOR_TRAITS)
+////////////////////////////////////////////////////////////////////////////////
+//
+// Pick which version of allocator_traits to use
+//
+// 0 = Own partial implementation
+// 1 = std::allocator_traits
+// 2 = boost::container::allocator_traits
+#if !defined(BOOST_UNORDERED_USE_ALLOCATOR_TRAITS)
# if defined(__GXX_EXPERIMENTAL_CXX0X__) && \
(__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7))
# define BOOST_UNORDERED_USE_ALLOCATOR_TRAITS 1
@@ -39,24 +46,15 @@
# define BOOST_UNORDERED_USE_ALLOCATOR_TRAITS 0
#endif
-#if BOOST_UNORDERED_USE_ALLOCATOR_TRAITS == 0
-# include <boost/limits.hpp>
-# include <boost/utility/enable_if.hpp>
-# include <boost/pointer_to_other.hpp>
-# if defined(BOOST_NO_SFINAE_EXPR)
-# include <boost/type_traits/is_same.hpp>
-# endif
-#elif BOOST_UNORDERED_USE_ALLOCATOR_TRAITS == 1
-# include <memory>
-#elif BOOST_UNORDERED_USE_ALLOCATOR_TRAITS == 2
-# include <boost/container/allocator_traits.hpp>
-#endif
+////////////////////////////////////////////////////////////////////////////////
+//
+// Some utilities for implementing allocator_traits, but useful elsewhere so
+// they're always defined.
#if !defined(BOOST_NO_0X_HDR_TYPE_TRAITS)
# include <type_traits>
#endif
-
namespace boost { namespace unordered { namespace detail {
////////////////////////////////////////////////////////////////////////////
@@ -99,6 +97,13 @@
////////////////////////////////////////////////////////////////////////////
// Expression test mechanism
+ //
+ // When SFINAE expressions are available, define
+ // BOOST_UNORDERED_HAS_FUNCTION which can check if a function call is
+ // supported by a class, otherwise define BOOST_UNORDERED_HAS_MEMBER which
+ // can detect if a class has the specified member, but not that it has the
+ // correct type, this is good enough for a passable impression of
+ // allocator_traits.
#if !defined(BOOST_NO_SFINAE_EXPR)
@@ -106,7 +111,7 @@
template <typename T> struct expr_test<T, sizeof(char)> : T {};
template <typename U> static char for_expr_test(U const&);
-#define BOOST_UNORDERED_CHECK_EXPRESSION(count, result, expression) \
+# define BOOST_UNORDERED_CHECK_EXPRESSION(count, result, expression) \
template <typename U> \
static typename boost::unordered::detail::expr_test< \
BOOST_PP_CAT(choice, result), \
@@ -115,12 +120,12 @@
0)))>::type test( \
BOOST_PP_CAT(choice, count))
-#define BOOST_UNORDERED_DEFAULT_EXPRESSION(count, result) \
+# define BOOST_UNORDERED_DEFAULT_EXPRESSION(count, result) \
template <typename U> \
static BOOST_PP_CAT(choice, result)::type test( \
BOOST_PP_CAT(choice, count))
-#define BOOST_UNORDERED_HAS_FUNCTION(name, thing, args, _) \
+# define BOOST_UNORDERED_HAS_FUNCTION(name, thing, args, _) \
struct BOOST_PP_CAT(has_, name) \
{ \
BOOST_UNORDERED_CHECK_EXPRESSION(1, 1, \
@@ -134,7 +139,7 @@
template <typename T> struct identity { typedef T type; };
-#define BOOST_UNORDERED_CHECK_MEMBER(count, result, name, member) \
+# define BOOST_UNORDERED_CHECK_MEMBER(count, result, name, member) \
\
typedef typename boost::unordered::detail::identity<member>::type \
BOOST_PP_CAT(check, count); \
@@ -148,11 +153,11 @@
BOOST_PP_CAT(test, count)<&U::name>::type \
test(BOOST_PP_CAT(choice, count))
-#define BOOST_UNORDERED_DEFAULT_MEMBER(count, result) \
+# define BOOST_UNORDERED_DEFAULT_MEMBER(count, result) \
template <class U> static BOOST_PP_CAT(choice, result)::type \
test(BOOST_PP_CAT(choice, count))
-#define BOOST_UNORDERED_HAS_MEMBER(name) \
+# define BOOST_UNORDERED_HAS_MEMBER(name) \
struct BOOST_PP_CAT(has_, name) \
{ \
struct impl { \
@@ -172,105 +177,90 @@
#endif
- ////////////////////////////////////////////////////////////////////////////
- // Allocator traits
-
-#if BOOST_UNORDERED_USE_ALLOCATOR_TRAITS == 1
-
-#define BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT 1
-
- template <typename Alloc>
- struct allocator_traits : std::allocator_traits<Alloc> {};
-
- template <typename Alloc, typename T>
- struct rebind_wrap
- {
- typedef typename std::allocator_traits<Alloc>::
- template rebind_alloc<T> type;
- };
-
-#elif BOOST_UNORDERED_USE_ALLOCATOR_TRAITS == 2
-
-#define BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT 0
+}}}
- template <typename Alloc>
- struct allocator_traits :
- boost::container::allocator_traits<Alloc> {};
+////////////////////////////////////////////////////////////////////////////////
+//
+// Allocator traits
+//
+// First our implementation, then later light wrappers around the alternatives
- template <typename Alloc, typename T>
- struct rebind_wrap :
- boost::container::allocator_traits<Alloc>::
- template portable_rebind_alloc<T>
- {};
+#if BOOST_UNORDERED_USE_ALLOCATOR_TRAITS == 0
-#else
+# include <boost/limits.hpp>
+# include <boost/utility/enable_if.hpp>
+# include <boost/pointer_to_other.hpp>
+# if defined(BOOST_NO_SFINAE_EXPR)
+# include <boost/type_traits/is_same.hpp>
+# endif
-#if defined(BOOST_UNORDERED_VARIADIC_MOVE) && \
+# if defined(BOOST_UNORDERED_VARIADIC_MOVE) && \
!defined(BOOST_NO_SFINAE_EXPR)
-# define BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT 1
-#else
-# define BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT 0
-#endif
+# define BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT 1
+# else
+# define BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT 0
+# endif
+
+namespace boost { namespace unordered { namespace detail {
// TODO: Does this match std::allocator_traits<Alloc>::rebind_alloc<T>?
template <typename Alloc, typename T>
struct rebind_wrap
{
- typedef typename Alloc::BOOST_NESTED_TEMPLATE rebind<T>::other
- type;
+ typedef typename Alloc::BOOST_NESTED_TEMPLATE rebind<T>::other type;
};
-#if defined(BOOST_MSVC) && BOOST_MSVC <= 1400
+# if defined(BOOST_MSVC) && BOOST_MSVC <= 1400
- #define BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(tname) \
- template <typename Tp, typename Default> \
- struct default_type_ ## tname { \
+# define BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(tname) \
+ template <typename Tp, typename Default> \
+ struct default_type_ ## tname { \
\
- template <typename X> \
- static choice1::type test(choice1, typename X::tname* = 0); \
+ template <typename X> \
+ static choice1::type test(choice1, typename X::tname* = 0); \
\
- template <typename X> \
- static choice2::type test(choice2, void* = 0); \
+ template <typename X> \
+ static choice2::type test(choice2, void* = 0); \
\
- struct DefaultWrap { typedef Default tname; }; \
+ struct DefaultWrap { typedef Default tname; }; \
\
- enum { value = (1 == sizeof(test<Tp>(choose()))) }; \
+ enum { value = (1 == sizeof(test<Tp>(choose()))) }; \
\
- typedef typename boost::detail::if_true<value>:: \
- BOOST_NESTED_TEMPLATE then<Tp, DefaultWrap> \
- ::type::tname type; \
- }
+ typedef typename boost::detail::if_true<value>:: \
+ BOOST_NESTED_TEMPLATE then<Tp, DefaultWrap> \
+ ::type::tname type; \
+ }
-#else
+# else
template <typename T, typename T2>
struct sfinae : T2 {};
- #define BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(tname) \
- template <typename Tp, typename Default> \
- struct default_type_ ## tname { \
+# define BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(tname) \
+ template <typename Tp, typename Default> \
+ struct default_type_ ## tname { \
\
- template <typename X> \
- static typename boost::unordered::detail::sfinae< \
- typename X::tname, choice1>::type \
- test(choice1); \
+ template <typename X> \
+ static typename boost::unordered::detail::sfinae< \
+ typename X::tname, choice1>::type \
+ test(choice1); \
\
- template <typename X> \
- static choice2::type test(choice2); \
+ template <typename X> \
+ static choice2::type test(choice2); \
\
- struct DefaultWrap { typedef Default tname; }; \
+ struct DefaultWrap { typedef Default tname; }; \
\
- enum { value = (1 == sizeof(test<Tp>(choose()))) }; \
+ enum { value = (1 == sizeof(test<Tp>(choose()))) }; \
\
- typedef typename boost::detail::if_true<value>:: \
- BOOST_NESTED_TEMPLATE then<Tp, DefaultWrap> \
- ::type::tname type; \
- }
+ typedef typename boost::detail::if_true<value>:: \
+ BOOST_NESTED_TEMPLATE then<Tp, DefaultWrap> \
+ ::type::tname type; \
+ }
-#endif
+# endif
- #define BOOST_UNORDERED_DEFAULT_TYPE(T,tname, arg) \
- typename default_type_ ## tname<T, arg>::type
+# define BOOST_UNORDERED_DEFAULT_TYPE(T,tname, arg) \
+ typename default_type_ ## tname<T, arg>::type
BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(pointer);
BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(const_pointer);
@@ -282,7 +272,8 @@
BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(propagate_on_container_move_assignment);
BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(propagate_on_container_swap);
-#if !defined(BOOST_NO_SFINAE_EXPR)
+# if !defined(BOOST_NO_SFINAE_EXPR)
+
template <typename T>
BOOST_UNORDERED_HAS_FUNCTION(
select_on_container_copy_construction, U const, (), 0
@@ -293,27 +284,33 @@
max_size, U const, (), 0
);
-# if defined(BOOST_UNORDERED_VARIADIC_MOVE)
+# if defined(BOOST_UNORDERED_VARIADIC_MOVE)
+
template <typename T, typename ValueType, typename... Args>
BOOST_UNORDERED_HAS_FUNCTION(
- construct, U, (
- boost::unordered::detail::make<ValueType*>(),
- boost::unordered::detail::make<Args const>()...), 2
+ construct, U, (
+ boost::unordered::detail::make<ValueType*>(),
+ boost::unordered::detail::make<Args const>()...), 2
);
-# else
+
+# else
+
template <typename T, typename ValueType>
BOOST_UNORDERED_HAS_FUNCTION(
- construct, U, (
- boost::unordered::detail::make<ValueType*>(),
- boost::unordered::detail::make<ValueType const>()), 2
+ construct, U, (
+ boost::unordered::detail::make<ValueType*>(),
+ boost::unordered::detail::make<ValueType const>()), 2
);
-# endif
+
+# endif
template <typename T, typename ValueType>
BOOST_UNORDERED_HAS_FUNCTION(
destroy, U, (boost::unordered::detail::make<ValueType*>()), 1
);
-#else
+
+# else
+
template <typename T>
BOOST_UNORDERED_HAS_MEMBER(select_on_container_copy_construction);
@@ -325,7 +322,8 @@
template <typename T, typename ValueType>
BOOST_UNORDERED_HAS_MEMBER(destroy);
-#endif
+
+# endif
template <typename Alloc>
inline typename boost::enable_if_c<
@@ -393,7 +391,7 @@
// TODO: rebind_alloc and rebind_traits
- static pointer allocate(Alloc& a, size_type n)
+ static pointer allocate(Alloc& a, size_type n)
{ return a.allocate(n); }
// I never use this, so I'll just comment it out for now.
@@ -401,13 +399,13 @@
//static pointer allocate(Alloc& a, size_type n,
// const_void_pointer hint)
// { return DEFAULT_FUNC(allocate, pointer)(a, n, hint); }
-
+
static void deallocate(Alloc& a, pointer p, size_type n)
{ a.deallocate(p, n); }
public:
-#if BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT
+# if BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT
template <typename T, typename... Args>
static typename boost::enable_if_c<
@@ -427,34 +425,27 @@
new ((void*) p) T(boost::forward<Args>(x)...);
}
-#elif !defined(BOOST_NO_SFINAE_EXPR)
-
template <typename T>
static typename boost::enable_if_c<
- boost::unordered::detail::has_construct<Alloc, T>::value>::type
- construct(Alloc& a, T* p, T const& x)
+ boost::unordered::detail::has_destroy<Alloc, T>::value>::type
+ destroy(Alloc& a, T* p)
{
- a.construct(p, x);
+ a.destroy(p);
}
template <typename T>
static typename boost::disable_if_c<
- boost::unordered::detail::has_construct<Alloc, T>::value>::type
- construct(Alloc&, T* p, T const& x)
+ boost::unordered::detail::has_destroy<Alloc, T>::value>::type
+ destroy(Alloc&, T* p)
{
- new ((void*) p) T(x);
+ boost::unordered::detail::destroy(p);
}
-#else
-
- // If we don't have SFINAE expressions, only construct the type
- // that matches the allocator.
+# elif !defined(BOOST_NO_SFINAE_EXPR)
template <typename T>
static typename boost::enable_if_c<
- boost::unordered::detail::has_construct<Alloc, T>::value &&
- boost::is_same<T, value_type>::value
- >::type
+ boost::unordered::detail::has_construct<Alloc, T>::value>::type
construct(Alloc& a, T* p, T const& x)
{
a.construct(p, x);
@@ -462,17 +453,15 @@
template <typename T>
static typename boost::disable_if_c<
- boost::unordered::detail::has_construct<Alloc, T>::value &&
- boost::is_same<T, value_type>::value
- >::type
+ boost::unordered::detail::has_construct<Alloc, T>::value>::type
construct(Alloc&, T* p, T const& x)
{
new ((void*) p) T(x);
}
-#endif
+# endif
-#if BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT
+# if BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT
template <typename T>
static typename boost::enable_if_c<
@@ -490,26 +479,31 @@
boost::unordered::detail::destroy(p);
}
-#elif !defined(BOOST_NO_SFINAE_EXPR)
+# else
+
+ // If we don't have SFINAE expressions, only call construct the type
+ // that matches the allocator.
template <typename T>
static typename boost::enable_if_c<
- boost::unordered::detail::has_destroy<Alloc, T>::value>::type
- destroy(Alloc& a, T* p)
+ boost::unordered::detail::has_construct<Alloc, T>::value &&
+ boost::is_same<T, value_type>::value
+ >::type
+ construct(Alloc& a, T* p, T const& x)
{
- a.destroy(p);
+ a.construct(p, x);
}
template <typename T>
static typename boost::disable_if_c<
- boost::unordered::detail::has_destroy<Alloc, T>::value>::type
- destroy(Alloc&, T* p)
+ boost::unordered::detail::has_construct<Alloc, T>::value &&
+ boost::is_same<T, value_type>::value
+ >::type
+ construct(Alloc&, T* p, T const& x)
{
- boost::unordered::detail::destroy(p);
+ new ((void*) p) T(x);
}
-#else
-
template <typename T>
static typename boost::enable_if_c<
boost::unordered::detail::has_destroy<Alloc, T>::value &&
@@ -530,7 +524,7 @@
boost::unordered::detail::destroy(p);
}
-#endif
+# endif
static size_type max_size(const Alloc& a)
{
@@ -538,13 +532,13 @@
}
// Allocator propagation on construction
-
+
static Alloc select_on_container_copy_construction(Alloc const& rhs)
{
return boost::unordered::detail::
call_select_on_container_copy_construction(rhs);
}
-
+
// Allocator propagation on assignment and swap.
// Return true if lhs is modified.
typedef BOOST_UNORDERED_DEFAULT_TYPE(
@@ -557,13 +551,78 @@
Alloc,propagate_on_container_swap,false_type)
propagate_on_container_swap;
};
+}}}
+
+# undef BOOST_UNORDERED_DEFAULT_TYPE_TMPLT
+# undef BOOST_UNORDERED_DEFAULT_TYPE
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// std::allocator_traits
+
+#elif BOOST_UNORDERED_USE_ALLOCATOR_TRAITS == 1
+
+# include <memory>
+
+# define BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT 1
-#undef BOOST_UNORDERED_DEFAULT_TYPE_TMPLT
-#undef BOOST_UNORDERED_DEFAULT_TYPE
+namespace boost { namespace unordered { namespace detail {
+
+ template <typename Alloc>
+ struct allocator_traits : std::allocator_traits<Alloc> {};
+
+ template <typename Alloc, typename T>
+ struct rebind_wrap
+ {
+ typedef typename std::allocator_traits<Alloc>::
+ template rebind_alloc<T> type;
+ };
+}}}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// boost::container::allocator_traits
+
+#elif BOOST_UNORDERED_USE_ALLOCATOR_TRAITS == 2
+
+# include <boost/container/allocator_traits.hpp>
+
+# define BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT 0
+
+namespace boost { namespace unordered { namespace detail {
+
+ template <typename Alloc>
+ struct allocator_traits :
+ boost::container::allocator_traits<Alloc> {};
+
+ template <typename Alloc, typename T>
+ struct rebind_wrap :
+ boost::container::allocator_traits<Alloc>::
+ template portable_rebind_alloc<T>
+ {};
+
+}}}
+
+#else
+
+#error "Invalid BOOST_UNORDERED_USE_ALLOCATOR_TRAITS value."
#endif
+////////////////////////////////////////////////////////////////////////////////
+//
+// Some helper functions for allocating & constructing
+
+namespace boost { namespace unordered { namespace detail {
+
+ ////////////////////////////////////////////////////////////////////////////
+ //
+ // construct_node/destroy_node
+ //
+ // Construct a node using the best available method.
+
#if BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT
+
template <typename Alloc, typename T, BOOST_UNORDERED_EMPLACE_TEMPLATE>
inline void construct_node(Alloc& a, T* p, BOOST_UNORDERED_EMPLACE_ARGS)
{
@@ -576,7 +635,9 @@
{
boost::unordered::detail::allocator_traits<Alloc>::destroy(a, p);
}
+
#else
+
template <typename Alloc, typename T, BOOST_UNORDERED_EMPLACE_TEMPLATE>
inline void construct_node(Alloc& a, T* p, BOOST_UNORDERED_EMPLACE_ARGS)
{
@@ -596,8 +657,11 @@
boost::unordered::detail::destroy(p->value_ptr());
boost::unordered::detail::allocator_traits<Alloc>::destroy(a, p);
}
+
#endif
+ ////////////////////////////////////////////////////////////////////////////
+ //
// array_constructor
//
// Allocate and construct an array in an exception safe manner, and
@@ -653,7 +717,9 @@
ptr_ = pointer();
return p;
}
+
private:
+
array_constructor(array_constructor const&);
array_constructor& operator=(array_constructor const&);
};
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk