Line data Source code
1 : // (C) Copyright David Abrahams 2002.
2 : // (C) Copyright Jeremy Siek 2002.
3 : // (C) Copyright Thomas Witt 2002.
4 : // Distributed under the Boost Software License, Version 1.0. (See
5 : // accompanying file LICENSE_1_0.txt or copy at
6 : // http://www.boost.org/LICENSE_1_0.txt)
7 : #ifndef BOOST_ITERATOR_ADAPTOR_23022003THW_HPP
8 : #define BOOST_ITERATOR_ADAPTOR_23022003THW_HPP
9 :
10 : #include <type_traits>
11 :
12 : #include <boost/core/use_default.hpp>
13 :
14 : #include <boost/iterator/iterator_categories.hpp>
15 : #include <boost/iterator/iterator_facade.hpp>
16 : #include <boost/iterator/iterator_traits.hpp>
17 : #include <boost/iterator/enable_if_convertible.hpp> // for backward compatibility; remove once downstream users are updated
18 : #include <boost/iterator/detail/eval_if_default.hpp>
19 :
20 : #include <boost/iterator/detail/config_def.hpp>
21 :
22 : namespace boost {
23 : namespace iterators {
24 :
25 : // Used as a default template argument internally, merely to
26 : // indicate "use the default", this can also be passed by users
27 : // explicitly in order to specify that the default should be used.
28 : using boost::use_default;
29 :
30 : namespace detail {
31 :
32 : // A metafunction which computes an iterator_adaptor's base class,
33 : // a specialization of iterator_facade.
34 : template<
35 : typename Derived,
36 : typename Base,
37 : typename Value,
38 : typename Traversal,
39 : typename Reference,
40 : typename Difference
41 : >
42 : using iterator_adaptor_base_t = iterator_facade<
43 : Derived,
44 :
45 : #ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
46 : detail::eval_if_default_t<
47 : Value,
48 : detail::eval_if_default<
49 : Reference,
50 : iterator_value< Base >,
51 : std::remove_reference< Reference >
52 : >
53 : >,
54 : #else
55 : detail::eval_if_default_t<
56 : Value,
57 : iterator_value< Base >
58 : >,
59 : #endif
60 :
61 : detail::eval_if_default_t<
62 : Traversal,
63 : iterator_traversal< Base >
64 : >,
65 :
66 : detail::eval_if_default_t<
67 : Reference,
68 : detail::eval_if_default<
69 : Value,
70 : iterator_reference< Base >,
71 : std::add_lvalue_reference< Value >
72 : >
73 : >,
74 :
75 : detail::eval_if_default_t<
76 : Difference,
77 : iterator_difference< Base >
78 : >
79 : >;
80 :
81 : } // namespace detail
82 :
83 : //
84 : // Iterator Adaptor
85 : //
86 : // The parameter ordering changed slightly with respect to former
87 : // versions of iterator_adaptor The idea is that when the user needs
88 : // to fiddle with the reference type it is highly likely that the
89 : // iterator category has to be adjusted as well. Any of the
90 : // following four template arguments may be omitted or explicitly
91 : // replaced by use_default.
92 : //
93 : // Value - if supplied, the value_type of the resulting iterator, unless
94 : // const. If const, a conforming compiler strips constness for the
95 : // value_type. If not supplied, iterator_traits<Base>::value_type is used
96 : //
97 : // Category - the traversal category of the resulting iterator. If not
98 : // supplied, iterator_traversal<Base>::type is used.
99 : //
100 : // Reference - the reference type of the resulting iterator, and in
101 : // particular, the result type of operator*(). If not supplied but
102 : // Value is supplied, Value& is used. Otherwise
103 : // iterator_traits<Base>::reference is used.
104 : //
105 : // Difference - the difference_type of the resulting iterator. If not
106 : // supplied, iterator_traits<Base>::difference_type is used.
107 : //
108 : template<
109 : typename Derived,
110 : typename Base,
111 : typename Value = use_default,
112 : typename Traversal = use_default,
113 : typename Reference = use_default,
114 : typename Difference = use_default
115 : >
116 : class iterator_adaptor :
117 : public detail::iterator_adaptor_base_t<
118 : Derived, Base, Value, Traversal, Reference, Difference
119 : >
120 : {
121 : friend class iterator_core_access;
122 :
123 : protected:
124 : using super_t = detail::iterator_adaptor_base_t<
125 : Derived, Base, Value, Traversal, Reference, Difference
126 : >;
127 :
128 : public:
129 : using base_type = Base;
130 :
131 : iterator_adaptor() = default;
132 :
133 629 : explicit iterator_adaptor(Base const& iter) :
134 629 : m_iterator(iter)
135 : {
136 629 : }
137 :
138 1676 : base_type const& base() const { return m_iterator; }
139 :
140 : protected:
141 : // for convenience in derived classes
142 : using iterator_adaptor_ = iterator_adaptor< Derived, Base, Value, Traversal, Reference, Difference >;
143 :
144 : //
145 : // lvalue access to the Base object for Derived
146 : //
147 387 : Base& base_reference() { return m_iterator; }
148 774 : Base const& base_reference() const { return m_iterator; }
149 :
150 : private:
151 : //
152 : // Core iterator interface for iterator_facade. This is private
153 : // to prevent temptation for Derived classes to use it, which
154 : // will often result in an error. Derived classes should use
155 : // base_reference(), above, to get direct access to m_iterator.
156 : //
157 : typename super_t::reference dereference() const { return *m_iterator; }
158 :
159 : template< typename OtherDerived, typename OtherIterator, typename V, typename C, typename R, typename D >
160 1092 : bool equal(iterator_adaptor< OtherDerived, OtherIterator, V, C, R, D > const& x) const
161 : {
162 : // Maybe readd with same_distance
163 : // BOOST_STATIC_ASSERT(
164 : // (detail::same_category_and_difference<Derived,OtherDerived>::value)
165 : // );
166 1092 : return m_iterator == x.base();
167 : }
168 :
169 : using my_traversal = typename iterator_category_to_traversal< typename super_t::iterator_category >::type;
170 :
171 : void advance(typename super_t::difference_type n)
172 : {
173 : static_assert(detail::is_traversal_at_least< my_traversal, random_access_traversal_tag >::value,
174 : "Iterator must support random access traversal.");
175 : m_iterator += n;
176 : }
177 :
178 584 : void increment() { ++m_iterator; }
179 :
180 : void decrement()
181 : {
182 : static_assert(detail::is_traversal_at_least< my_traversal, bidirectional_traversal_tag >::value,
183 : "Iterator must support bidirectional traversal.");
184 : --m_iterator;
185 : }
186 :
187 : template< typename OtherDerived, typename OtherIterator, typename V, typename C, typename R, typename D >
188 : typename super_t::difference_type distance_to(iterator_adaptor< OtherDerived, OtherIterator, V, C, R, D > const& y) const
189 : {
190 : static_assert(detail::is_traversal_at_least< my_traversal, random_access_traversal_tag >::value,
191 : "Super iterator must support random access traversal.");
192 : // Maybe readd with same_distance
193 : // BOOST_STATIC_ASSERT(
194 : // (detail::same_category_and_difference<Derived,OtherDerived>::value)
195 : // );
196 : return y.base() - m_iterator;
197 : }
198 :
199 : private: // data members
200 : Base m_iterator;
201 : };
202 :
203 : } // namespace iterators
204 :
205 : using iterators::iterator_adaptor;
206 :
207 : } // namespace boost
208 :
209 : #include <boost/iterator/detail/config_undef.hpp>
210 :
211 : #endif // BOOST_ITERATOR_ADAPTOR_23022003THW_HPP
|
