1// (C) Copyright Jeremy Siek 2002.
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#ifndef BOOST_ITERATOR_CONCEPTS_HPP
7#define BOOST_ITERATOR_CONCEPTS_HPP
8
9#include <boost/concept_check.hpp>
10#include <boost/iterator/iterator_categories.hpp>
11
12#include <boost/type_traits/is_same.hpp>
13#include <boost/type_traits/is_integral.hpp>
14
15#include <boost/mpl/bool.hpp>
16#include <boost/mpl/if.hpp>
17#include <boost/mpl/and.hpp>
18#include <boost/mpl/or.hpp>
19
20#include <boost/static_assert.hpp>
21
22// Use boost/limits to work around missing limits headers on some compilers
23#include <boost/limits.hpp>
24#include <boost/config.hpp>
25
26#include <algorithm>
27#include <iterator>
28
29#include <boost/concept/detail/concept_def.hpp>
30
31namespace boost_concepts
32{
33 // Used a different namespace here (instead of "boost") so that the
34 // concept descriptions do not take for granted the names in
35 // namespace boost.
36
37 //===========================================================================
38 // Iterator Access Concepts
39
40 BOOST_concept(ReadableIterator,(Iterator))
41 : boost::Assignable<Iterator>
42 , boost::CopyConstructible<Iterator>
43
44 {
45 typedef BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::value_type value_type;
46 typedef BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::reference reference;
47
48 BOOST_CONCEPT_USAGE(ReadableIterator)
49 {
50
51 value_type v = *i;
52 boost::ignore_unused_variable_warning(v);
53 }
54 private:
55 Iterator i;
56 };
57
58 template <
59 typename Iterator
60 , typename ValueType = BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::value_type
61 >
62 struct WritableIterator
63 : boost::CopyConstructible<Iterator>
64 {
65 BOOST_CONCEPT_USAGE(WritableIterator)
66 {
67 *i = v;
68 }
69 private:
70 ValueType v;
71 Iterator i;
72 };
73
74 template <
75 typename Iterator
76 , typename ValueType = BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::value_type
77 >
78 struct WritableIteratorConcept : WritableIterator<Iterator,ValueType> {};
79
80 BOOST_concept(SwappableIterator,(Iterator))
81 {
82 BOOST_CONCEPT_USAGE(SwappableIterator)
83 {
84 std::iter_swap(i1, i2);
85 }
86 private:
87 Iterator i1;
88 Iterator i2;
89 };
90
91 BOOST_concept(LvalueIterator,(Iterator))
92 {
93 typedef typename std::iterator_traits<Iterator>::value_type value_type;
94
95 BOOST_CONCEPT_USAGE(LvalueIterator)
96 {
97 value_type& r = const_cast<value_type&>(*i);
98 boost::ignore_unused_variable_warning(r);
99 }
100 private:
101 Iterator i;
102 };
103
104
105 //===========================================================================
106 // Iterator Traversal Concepts
107
108 BOOST_concept(IncrementableIterator,(Iterator))
109 : boost::Assignable<Iterator>
110 , boost::CopyConstructible<Iterator>
111 {
112 typedef typename boost::iterator_traversal<Iterator>::type traversal_category;
113
114 BOOST_CONCEPT_ASSERT((
115 boost::Convertible<
116 traversal_category
117 , boost::incrementable_traversal_tag
118 >));
119
120 BOOST_CONCEPT_USAGE(IncrementableIterator)
121 {
122 ++i;
123 (void)i++;
124 }
125 private:
126 Iterator i;
127 };
128
129 BOOST_concept(SinglePassIterator,(Iterator))
130 : IncrementableIterator<Iterator>
131 , boost::EqualityComparable<Iterator>
132
133 {
134 BOOST_CONCEPT_ASSERT((
135 boost::Convertible<
136 BOOST_DEDUCED_TYPENAME SinglePassIterator::traversal_category
137 , boost::single_pass_traversal_tag
138 > ));
139 };
140
141 BOOST_concept(ForwardTraversal,(Iterator))
142 : SinglePassIterator<Iterator>
143 , boost::DefaultConstructible<Iterator>
144 {
145 typedef typename std::iterator_traits<Iterator>::difference_type difference_type;
146
147 BOOST_MPL_ASSERT((boost::is_integral<difference_type>));
148 BOOST_MPL_ASSERT_RELATION(std::numeric_limits<difference_type>::is_signed, ==, true);
149
150 BOOST_CONCEPT_ASSERT((
151 boost::Convertible<
152 BOOST_DEDUCED_TYPENAME ForwardTraversal::traversal_category
153 , boost::forward_traversal_tag
154 > ));
155 };
156
157 BOOST_concept(BidirectionalTraversal,(Iterator))
158 : ForwardTraversal<Iterator>
159 {
160 BOOST_CONCEPT_ASSERT((
161 boost::Convertible<
162 BOOST_DEDUCED_TYPENAME BidirectionalTraversal::traversal_category
163 , boost::bidirectional_traversal_tag
164 > ));
165
166 BOOST_CONCEPT_USAGE(BidirectionalTraversal)
167 {
168 --i;
169 (void)i--;
170 }
171 private:
172 Iterator i;
173 };
174
175 BOOST_concept(RandomAccessTraversal,(Iterator))
176 : BidirectionalTraversal<Iterator>
177 {
178 BOOST_CONCEPT_ASSERT((
179 boost::Convertible<
180 BOOST_DEDUCED_TYPENAME RandomAccessTraversal::traversal_category
181 , boost::random_access_traversal_tag
182 > ));
183
184 BOOST_CONCEPT_USAGE(RandomAccessTraversal)
185 {
186 i += n;
187 i = i + n;
188 i = n + i;
189 i -= n;
190 i = i - n;
191 n = i - j;
192 }
193
194 private:
195 typename BidirectionalTraversal<Iterator>::difference_type n;
196 Iterator i, j;
197 };
198
199 //===========================================================================
200 // Iterator Interoperability
201
202 namespace detail
203 {
204 template <typename Iterator1, typename Iterator2>
205 void interop_single_pass_constraints(Iterator1 const& i1, Iterator2 const& i2)
206 {
207 bool b;
208 b = i1 == i2;
209 b = i1 != i2;
210
211 b = i2 == i1;
212 b = i2 != i1;
213 boost::ignore_unused_variable_warning(b);
214 }
215
216 template <typename Iterator1, typename Iterator2>
217 void interop_rand_access_constraints(
218 Iterator1 const& i1, Iterator2 const& i2,
219 boost::random_access_traversal_tag, boost::random_access_traversal_tag)
220 {
221 bool b;
222 typename std::iterator_traits<Iterator2>::difference_type n;
223 b = i1 < i2;
224 b = i1 <= i2;
225 b = i1 > i2;
226 b = i1 >= i2;
227 n = i1 - i2;
228
229 b = i2 < i1;
230 b = i2 <= i1;
231 b = i2 > i1;
232 b = i2 >= i1;
233 n = i2 - i1;
234 boost::ignore_unused_variable_warning(b);
235 boost::ignore_unused_variable_warning(n);
236 }
237
238 template <typename Iterator1, typename Iterator2>
239 void interop_rand_access_constraints(
240 Iterator1 const&, Iterator2 const&,
241 boost::single_pass_traversal_tag, boost::single_pass_traversal_tag)
242 { }
243
244 } // namespace detail
245
246 BOOST_concept(InteroperableIterator,(Iterator)(ConstIterator))
247 {
248 private:
249 typedef typename boost::iterators::pure_iterator_traversal<Iterator>::type traversal_category;
250 typedef typename boost::iterators::pure_iterator_traversal<ConstIterator>::type const_traversal_category;
251
252 public:
253 BOOST_CONCEPT_ASSERT((SinglePassIterator<Iterator>));
254 BOOST_CONCEPT_ASSERT((SinglePassIterator<ConstIterator>));
255
256 BOOST_CONCEPT_USAGE(InteroperableIterator)
257 {
258 detail::interop_single_pass_constraints(i, ci);
259 detail::interop_rand_access_constraints(i, ci, traversal_category(), const_traversal_category());
260
261 ci = i;
262 }
263
264 private:
265 Iterator i;
266 ConstIterator ci;
267 };
268
269} // namespace boost_concepts
270
271#include <boost/concept/detail/concept_undef.hpp>
272
273#endif // BOOST_ITERATOR_CONCEPTS_HPP
274

source code of include/boost/iterator/iterator_concepts.hpp