Ugly, not-to-be-pushed sucking in of all of Boost to get windows to work.
[dyninst.git] / external / boost / iterator / detail / facade_iterator_category.hpp
1 // Copyright David Abrahams 2003. Use, modification and distribution is
2 // subject to the Boost Software License, Version 1.0. (See accompanying
3 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
4 #ifndef FACADE_ITERATOR_CATEGORY_DWA20031118_HPP
5 # define FACADE_ITERATOR_CATEGORY_DWA20031118_HPP
6
7 # include <boost/iterator/iterator_categories.hpp>
8
9 # include <boost/static_assert.hpp>
10
11 # include <boost/mpl/or.hpp>  // used in iterator_tag inheritance logic
12 # include <boost/mpl/and.hpp>
13 # include <boost/mpl/if.hpp>
14 # include <boost/mpl/eval_if.hpp>
15 # include <boost/mpl/identity.hpp>
16
17 # include <boost/type_traits/is_same.hpp>
18 # include <boost/type_traits/is_const.hpp>
19 # include <boost/type_traits/is_reference.hpp>
20 # include <boost/type_traits/is_convertible.hpp>
21
22 # include <boost/type_traits/is_same.hpp>
23
24 # include <boost/iterator/detail/config_def.hpp> // try to keep this last
25
26 # ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
27 #  include <boost/detail/indirect_traits.hpp>
28 # endif
29
30 //
31 // iterator_category deduction for iterator_facade
32 //
33
34 // forward declaration
35 namespace boost { struct use_default; }
36
37 namespace boost { namespace detail  {
38
39 struct input_output_iterator_tag
40   : std::input_iterator_tag
41 {
42     // Using inheritance for only input_iterator_tag helps to avoid
43     // ambiguities when a stdlib implementation dispatches on a
44     // function which is overloaded on both input_iterator_tag and
45     // output_iterator_tag, as STLPort does, in its __valid_range
46     // function.  I claim it's better to avoid the ambiguity in these
47     // cases.
48     operator std::output_iterator_tag() const
49     {
50         return std::output_iterator_tag();
51     }
52 };
53
54 //
55 // True iff the user has explicitly disabled writability of this
56 // iterator.  Pass the iterator_facade's Value parameter and its
57 // nested ::reference type.
58 //
59 template <class ValueParam, class Reference>
60 struct iterator_writability_disabled
61 # ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY // Adding Thomas' logic?
62   : mpl::or_<
63         is_const<Reference>
64       , boost::detail::indirect_traits::is_reference_to_const<Reference>
65       , is_const<ValueParam>
66     >
67 # else 
68   : is_const<ValueParam>
69 # endif 
70 {};
71
72
73 //
74 // Convert an iterator_facade's traversal category, Value parameter,
75 // and ::reference type to an appropriate old-style category.
76 //
77 // If writability has been disabled per the above metafunction, the
78 // result will not be convertible to output_iterator_tag.
79 //
80 // Otherwise, if Traversal == single_pass_traversal_tag, the following
81 // conditions will result in a tag that is convertible both to
82 // input_iterator_tag and output_iterator_tag:
83 //
84 //    1. Reference is a reference to non-const
85 //    2. Reference is not a reference and is convertible to Value
86 //
87 template <class Traversal, class ValueParam, class Reference>
88 struct iterator_facade_default_category
89   : mpl::eval_if<
90         mpl::and_<
91             is_reference<Reference>
92           , is_convertible<Traversal,forward_traversal_tag>
93         >
94       , mpl::eval_if<
95             is_convertible<Traversal,random_access_traversal_tag>
96           , mpl::identity<std::random_access_iterator_tag>
97           , mpl::if_<
98                 is_convertible<Traversal,bidirectional_traversal_tag>
99               , std::bidirectional_iterator_tag
100               , std::forward_iterator_tag
101             >
102         >
103       , typename mpl::eval_if<
104             mpl::and_<
105                 is_convertible<Traversal, single_pass_traversal_tag>
106                 
107                 // check for readability
108               , is_convertible<Reference, ValueParam>
109             >
110           , mpl::identity<std::input_iterator_tag>
111           , mpl::identity<Traversal>
112         >
113     >
114 {
115 };
116
117 // True iff T is convertible to an old-style iterator category.
118 template <class T>
119 struct is_iterator_category
120   : mpl::or_<
121         is_convertible<T,std::input_iterator_tag>
122       , is_convertible<T,std::output_iterator_tag>
123     >
124 {
125 };
126
127 template <class T>
128 struct is_iterator_traversal
129   : is_convertible<T,incrementable_traversal_tag>
130 {};
131
132 //
133 // A composite iterator_category tag convertible to Category (a pure
134 // old-style category) and Traversal (a pure traversal tag).
135 // Traversal must be a strict increase of the traversal power given by
136 // Category.
137 //
138 template <class Category, class Traversal>
139 struct iterator_category_with_traversal
140   : Category, Traversal
141 {
142 # if 0
143     // Because of limitations on multiple user-defined conversions,
144     // this should be a good test of whether convertibility is enough
145     // in the spec, or whether we need to specify inheritance.
146     operator Category() const { return Category(); }
147     operator Traversal() const { return Traversal(); }
148 # endif
149     
150 # if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
151     // Make sure this isn't used to build any categories where
152     // convertibility to Traversal is redundant.  Should just use the
153     // Category element in that case.
154     BOOST_STATIC_ASSERT(
155         !(is_convertible<
156               typename iterator_category_to_traversal<Category>::type
157             , Traversal
158           >::value));
159
160     BOOST_STATIC_ASSERT(is_iterator_category<Category>::value);
161     BOOST_STATIC_ASSERT(!is_iterator_category<Traversal>::value);
162     BOOST_STATIC_ASSERT(!is_iterator_traversal<Category>::value);
163 #  if !BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
164     BOOST_STATIC_ASSERT(is_iterator_traversal<Traversal>::value);
165 #  endif 
166 # endif 
167 };
168
169 // Computes an iterator_category tag whose traversal is Traversal and
170 // which is appropriate for an iterator
171 template <class Traversal, class ValueParam, class Reference>
172 struct facade_iterator_category_impl
173 {
174 # if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
175     BOOST_STATIC_ASSERT(!is_iterator_category<Traversal>::value);
176 # endif 
177     
178     typedef typename iterator_facade_default_category<
179         Traversal,ValueParam,Reference
180     >::type category;
181     
182     typedef typename mpl::if_<
183         is_same<
184             Traversal
185           , typename iterator_category_to_traversal<category>::type
186         >
187       , category
188       , iterator_category_with_traversal<category,Traversal>
189     >::type type;
190 };
191
192 //
193 // Compute an iterator_category for iterator_facade
194 //
195 template <class CategoryOrTraversal, class ValueParam, class Reference>
196 struct facade_iterator_category
197   : mpl::eval_if<
198         is_iterator_category<CategoryOrTraversal>
199       , mpl::identity<CategoryOrTraversal> // old-style categories are fine as-is
200       , facade_iterator_category_impl<CategoryOrTraversal,ValueParam,Reference>
201     >
202 {
203 };
204
205 }} // namespace boost::detail
206
207 # include <boost/iterator/detail/config_undef.hpp>
208
209 #endif // FACADE_ITERATOR_CATEGORY_DWA20031118_HPP