merged from trunk

[SVN r21516]

include/boost/iterator/indirect_iterator.hpp

@@ -12,11 +12,15 @@
 #include <boost/iterator.hpp>
 #include <boost/iterator/iterator_adaptor.hpp>
 
-#include <boost/iterator/iterator_traits.hpp>
-
-#include <boost/type_traits/remove_cv.hpp>
+#include <boost/pointee.hpp>
+#include <boost/indirect_reference.hpp>
+#include <boost/detail/iterator.hpp>
 
 #include <boost/python/detail/indirect_traits.hpp>
+
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/add_reference.hpp>
+
 #include <boost/mpl/bool.hpp>
 #include <boost/mpl/identity.hpp>
 #include <boost/mpl/apply_if.hpp>
@@ -37,116 +41,8 @@ namespace boost
   template <class Iter, class Value, class Category, class Reference, class Difference>
   class indirect_iterator;
 
-  template <class T>
-  struct referent;
-  
   namespace detail
   {
-    struct unspecified {};
-
-    //
-    // Detection for whether a type has a nested `element_type'
-    // typedef. Used to detect smart pointers. For compilers not
-    // supporting mpl's has_xxx, we supply specializations. However, we
-    // really ought to have a specializable is_pointer template which
-    // can be used instead with something like
-    // boost/python/pointee.hpp to find the value_type.
-    //
-# ifndef BOOST_MPL_NO_AUX_HAS_XXX
-    namespace aux
-    {
-      BOOST_MPL_HAS_XXX_TRAIT_DEF(element_type)
-    }
-
-    template <class T>
-    struct has_element_type
-        : mpl::bool_<
-              mpl::if_<
-                  is_class<T>
-                , ::boost::detail::aux::has_element_type<T>
-                , mpl::false_
-              >::type::value
-          >
-    {
-    };
-# else
-    template <class T>
-    struct has_element_type
-        : mpl::false_ {};
-    
-    template <class T>
-    struct has_element_type<boost::shared_ptr<T> >
-        : mpl::true_ {};
-    
-    template <class T>
-    struct has_element_type<boost::scoped_ptr<T> >
-        : mpl::true_ {};
-    
-    template <class T>
-    struct has_element_type<std::auto_ptr<T> >
-        : mpl::true_ {};
-# endif 
-  
-    // Metafunction accessing the nested ::element_type
-    template <class T>
-    struct element_type
-      : mpl::identity<typename T::element_type>
-    {};
-
-    template <class T>
-    struct iterator_is_mutable
-        : mpl::not_<
-              boost::python::detail::is_reference_to_const<
-                 typename iterator_reference<T>::type
-              >
-          >
-    {
-    };
-
-    template <class T>
-    struct not_int_impl
-    {
-        template <class U>
-        struct apply {
-            typedef T type;
-        };
-    };
-
-    template <>
-    struct not_int_impl<int> {};
-    
-    template <class T, class U>
-    struct not_int
-        : not_int_impl<T>::template apply<U> {};
-
-
-    template <class Dereferenceable>
-    struct class_has_element_type
-      : mpl::and_<
-            is_class<Dereferenceable>
-          , has_element_type<Dereferenceable>
-        >
-    {};
-
-    // If the Value parameter is unspecified, we use this metafunction
-    // to deduce the default types
-    template <class Dereferenceable>
-    struct default_indirect_value
-    {
-        typedef typename remove_cv<
-            typename referent<Dereferenceable>::type
-        >::type referent_t;
-
-        typedef typename mpl::if_<
-            mpl::or_<
-                class_has_element_type<Dereferenceable>
-              , iterator_is_mutable<Dereferenceable>
-            >
-          , referent_t
-          , referent_t const
-        >::type type;
-    };
-    
     template <class Iter, class Value, class Category, class Reference, class Difference>
     struct indirect_base
     {
@@ -156,10 +52,17 @@ namespace boost
             indirect_iterator<Iter, Value, Category, Reference, Difference>
           , Iter
           , typename ia_dflt_help<
-                Value, default_indirect_value<dereferenceable>
+                Value, pointee<dereferenceable>
             >::type
           , Category
-          , Reference
+          , typename ia_dflt_help<
+                Reference
+              , mpl::apply_if<
+                    is_same<Value,use_default>
+                  , indirect_reference<dereferenceable>
+                  , add_reference<Value>
+                >
+            >::type
           , Difference
         > type;
     };
@@ -168,19 +71,6 @@ namespace boost
     struct indirect_base<int, int, int, int, int> {};
   } // namespace detail
 
-  // User-specializable metafunction which returns the referent of a
-  // dereferenceable type.  The default implementation returns
-  // Dereferenceable::element_type if such a member exists (thus
-  // handling the boost smart pointers and auto_ptr), and
-  // iterator_traits<Dereferenceable>::value_type otherwise.
-  template <class Dereferenceable>
-  struct referent
-    : mpl::apply_if<
-          detail::class_has_element_type<Dereferenceable>
-        , detail::element_type<Dereferenceable>
-        , iterator_value<Dereferenceable>
-      >
-  {};
     
   template <
       class Iterator