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