Updated pointee and indirect_reference so that pointee represents the

immutability of the pointed-to type via const qualification.  The
pointee of a proxy-based iterator will be const qualified unless a
mutable reference to the value_type can be bound to the returned
proxy.

Added a test for pointee

Fixed iterator_facade so operator[] result type computation didn't
cause a problem with abstract types.

Updated iterator_facade operator[] docs for accuracy.

Allowed Borland to simply fail the indirect_iterator_member_types test
because of its lame const-dropping, instead of trying to work around
it.


[SVN r21579]

doc/iterator_facade_body.rst

@@ -151,14 +151,16 @@ into the temporary iterator ``p+n``, which is destroyed when
 
 Writable iterators built with ``iterator_facade`` implement the
 semantics required by the preferred resolution to `issue 299`_ and
-adopted by proposal n1550_: the result of ``p[n]`` is a proxy object
-containing a copy of ``p+n``, and ``p[n] = x`` is equivalent to ``*(p
-+ n) = x``.  This approach will work properly for any random-access
-iterator regardless of the other details of its implementation.  A
-user who knows more about the implementation of her iterator is free
-to implement an ``operator[]`` which returns an lvalue in the derived
-iterator class; it will hide the one supplied by ``iterator_facade``
-from clients of her iterator.
+adopted by proposal n1550_: the result of ``p[n]`` is an object
+convertible to the iterator's ``value_type``, and ``p[n] = x`` is
+equivalent to ``*(p + n) = x`` (Note: This result object may be
+implemented as a proxy containing a copy of ``p+n``).  This approach
+will work properly for any random-access iterator regardless of the
+other details of its implementation.  A user who knows more about
+the implementation of her iterator is free to implement an
+``operator[]`` that returns an lvalue in the derived iterator
+class; it will hide the one supplied by ``iterator_facade`` from
+clients of her iterator.
 
 .. _n1550: http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/papers/2003/n1550.html
 

doc/iterator_facade_ref.rst

@@ -245,10 +245,13 @@ __ `operator arrow`_
 
 *unspecified* ``operator[](difference_type n) const;``
 
-:Returns: an object convertible to ``reference`` and holding a copy
-     *p* of ``*static_cast<Derived const*>(this) + n`` such that, for a constant object ``v`` of type
-     ``value_type``, ``(*static_cast<Derived const*>(this))[n] = v`` is equivalent
-     to ``p = v``.
+:Returns: an object convertible to ``value_type``. For constant
+     objects ``v`` of type ``value_type``, and ``n`` of type
+     ``difference_type``, and reference ``p`` equal to
+     ``*static_cast<Derived const*>(this)``, ``(*this)[n] = v`` is
+     equivalent to ``*(p+ n) = v``, and ``static_cast<value_type
+     const&>((*this)[n])`` is equivalent to
+     ``static_cast<value_type const&>(*(p+n))`` 
 
 
 

include/boost/iterator/iterator_facade.hpp

@@ -22,9 +22,11 @@
 #include <boost/type_traits/add_pointer.hpp>
 #include <boost/type_traits/remove_const.hpp>
 #include <boost/type_traits/is_convertible.hpp>
+#include <boost/type_traits/is_POD.hpp>
 
 #include <boost/mpl/apply_if.hpp>
 #include <boost/mpl/or.hpp>
+#include <boost/mpl/and.hpp>
 
 #include <boost/iterator/detail/config_def.hpp> // this goes last
 
@@ -182,11 +184,21 @@ namespace boost
         Iterator m_iter;
     };
 
