[Boost-commit] svn:boost r74532 - in trunk: boost/unordered/detail libs/unordered/test/unordered

Subject: [Boost-commit] svn:boost r74532 - in trunk: boost/unordered/detail libs/unordered/test/unordered
From: dnljms_at_[hidden]
Date: 2011-09-22 19:56:50

Author: danieljames
Date: 2011-09-22 19:56:49 EDT (Thu, 22 Sep 2011)
New Revision: 74532
URL: http://svn.boost.org/trac/boost/changeset/74532

Log:
Unordered: New member function detection.

Based on Ion's `has_member_function_callable_with`.
Text files modified: 
   trunk/boost/unordered/detail/allocator_helpers.hpp       |   155 ++++++++++++++++++++++++++------------- 
   trunk/libs/unordered/test/unordered/allocator_traits.cpp |    19 ++--                                    
   2 files changed, 115 insertions(+), 59 deletions(-)

Modified: trunk/boost/unordered/detail/allocator_helpers.hpp
==============================================================================
--- trunk/boost/unordered/detail/allocator_helpers.hpp	(original)
+++ trunk/boost/unordered/detail/allocator_helpers.hpp	2011-09-22 19:56:49 EDT (Thu, 22 Sep 2011)
@@ -19,8 +19,10 @@
 #include <boost/detail/select_type.hpp>
 #include <boost/utility/enable_if.hpp>
 #include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/enum.hpp>
 #include <boost/limits.hpp>
 #include <boost/type_traits/add_lvalue_reference.hpp>
+#include <boost/pointer_to_other.hpp>
 
 #if BOOST_UNORDERED_USE_ALLOCATOR_TRAITS
 #  include <memory>
@@ -97,6 +99,22 @@
     struct choice1 : choice2 { typedef char (&type)[1]; };
     choice1 choose();
 
+    typedef choice1::type yes_type;
+    typedef choice2::type no_type;
+
+    struct private_type
+    {
+       private_type const &operator,(int) const;
+    };
+
+    template <typename T>
+    no_type is_private_type(T const&);
+    yes_type is_private_type(private_type const&);
+
+    struct convert_from_anything {
+        convert_from_anything(...);
+    };
+
 #if defined(BOOST_MSVC) && BOOST_MSVC <= 1400
 
     #define BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(tname)                       \
@@ -176,44 +194,40 @@
         static BOOST_PP_CAT(choice, result)::type test(                     \
             BOOST_PP_CAT(choice, count))
 
-#define BOOST_UNORDERED_HAS_EXPRESSION(name, expression)                    \
+#define BOOST_UNORDERED_HAS_FUNCTION(name, thing, args, _)                  \
     struct BOOST_PP_CAT(has_, name)                                         \
     {                                                                       \
-        BOOST_UNORDERED_CHECK_EXPRESSION(1, 1, expression);                 \
+        BOOST_UNORDERED_CHECK_EXPRESSION(1, 1, make< thing >().name args);  \
         BOOST_UNORDERED_DEFAULT_EXPRESSION(2, 2);                           \
                                                                             \
         enum { value = sizeof(test<T>(choose())) == sizeof(choice1::type) };\
     }
 
     template <typename T>
