Moved pointer parameter

[SVN r9348]

iterator_adaptor_test.cpp

@@ -9,6 +9,18 @@
 //  See http://www.boost.org for most recent version including documentation.
 
 //  Revision History
+//  19 Feb 01 Take adavantage of improved iterator_traits to do more tests
+//            on MSVC. Hack around an MSVC-with-STLport internal compiler
+//            error. (David Abrahams)
+//  11 Feb 01 Added test of operator-> for forward and input iterators.
+//            (Jeremy Siek)
+//  11 Feb 01 Borland fixes (David Abrahams)
+//  10 Feb 01 Use new adaptors interface. (David Abrahams)
+//  10 Feb 01 Use new filter_ interface. (David Abrahams)
+//  09 Feb 01 Use new reverse_ and indirect_ interfaces. Replace
+//            BOOST_NO_STD_ITERATOR_TRAITS with
+//            BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION to prove we've
+//            normalized to core compiler capabilities (David Abrahams)
 //  08 Feb 01 Use Jeremy's new make_reverse_iterator form; add more
 //            comprehensive testing. Force-decay array function arguments to
 //            pointers.
@@ -37,6 +49,7 @@
 #include <boost/iterator_adaptors.hpp>
 #include <boost/pending/iterator_tests.hpp>
 #include <boost/pending/integer_range.hpp>
+#include <boost/concept_archetype.hpp>
 #include <stdlib.h>
 #include <vector>
 #include <deque>
@@ -63,10 +76,10 @@ struct my_const_iter_traits {
 };
 
 typedef boost::iterator_adaptor<dummyT*, 
-  boost::default_iterator_policies, my_iter_traits> my_iterator;
+  boost::default_iterator_policies, dummyT> my_iterator;
 
 typedef boost::iterator_adaptor<const dummyT*, 
