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