-    BOOST_UNORDERED_HAS_EXPRESSION(
-        select_on_container_copy_construction,
-        make<U const>().select_on_container_copy_construction()
+    BOOST_UNORDERED_HAS_FUNCTION(
+        select_on_container_copy_construction, U const, (), 0
     );
 
     // Only supporting the basic copy constructor for now.
 
     template <typename T, typename ValueType>
-    BOOST_UNORDERED_HAS_EXPRESSION(
-        construct,
-        make<U>().construct(make<ValueType*>(), make<ValueType const>())
+    BOOST_UNORDERED_HAS_FUNCTION(
+        construct, U, (make<ValueType*>(), make<ValueType const>()), 2
     );
 
     template <typename T, typename ValueType>
-    BOOST_UNORDERED_HAS_EXPRESSION(
-        destroy,
-        make<U>().destroy(make<ValueType*>())
+    BOOST_UNORDERED_HAS_FUNCTION(
+        destroy, U, (make<ValueType*>()), 1
     );
 
     template <typename T>
-    BOOST_UNORDERED_HAS_EXPRESSION(
-        max_size,
-        make<U const>().max_size()
+    BOOST_UNORDERED_HAS_FUNCTION(
+        max_size, U const, (), 0
     );
 
 #else
 
-   template <typename T> struct identity { typedef T type; };
+    template <typename T> struct identity { typedef T type; };
 
 #define BOOST_UNORDERED_CHECK_MEMBER(count, result, name, member)           \
                                                                             \
@@ -232,27 +246,73 @@
     template <class U> static BOOST_PP_CAT(choice, result)::type            \
         test(BOOST_PP_CAT(choice, count))
 
+#define BOOST_UNORDERED_WRAP_PARAMATERS(z, n, data) convert_from_anything
+
+#define BOOST_UNORDERED_HAS_MEMBER(name)                                    \
+    struct BOOST_PP_CAT(has_, name)                                         \
+    {                                                                       \
+        struct base_mixin { void name(); };                                 \
+        struct base : public T, public base_mixin {};                       \
+                                                                            \
+        BOOST_UNORDERED_CHECK_MEMBER(1, 1, name, void (base_mixin::*)());   \
+        BOOST_UNORDERED_DEFAULT_MEMBER(2, 2);                               \
+                                                                            \
+        enum { value = sizeof(choice2::type) ==                             \
+            sizeof(test<base>(choose()))                                    \
+        };                                                                  \
+    }
+
+#define BOOST_UNORDERED_HAS_FUNCTION(name, thing, args, arg_count)          \
+    struct BOOST_PP_CAT(has_, name)                                         \
+    {                                                                       \
+        struct base_mixin { void name(); };                                 \
+        struct base : public T, public base_mixin {};                       \
+                                                                            \
+        BOOST_UNORDERED_CHECK_MEMBER(1, 1, name, void (base_mixin::*)());   \
+        BOOST_UNORDERED_DEFAULT_MEMBER(2, 2);                               \
+                                                                            \
+        enum { has_member = sizeof(choice2::type) ==                        \
+            sizeof(test<base>(choose()))                                    \
+        };                                                                  \
+                                                                            \
+        template <typename U>                                               \
+        struct wrap : U                                                     \
+        {                                                                   \
+            using U::name;                                                  \
+            private_type name(                                              \
+            BOOST_PP_ENUM(arg_count, BOOST_UNORDERED_WRAP_PARAMATERS, _)    \
+            );                                                              \
+        };                                                                  \
+                                                                            \
+        template <typename U>                                               \
+        struct impl                                                         \
+        {                                                                   \
+            enum { value = sizeof(is_private_type((                         \
+                make<wrap< thing > >().name args                            \
+            , 0))) == sizeof(yes_type) };                                   \
+        };                                                                  \
+                                                                            \
+        enum { value =                                                      \
+            boost::detail::if_true<has_member>::                            \
+            BOOST_NESTED_TEMPLATE then<impl<T>, false_type>::type::value    \
+        };                                                                  \
+    }
 
     template <typename T>
-    struct has_select_on_container_copy_construction
-    {
-        BOOST_UNORDERED_CHECK_MEMBER(1, 1,
-            select_on_container_copy_construction,
-            T (T::*)() const);
-        BOOST_UNORDERED_DEFAULT_MEMBER(2, 2);
- 
-        enum { value = sizeof(test<T>(choose())) == sizeof(choice1::type) };
-    };
+    BOOST_UNORDERED_HAS_MEMBER(select_on_container_copy_construction);
 
-    // Detection isn't reliable enough, so just assume that we have these
-    // functions.
-    
-    template <typename Alloc, typename value_type>
-    struct has_construct : true_type {};
-    template <typename Alloc, typename value_type>
-    struct has_destroy : true_type {};
-    template <typename Alloc>
-    struct has_max_size : true_type {};
+    template <typename T, typename ValueType>
+    BOOST_UNORDERED_HAS_FUNCTION(
+        construct, U, (make<ValueType*>(), make<ValueType const>()), 2
+    );
+
+    template <typename T, typename ValueType>
+    BOOST_UNORDERED_HAS_FUNCTION(
+        destroy, U, (make<ValueType*>()), 1
+    );
+
+    template <typename T>
+    BOOST_UNORDERED_HAS_MEMBER(max_size);
 
 #endif
 
@@ -295,27 +355,20 @@
         typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, pointer, value_type*)
             pointer;
 
-        // For now always use the allocator's const_pointer.
-
-        //typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, const_pointer,
-        //    typename pointer_traits<pointer>::
-        //    BOOST_NESTED_TEMPLATE rebind<const value_type>::other)
-        //    const_pointer;
+        template <typename T>
+        struct pointer_to_other : boost::pointer_to_other<pointer, T> {};
 
         typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, const_pointer,
-            value_type const*) const_pointer;
-
-        // I'm not using void pointers for now.
+            typename pointer_to_other<const value_type>::type)
+            const_pointer;
 
-        //typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, void_pointer,
-        //    BOOST_NESTED_TEMPLATE pointer_traits<pointer>::
-        //    BOOST_NESTED_TEMPLATE rebind<void>::other)
-        //    void_pointer;
-
-        //typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, const_void_pointer,
-        //    typename pointer_traits<pointer>::
-        //    BOOST_NESTED_TEMPLATE rebind<const void>::other)
-        //    const_void_pointer;
+        typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, void_pointer,
+            typename pointer_to_other<void>::type)
+            void_pointer;
+
+        typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, const_void_pointer,
+            typename pointer_to_other<const void>::type)
+            const_void_pointer;
 
         typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, difference_type,
             std::ptrdiff_t) difference_type;

Modified: trunk/libs/unordered/test/unordered/allocator_traits.cpp
==============================================================================
--- trunk/libs/unordered/test/unordered/allocator_traits.cpp	(original)
+++ trunk/libs/unordered/test/unordered/allocator_traits.cpp	2011-09-22 19:56:49 EDT (Thu, 22 Sep 2011)
@@ -136,8 +136,17 @@
 
 // allocator 2
 
+template <typename Alloc>
+struct allocator2_base
+{
+    Alloc select_on_container_copy_construction() const {
+        ++selected;
+        return Alloc();
+    }
+};
+
 template <typename T>
-struct allocator2
+struct allocator2 : allocator2_base<allocator2<T> >
 {
     typedef T value_type;
     typedef T* pointer;
@@ -149,12 +158,6 @@
     typedef no_type propagate_on_container_copy_assignment;
     typedef no_type propagate_on_container_move_assignment;
     typedef no_type propagate_on_container_swap;
-
-    // Note: Not const - so it shouldn't be called.
-    allocator2<T> select_on_container_copy_construction() {
-        ++selected;
-        return allocator2<T>();
-    }
 };
 
 void test_allocator2()
@@ -169,7 +172,7 @@
     BOOST_TEST(!traits::propagate_on_container_copy_assignment::value);
     BOOST_TEST(!traits::propagate_on_container_move_assignment::value);
     BOOST_TEST(!traits::propagate_on_container_swap::value);
-    BOOST_TEST(call_select<allocator>() == 0);
+    BOOST_TEST(call_select<allocator>() == 1);
 }
 
 // allocator 3