ceph/src/boost/libs/iterator/test/indirect_iterator_test.cpp

   1 //  (C) Copyright Jeremy Siek 1999.
   2 // Distributed under the Boost Software License, Version 1.0. (See
   3 // accompanying file LICENSE_1_0.txt or copy at
   4 // http://www.boost.org/LICENSE_1_0.txt)
   5
   6 //  Revision History
   7 //  22 Nov 2002 Thomas Witt
   8 //       Added interoperability check.
   9 //  08 Mar 2001   Jeremy Siek
  10 //       Moved test of indirect iterator into its own file. It to
  11 //       to be in iterator_adaptor_test.cpp.
  12
  13 #include <boost/config.hpp>
  14 #include <iostream>
  15 #include <algorithm>
  16
  17 #include <boost/iterator/indirect_iterator.hpp>
  18 #include <boost/iterator/iterator_concepts.hpp>
  19 #include <boost/iterator/new_iterator_tests.hpp>
  20
  21 #include <boost/detail/workaround.hpp>
  22
  23 #include <boost/concept_archetype.hpp>
  24 #include <boost/concept_check.hpp>
  25 #include <boost/shared_ptr.hpp>
  26 #include <boost/utility.hpp>
  27 #include <boost/next_prior.hpp>
  28
  29 #include <boost/mpl/has_xxx.hpp>
  30
  31 #include <boost/detail/lightweight_test.hpp>
  32
  33 #include <vector>
  34 #include <stdlib.h>
  35 #include <set>
  36 #include <iterator>
  37
  38 #if !defined(__SGI_STL_PORT)                            \
  39     && (defined(BOOST_MSVC_STD_ITERATOR)                \
  40         || BOOST_WORKAROUND(_CPPLIB_VER, <= 310)        \
  41         || BOOST_WORKAROUND(__GNUC__, <= 2))
  42
  43 // std container random-access iterators don't support mutable/const
  44 // interoperability (but may support const/mutable interop).
  45 # define NO_MUTABLE_CONST_STD_SET_ITERATOR_INTEROPERABILITY
  46
  47 #endif
  48
  49
  50 template <class T> struct see_type;
  51 template <int I> struct see_val;
  52
  53 struct my_iterator_tag : public std::random_access_iterator_tag { };
  54
  55 using boost::dummyT;
  56
  57 typedef std::vector<int> storage;
  58 typedef std::vector<int*> pointer_ra_container;
  59 typedef std::set<storage::iterator> iterator_set;
  60
  61 template <class Container>
  62 struct indirect_iterator_pair_generator
  63 {
  64     typedef boost::indirect_iterator<typename Container::iterator> iterator;
  65
  66     typedef boost::indirect_iterator<
  67         typename Container::iterator
  68       , typename iterator::value_type const
  69     > const_iterator;
  70 };
  71
  72 void more_indirect_iterator_tests()
  73 {
  74     storage store(1000);
  75     std::generate(store.begin(), store.end(), rand);
  76
  77     pointer_ra_container ptr_ra_container;
  78     iterator_set iter_set;
  79
  80     for (storage::iterator p = store.begin(); p != store.end(); ++p)
  81     {
  82         ptr_ra_container.push_back(&*p);
  83         iter_set.insert(p);
  84     }
  85
  86     typedef indirect_iterator_pair_generator<pointer_ra_container> indirect_ra_container;
  87
  88     indirect_ra_container::iterator db(ptr_ra_container.begin());
  89     indirect_ra_container::iterator de(ptr_ra_container.end());
  90     BOOST_TEST(static_cast<std::size_t>(de - db) == store.size());
  91     BOOST_TEST(db + store.size() == de);
  92     indirect_ra_container::const_iterator dci = db;
  93
  94     BOOST_TEST(dci == db);
  95
  96 #ifndef NO_MUTABLE_CONST_RA_ITERATOR_INTEROPERABILITY
  97     BOOST_TEST(db == dci);
  98 #endif
  99
 100     BOOST_TEST(dci != de);
 101     BOOST_TEST(dci < de);
 102     BOOST_TEST(dci <= de);
 103
 104 #ifndef NO_MUTABLE_CONST_RA_ITERATOR_INTEROPERABILITY
 105     BOOST_TEST(de >= dci);
 106     BOOST_TEST(de > dci);
 107 #endif
 108
 109     dci = de;
 110     BOOST_TEST(dci == de);
 111
 112     boost::random_access_iterator_test(db + 1, store.size() - 1, boost::next(store.begin()));
 113
 114     *db = 999;
 115     BOOST_TEST(store.front() == 999);
 116
 117     // Borland C++ is getting very confused about the typedefs here
 118     typedef boost::indirect_iterator<iterator_set::iterator> indirect_set_iterator;
 119     typedef boost::indirect_iterator<
 120         iterator_set::iterator
 121       , iterator_set::iterator::value_type const
 122     > const_indirect_set_iterator;
 123
 124     indirect_set_iterator sb(iter_set.begin());
 125     indirect_set_iterator se(iter_set.end());
 126     const_indirect_set_iterator sci(iter_set.begin());
 127     BOOST_TEST(sci == sb);
 128
 129 # ifndef NO_MUTABLE_CONST_STD_SET_ITERATOR_INTEROPERABILITY
 130     BOOST_TEST(se != sci);
 131 # endif
 132
 133     BOOST_TEST(sci != se);
 134     sci = se;
 135     BOOST_TEST(sci == se);
 136
 137     *boost::prior(se) = 888;
 138     BOOST_TEST(store.back() == 888);
 139     BOOST_TEST(std::equal(sb, se, store.begin()));
 140
 141     boost::bidirectional_iterator_test(boost::next(sb), store[1], store[2]);
 142     BOOST_TEST(std::equal(db, de, store.begin()));
 143 }
 144
 145 // element_type detector; defaults to true so the test passes when
 146 // has_xxx isn't implemented
 147 BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(has_element_type, element_type, true)
 148
 149 int
 150 main()
 151 {
 152   dummyT array[] = { dummyT(0), dummyT(1), dummyT(2),
 153                      dummyT(3), dummyT(4), dummyT(5) };
 154   const int N = sizeof(array)/sizeof(dummyT);
 155
 156 # if BOOST_WORKAROUND(BOOST_MSVC, == 1200)
 157   boost::shared_ptr<dummyT> zz((dummyT*)0);  // Why? I don't know, but it suppresses a bad instantiation.
 158 # endif
 159
 160   typedef std::vector<boost::shared_ptr<dummyT> > shared_t;
 161   shared_t shared;
 162
 163   // Concept checks
 164   {
 165     typedef boost::indirect_iterator<shared_t::iterator> iter_t;
 166
 167     BOOST_STATIC_ASSERT(
 168         has_element_type<
 169             std::iterator_traits<shared_t::iterator>::value_type
 170         >::value
 171         );
 172
 173     typedef boost::indirect_iterator<
 174         shared_t::iterator
 175       , boost::iterator_value<shared_t::iterator>::type const
 176     > c_iter_t;
 177
 178 # ifndef NO_MUTABLE_CONST_RA_ITERATOR_INTEROPERABILITY
 179     boost::function_requires< boost_concepts::InteroperableIteratorConcept<iter_t, c_iter_t> >();
 180 # endif
 181   }
 182
 183   // Test indirect_iterator_generator
 184   {
 185       for (int jj = 0; jj < N; ++jj)
 186           shared.push_back(boost::shared_ptr<dummyT>(new dummyT(jj)));
 187
 188       dummyT* ptr[N];
 189       for (int k = 0; k < N; ++k)
 190           ptr[k] = array + k;
 191
 192       typedef boost::indirect_iterator<dummyT**> indirect_iterator;
 193
 194       typedef boost::indirect_iterator<dummyT**, dummyT const>
 195           const_indirect_iterator;
 196
 197       indirect_iterator i(ptr);
 198       boost::random_access_iterator_test(i, N, array);
 199
 200       boost::random_access_iterator_test(
 201           boost::indirect_iterator<shared_t::iterator>(shared.begin())
 202           , N, array);
 203
 204       boost::random_access_iterator_test(boost::make_indirect_iterator(ptr), N, array);
 205
 206       // check operator->
 207       assert((*i).m_x == i->foo());
 208
 209       const_indirect_iterator j(ptr);
 210       boost::random_access_iterator_test(j, N, array);
 211
 212       dummyT const*const* const_ptr = ptr;
 213       boost::random_access_iterator_test(boost::make_indirect_iterator(const_ptr), N, array);
 214
 215       boost::const_nonconst_iterator_test(i, ++j);
 216
 217       more_indirect_iterator_tests();
 218   }
 219   return boost::report_errors();
 220 }