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
more_indirect_iterator_tests()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
BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(has_element_type,element_type,true)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 }
221