-  boost::default_iterator_policies, my_const_iter_traits> const_my_iterator;
+  boost::default_iterator_policies, const dummyT> const_my_iterator;
 
 
 struct mult_functor {
@@ -122,8 +135,8 @@ void more_indirect_iterator_tests()
 
     typedef boost::indirect_iterator_pair_generator<
         pointer_deque::iterator
-#ifndef BOOST_NO_STD_ITERATOR_TRAITS
-        , int, int*, int&, const int*, const int&
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+        , int
 #endif
     > IndirectDeque;
 
@@ -149,6 +162,9 @@ void more_indirect_iterator_tests()
 
     typedef boost::indirect_iterator_generator<
         iterator_set::iterator
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+        , int
+#endif
         >::type indirect_set_iterator;
 
     typedef boost::indirect_iterator_generator<
@@ -194,13 +210,14 @@ main()
 
   // Test the iterator_adaptor
   {
-    my_iterator i = array;
+    my_iterator i(array);
     boost::random_access_iterator_test(i, N, array);
     
-    const_my_iterator j = array;
+    const_my_iterator j(array);
     boost::random_access_iterator_test(j, N, array);
     boost::const_nonconst_iterator_test(i, ++j);
   }
+
   // Test transform_iterator
   {
     int x[N], y[N];
@@ -224,41 +241,36 @@ main()
       ptr[k] = array + k;
 
     typedef boost::indirect_iterator_generator<dummyT**
-#ifdef BOOST_NO_STD_ITERATOR_TRAITS
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
         , dummyT
 #endif
       >::type indirect_iterator;
 
     typedef boost::indirect_iterator_generator<dummyT**, const dummyT>::type const_indirect_iterator;
 
-    indirect_iterator i = ptr;
+    indirect_iterator i(ptr);
     boost::random_access_iterator_test(i, N, array);
 
-    typedef boost::iterator<std::random_access_iterator_tag, dummyT> InnerTraits;
-    
-//    boost::random_access_iterator_test(boost::make_indirect_iterator(ptr, InnerTraits()), N, array);
-
-#ifndef BOOST_NO_STD_ITERATOR_TRAITS
-//    boost::random_access_iterator_test(boost::make_indirect_iterator(ptr), N, array);
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+    boost::random_access_iterator_test(boost::make_indirect_iterator(ptr), N, array);
 #endif
     
-    const_indirect_iterator j = ptr;
+    // check operator->
+    assert((*i).m_x == i->foo());
+
+    const_indirect_iterator j(ptr);
     boost::random_access_iterator_test(j, N, array);
 
     dummyT*const* const_ptr = ptr;
     
-    typedef boost::iterator<std::random_access_iterator_tag,dummyT,std::ptrdiff_t,const dummyT*,const dummyT&> ConstInnerTraits;
-//    boost::random_access_iterator_test(boost::make_indirect_iterator(const_ptr, ConstInnerTraits()), N, array);
-
-#ifndef BOOST_NO_STD_ITERATOR_TRAITS
-//    boost::random_access_iterator_test(boost::make_indirect_iterator(const_ptr), N, array);
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+    boost::random_access_iterator_test(boost::make_indirect_iterator(const_ptr), N, array);
 #endif
-
     boost::const_nonconst_iterator_test(i, ++j);
 
     more_indirect_iterator_tests();
   }
-  
+
   // Test projection_iterator_pair_generator
   {    
     typedef std::pair<dummyT,dummyT> Pair;
@@ -270,82 +282,90 @@ main()
       Pair*, const Pair*
       > Projection;
     
-    Projection::iterator i = pair_array;
+    Projection::iterator i(pair_array);
     boost::random_access_iterator_test(i, N, array);
 
     boost::random_access_iterator_test(boost::make_projection_iterator(pair_array, select1st_<Pair>()), N, array);    
     boost::random_access_iterator_test(boost::make_projection_iterator< select1st_<Pair> >(pair_array), N, array);    
 
-    Projection::const_iterator j = pair_array;
+    Projection::const_iterator j(pair_array);
     boost::random_access_iterator_test(j, N, array);
 
     boost::random_access_iterator_test(boost::make_const_projection_iterator(pair_array, select1st_<Pair>()), N, array);
-    boost::random_access_iterator_test(boost::make_const_projection_iterator< select1st_<Pair> >(pair_array), N, array);
+    boost::random_access_iterator_test(boost::make_const_projection_iterator<select1st_<Pair> >(pair_array), N, array);
 
     boost::const_nonconst_iterator_test(i, ++j);
   }
+
   // Test reverse_iterator_generator
   {
     dummyT reversed[N];
     std::copy(array, array + N, reversed);
     std::reverse(reversed, reversed + N);
     
-    typedef boost::reverse_iterator_generator<dummyT*, 
-      boost::iterator<std::random_access_iterator_tag,dummyT>
+    typedef boost::reverse_iterator_generator<dummyT*
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+        , dummyT
+#endif
       >::type reverse_iterator;
-    typedef boost::reverse_iterator_generator<const dummyT*,
-      boost::iterator<std::random_access_iterator_tag,const dummyT>
-      >::type const_reverse_iterator;
-    reverse_iterator i = reversed + N;
+    
+    reverse_iterator i(reversed + N);
     boost::random_access_iterator_test(i, N, array);
 
-    typedef boost::iterator<std::random_access_iterator_tag,dummyT> ReverseTraits;
-    boost::random_access_iterator_test(boost::make_reverse_iterator<ReverseTraits>(reversed + N), N, array);
-#ifndef BOOST_NO_STD_ITERATOR_TRAITS
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
     boost::random_access_iterator_test(boost::make_reverse_iterator(reversed + N), N, array);
 #endif
 
-    const_reverse_iterator j = reversed + N;
+    typedef boost::reverse_iterator_generator<const dummyT*
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+        , const dummyT
+#endif
+      >::type const_reverse_iterator;
+    
+    const_reverse_iterator j(reversed + N);
     boost::random_access_iterator_test(j, N, array);
 
     const dummyT* const_reversed = reversed;
-    typedef boost::iterator<std::random_access_iterator_tag,const dummyT> ConstReverseTraits;
-    boost::random_access_iterator_test(boost::make_reverse_iterator<ConstReverseTraits>(const_reversed + N), N, array);
-#ifndef BOOST_NO_STD_ITERATOR_TRAITS
+    
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
     boost::random_access_iterator_test(boost::make_reverse_iterator(const_reversed + N), N, array);
 #endif
-
+    
     boost::const_nonconst_iterator_test(i, ++j);    
   }
 
-  // Test reverse_iterator_generator again, with traits fully deducible on most platforms
-#if !defined(BOOST_MSVC) || defined(__SGI_STL_PORT)
+  // Test reverse_iterator_generator again, with traits fully deducible on all platforms
   {
     std::deque<dummyT> reversed_container;
-    std::copy(array, array + N, std::back_inserter(reversed_container));
+    std::reverse_copy(array, array + N, std::back_inserter(reversed_container));
     const std::deque<dummyT>::iterator reversed = reversed_container.begin();
-    std::reverse(reversed, reversed + N);
-    
+
+
     typedef boost::reverse_iterator_generator<
         std::deque<dummyT>::iterator>::type reverse_iterator;
     typedef boost::reverse_iterator_generator<
-        std::deque<dummyT>::const_iterator>::type const_reverse_iterator;
+        std::deque<dummyT>::const_iterator, const dummyT>::type const_reverse_iterator;
 
-    reverse_iterator i = reversed + N;
+    // MSVC/STLport gives an INTERNAL COMPILER ERROR when any computation
+    // (e.g. "reversed + N") is used in the constructor below.
+    const std::deque<dummyT>::iterator finish = reversed_container.end();
+    reverse_iterator i(finish);
+    
     boost::random_access_iterator_test(i, N, array);
     boost::random_access_iterator_test(boost::make_reverse_iterator(reversed + N), N, array);
 
-    const_reverse_iterator j = reverse_iterator(reversed + N);
+    const_reverse_iterator j = reverse_iterator(finish);
     boost::random_access_iterator_test(j, N, array);
 
     const std::deque<dummyT>::const_iterator const_reversed = reversed;
     boost::random_access_iterator_test(boost::make_reverse_iterator(const_reversed + N), N, array);
-
-#if !defined(__GNUC__) || defined(__SGI_STL_PORT)  // GCC deque iterators don't allow all const/non-const comparisons
+    
+    // Many compilers' builtin deque iterators don't interoperate well, though
+    // STLport fixes that problem.
+#if defined(__SGI_STL_PORT) || !defined(__GNUC__) && !defined(__BORLANDC__) && !defined(BOOST_MSVC)
     boost::const_nonconst_iterator_test(i, ++j);
 #endif
   }
-#endif
   
   // Test integer_range's iterators
   {
@@ -356,31 +376,88 @@ main()
 
   // Test filter iterator
   {
-    typedef boost::filter_iterator_generator<one_or_four, dummyT*,
-      boost::iterator<std::forward_iterator_tag, dummyT, std::ptrdiff_t,
-      dummyT*, dummyT&> > FilterGen;
-    typedef FilterGen::type FilterIter;
-    typedef FilterGen::policies_type FilterPolicies;
-    FilterIter i(array, FilterPolicies(one_or_four(), array + N));
+    // Using typedefs for filter_gen::type and filter_gen::policies_type
+    // confused Borland terribly.
+    typedef boost::detail::non_bidirectional_category<dummyT*>::type category;
+    
+    typedef ::boost::filter_iterator_generator<one_or_four, dummyT*
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+        , dummyT
+#endif
+        > filter_iter_gen;
+
+#ifndef __BORLANDC__
+    typedef filter_iter_gen::type filter_iter;
+#else
+# define filter_iter filter_iter_gen::type // Borland has a problem with the above
+#endif
+    filter_iter i(array, filter_iter::policies_type(one_or_four(), array + N));
     boost::forward_iterator_test(i, dummyT(1), dummyT(4));
 
-    typedef boost::iterator<std::forward_iterator_tag, dummyT, std::ptrdiff_t, dummyT*, dummyT&> FilterTraits;
-    boost::forward_iterator_test(boost::make_filter_iterator<FilterTraits>
-       (array, array + N, one_or_four() ), dummyT(1), dummyT(4));
+    enum { is_forward = boost::is_same<
+           filter_iter::iterator_category,
+           std::forward_iterator_tag>::value };
+    BOOST_STATIC_ASSERT(is_forward);
 
-    boost::forward_iterator_test(boost::make_filter_iterator<FilterTraits, one_or_four>
-        (array, array + N), dummyT(1), dummyT(4));
+    // On compilers not supporting partial specialization, we can do more type
+    // deduction with deque iterators than with pointers... unless the library
+    // is broken ;-(
+#if !defined(BOOST_MSVC) || defined(__SGI_STL_PORT)
+    std::deque<dummyT> array2;
+    std::copy(array+0, array+N, std::back_inserter(array2));
+    boost::forward_iterator_test(
+        boost::make_filter_iterator(array2.begin(), array2.end(), one_or_four()),
+        dummyT(1), dummyT(4));
 
-#ifndef BOOST_NO_STD_ITERATOR_TRAITS
-    boost::forward_iterator_test(boost::make_filter_iterator(
-        array, array + N, one_or_four()), dummyT(1), dummyT(4));
+    boost::forward_iterator_test(
+        boost::make_filter_iterator<one_or_four>(array2.begin(), array2.end()),
+        dummyT(1), dummyT(4));
+#endif
 
-    boost::forward_iterator_test(boost::make_filter_iterator<one_or_four>(
-        array, array + N), dummyT(1), dummyT(4));
+#if !defined(BOOST_MSVC) // This just freaks MSVC out completely
+    boost::forward_iterator_test(
+        boost::make_filter_iterator<one_or_four>(
+            boost::make_reverse_iterator(array2.end()),
+            boost::make_reverse_iterator(array2.begin())
+            ),
+        dummyT(4), dummyT(1));
 #endif
     
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+    boost::forward_iterator_test(
+        boost::make_filter_iterator(array+0, array+N, one_or_four()),
+        dummyT(1), dummyT(4));
 
+    boost::forward_iterator_test(
+        boost::make_filter_iterator<one_or_four>(array, array + N),
+        dummyT(1), dummyT(4));
+
+#endif
   }
+
+  // check operator-> with a forward iterator
+  {
+    boost::forward_iterator_archetype<dummyT> forward_iter;
+    typedef boost::iterator_adaptor<boost::forward_iterator_archetype<dummyT>,
+      boost::default_iterator_policies,
+      dummyT, const dummyT&, 
+      std::forward_iterator_tag, std::ptrdiff_t, const dummyT*> adaptor_type;
+    adaptor_type i(forward_iter);
+    if (0) // don't do this, just make sure it compiles
+      assert((*i).m_x == i->foo());      
+  }
+  // check operator-> with an input iterator
+  {
+    boost::input_iterator_archetype<dummyT> input_iter;
+    typedef boost::iterator_adaptor<boost::input_iterator_archetype<dummyT>,
+      boost::default_iterator_policies,
+      dummyT, const dummyT&, 
+      std::input_iterator_tag, std::ptrdiff_t, const dummyT*> adaptor_type;
+    adaptor_type i(input_iter);
+    if (0) // don't do this, just make sure it compiles
+      assert((*i).m_x == i->foo());      
+  }
+
   std::cout << "test successful " << std::endl;
   return 0;
 }