← Back to branch summary

~ubuntu-branches/ubuntu/wily/davix/wily

« back to all changes in this revision

Viewing changes to deps/boost_intern/boost/iterator/detail/facade_iterator_category.hpp

  • Committer: Package Import Robot
  • Author(s): Mattias Ellert
  • Date: 2015-07-31 13:17:55 UTC
  • mfrom: (5.1.3 sid)
  • Revision ID: package-import@ubuntu.com-20150731131755-mizprbmn7ogv33te
Tags: 0.4.1-1
* Update to version 0.4.1
* Implement Multi-Arch support

Show diffs side-by-side

added added

removed removed

Lines of Context:
deps/boost_intern/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/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