+    template <class Value, class Reference>
+    struct use_operator_brackets_proxy
+      : mpl::and_<
+            // Really we want an is_copy_constructible trait here,
+            // but is_POD will have to suffice in the meantime.
+            boost::is_POD<Value>
+          , iterator_writability_disabled<Value,Reference>
+        >
+    {};
+        
     template <class Iterator, class Value, class Reference>
     struct operator_brackets_result
     {
         typedef typename mpl::if_<
-            iterator_writability_disabled<Value,Reference>
+            use_operator_brackets_proxy<Value,Reference>
           , Value 
           , operator_brackets_proxy<Iterator>
         >::type type;
@@ -387,12 +399,11 @@ namespace boost
       typename detail::operator_brackets_result<Derived,Value,Reference>::type
       operator[](difference_type n) const
       {
-          typedef detail::iterator_writability_disabled<Value,Reference>
-              not_writable;
+          typedef detail::use_operator_brackets_proxy<Value,Reference> use_proxy;
           
           return detail::make_operator_brackets_result<Derived>(
               this->derived() + n
-            , not_writable()
+            , use_proxy()
           );
       }
 

include/boost/pointee.hpp

@@ -9,7 +9,9 @@
 
 # include <boost/detail/is_incrementable.hpp>
 # include <boost/iterator/iterator_traits.hpp>
+# include <boost/type_traits/add_const.hpp>
 # include <boost/type_traits/remove_cv.hpp>
+# include <boost/mpl/if.hpp>
 # include <boost/mpl/apply_if.hpp>
 
 namespace boost { 
@@ -17,9 +19,37 @@ namespace boost {
 namespace detail
 {
   template <class P>
-  struct smart_ptr_value
+  struct smart_ptr_pointee
   {
-      typedef typename remove_cv<typename P::element_type>::type type;
+      typedef typename P::element_type type;
+  };
+
+  template <class Iterator>
+  struct iterator_pointee
+  {
+      typedef typename iterator_traits<Iterator>::value_type value_type;
+      
+      struct impl
+      {
+          template <class T>
+          static char test(T const&);
+          
+          static char (& test(value_type&) )[2];
+          
+          static Iterator& x;
+      };
+      
+      BOOST_STATIC_CONSTANT(bool, is_constant = sizeof(impl::test(*impl::x)) == 1);
+      
+      typedef typename mpl::if_c<
+#  if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
+          ::boost::detail::iterator_pointee<Iterator>::is_constant
+#  else
+          is_constant
+#  endif 
+        , typename add_const<value_type>::type
+        , value_type
+      >::type type;
   };
 }
 
@@ -30,8 +60,8 @@ struct pointee
 
     typedef typename mpl::apply_if<
         detail::is_incrementable<stripped>
-      , iterator_value<stripped>
-      , detail::smart_ptr_value<stripped>
+      , detail::iterator_pointee<stripped>
+      , detail::smart_ptr_pointee<stripped>
     >::type type;
 };
   

test/Jamfile

@@ -29,6 +29,7 @@ test-suite iterator
     # These tests should work for just about everything.
     [ compile is_lvalue_iterator.cpp ]
     [ compile is_readable_iterator.cpp ]
+    [ compile pointee.cpp ]
       
     [ run unit_tests.cpp ]
     [ run concept_tests.cpp ]

test/indirect_iterator_member_types.cpp

@@ -30,19 +30,8 @@ struct my_ptr {
 BOOST_TT_BROKEN_COMPILER_SPEC(my_ptr)
 BOOST_TT_BROKEN_COMPILER_SPEC(zow)
 
-#ifndef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
-    
-# define STATIC_ASSERT_SAME_POINTER(P1, P2)                         \
-    STATIC_ASSERT_SAME(                                             \
-        boost::remove_const<boost::remove_pointer<P1>::type>::type  \
-      , boost::remove_const<boost::remove_pointer<P2>::type>::type  \
-    )
-
-#else
-    
-# define STATIC_ASSERT_SAME_POINTER(P1, P2) STATIC_ASSERT_SAME(P1,P2)
-    
-#endif
+// Borland 5.6.4 and earlier drop const all over the place, so this
+// test will fail in the lines marked with (**)
     
 int main()
 {
@@ -50,7 +39,7 @@ int main()
     typedef boost::indirect_iterator<int**> Iter;
     STATIC_ASSERT_SAME(Iter::value_type, int);
     STATIC_ASSERT_SAME(Iter::reference, int&);  
-    STATIC_ASSERT_SAME_POINTER(Iter::pointer, int*);  
+    STATIC_ASSERT_SAME(Iter::pointer, int*);  
     STATIC_ASSERT_SAME(Iter::difference_type, std::ptrdiff_t);
     
     BOOST_STATIC_ASSERT((boost::is_convertible<Iter::iterator_category,
@@ -62,31 +51,26 @@ int main()
     typedef boost::indirect_iterator<int const**> Iter;
     STATIC_ASSERT_SAME(Iter::value_type, int);
     STATIC_ASSERT_SAME(Iter::reference, const int&);
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))  // Borland drops const all over the place
-    STATIC_ASSERT_SAME_POINTER(Iter::pointer, const int*);
-#endif 
+    STATIC_ASSERT_SAME(Iter::pointer, const int*);    // (**)
   }
   {
     typedef boost::indirect_iterator<int**, int> Iter;
     STATIC_ASSERT_SAME(Iter::value_type, int);
     STATIC_ASSERT_SAME(Iter::reference, int&);  
-    STATIC_ASSERT_SAME_POINTER(Iter::pointer, int*);  
+    STATIC_ASSERT_SAME(Iter::pointer, int*);  
   }
   {
     typedef boost::indirect_iterator<int**, const int> Iter;
     STATIC_ASSERT_SAME(Iter::value_type, int);
     STATIC_ASSERT_SAME(Iter::reference, const int&);  
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))  // Borland drops const all over the place
-    STATIC_ASSERT_SAME_POINTER(Iter::pointer, const int*);
-#endif 
+    STATIC_ASSERT_SAME(Iter::pointer, const int*);    // (**)
   }
   {
     typedef boost::indirect_iterator<my_ptr*> Iter;
     STATIC_ASSERT_SAME(Iter::value_type, zow);
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))  // Borland drops const all over the place
-    STATIC_ASSERT_SAME(Iter::reference, const zow&);
-    STATIC_ASSERT_SAME_POINTER(Iter::pointer, const zow*);  
-#endif 
+    STATIC_ASSERT_SAME(Iter::reference, const zow&);  // (**)
+    STATIC_ASSERT_SAME(Iter::pointer, const zow*);    // (**)
+    
     STATIC_ASSERT_SAME(Iter::difference_type, std::ptrdiff_t);
     
     BOOST_STATIC_ASSERT((boost::is_convertible<Iter::iterator_category,
@@ -98,7 +82,7 @@ int main()
     typedef boost::indirect_iterator<char**, int, std::random_access_iterator_tag, long&, short> Iter;
     STATIC_ASSERT_SAME(Iter::value_type, int);
     STATIC_ASSERT_SAME(Iter::reference, long&);  
-    STATIC_ASSERT_SAME_POINTER(Iter::pointer, int*);  
+    STATIC_ASSERT_SAME(Iter::pointer, int*);  
     STATIC_ASSERT_SAME(Iter::difference_type, short);  
   }
   return 0;

test/pointee.cpp

@@ -0,0 +1,72 @@
+// Copyright David Abrahams 2004. Use, modification and distribution is
+// subject to the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/pointee.hpp>
+#include <boost/type_traits/add_const.hpp>
+#include "static_assert_same.hpp"
+#include <memory>
+#include <list>
+
+template <class T, class Ref>
+struct proxy_ptr
+{
+    typedef T element_type;
+    struct proxy
+    {
+        operator Ref() const;
+    };
+    proxy operator*() const;
+};
+
+template <class T>
+struct proxy_ref_ptr : proxy_ptr<T,T&>
+{
+};
+
+template <class T>
+struct proxy_value_ptr : proxy_ptr<T,T>
+{
+    typedef typename boost::add_const<T>::type element_type;
+};
+
+struct X {
+    template <class T> X(T const&);
+    template <class T> operator T&() const;
+};
+
+BOOST_TT_BROKEN_COMPILER_SPEC(X)
+    
+int main()
+{
+    STATIC_ASSERT_SAME(boost::pointee<proxy_ref_ptr<int> >::type, int);
+    STATIC_ASSERT_SAME(boost::pointee<proxy_ref_ptr<X> >::type, X);
+
+    STATIC_ASSERT_SAME(boost::pointee<proxy_ref_ptr<int const> >::type, int const);
+    STATIC_ASSERT_SAME(boost::pointee<proxy_ref_ptr<X const> >::type, X const);
+    
+    STATIC_ASSERT_SAME(boost::pointee<proxy_value_ptr<int> >::type, int const);
+    STATIC_ASSERT_SAME(boost::pointee<proxy_value_ptr<X> >::type, X const);
+    
+    STATIC_ASSERT_SAME(boost::pointee<proxy_value_ptr<int const> >::type, int const);
+    STATIC_ASSERT_SAME(boost::pointee<proxy_value_ptr<X const> >::type, X const);
+
+    STATIC_ASSERT_SAME(boost::pointee<int*>::type, int);
+    STATIC_ASSERT_SAME(boost::pointee<int const*>::type, int const);
+    
+    STATIC_ASSERT_SAME(boost::pointee<X*>::type, X);
+    STATIC_ASSERT_SAME(boost::pointee<X const*>::type, X const);
+
+    STATIC_ASSERT_SAME(boost::pointee<std::auto_ptr<int> >::type, int);
+    STATIC_ASSERT_SAME(boost::pointee<std::auto_ptr<X> >::type, X);
+    
+    STATIC_ASSERT_SAME(boost::pointee<std::auto_ptr<int const> >::type, int const);
+    STATIC_ASSERT_SAME(boost::pointee<std::auto_ptr<X const> >::type, X const);
+
+    STATIC_ASSERT_SAME(boost::pointee<std::list<int>::iterator >::type, int);
+    STATIC_ASSERT_SAME(boost::pointee<std::list<X>::iterator >::type, X);
+    
+    STATIC_ASSERT_SAME(boost::pointee<std::list<int>::const_iterator >::type, int const);
+    STATIC_ASSERT_SAME(boost::pointee<std::list<X>::const_iterator >::type, X const);
+    return 0;
+}