1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
|
/*//////////////////////////////////////////////////////////////////////////////
Copyright (c) 2013 Jamboree
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//////////////////////////////////////////////////////////////////////////////*/
#ifndef BOOST_FUSION_FLATTEN_VIEW_ITERATOR_HPP_INCLUDED
#define BOOST_FUSION_FLATTEN_VIEW_ITERATOR_HPP_INCLUDED
#include <boost/mpl/bool.hpp>
#include <boost/mpl/eval_if.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <boost/fusion/container/list/cons.hpp>
#include <boost/fusion/support/unused.hpp>
#include <boost/fusion/include/equal_to.hpp>
#include <boost/fusion/iterator/next.hpp>
#include <boost/fusion/iterator/deref.hpp>
#include <boost/fusion/iterator/value_of.hpp>
namespace boost { namespace fusion
{
struct forward_traversal_tag;
struct flatten_view_iterator_tag;
template<class First, class Base>
struct flatten_view_iterator
: iterator_base<flatten_view_iterator<First, Base> >
{
typedef flatten_view_iterator_tag fusion_tag;
typedef forward_traversal_tag category;
typedef convert_iterator<First> first_converter;
typedef typename first_converter::type first_type;
typedef Base base_type;
flatten_view_iterator(First const& first, Base const& base)
: first(first), base(base)
{}
first_type first;
base_type base;
};
}}
namespace boost { namespace fusion { namespace detail
{
template<class Iterator, class = void>
struct make_descent_cons
{
typedef cons<Iterator> type;
static inline type apply(Iterator const& it)
{
return type(it);
}
};
template<class Iterator>
struct make_descent_cons<Iterator,
typename enable_if<traits::is_sequence<
typename result_of::value_of<Iterator>::type> >::type>
{
// we use 'value_of' above for convenience, assuming the value won't be reference,
// while we must use the regular 'deref' here for const issues...
typedef typename
remove_reference<typename result_of::deref<Iterator>::type>::type
sub_sequence;
typedef typename
result_of::begin<sub_sequence>::type
sub_begin;
typedef cons<Iterator, typename make_descent_cons<sub_begin>::type> type;
static inline type apply(Iterator const& it)
{
return type(it, make_descent_cons<sub_begin>::apply(
fusion::begin(*it)));
}
};
template<class Cons, class Base>
struct build_flatten_view_iterator;
template<class Car, class Base>
struct build_flatten_view_iterator<cons<Car>, Base>
{
typedef flatten_view_iterator<Car, Base> type;
static inline type apply(cons<Car> const& cons, Base const& base)
{
return type(cons.car, base);
}
};
template<class Car, class Cdr, class Base>
struct build_flatten_view_iterator<cons<Car, Cdr>, Base>
{
typedef flatten_view_iterator<Car, Base> next_base;
typedef build_flatten_view_iterator<Cdr, next_base> next;
typedef typename next::type type;
static inline type apply(cons<Car, Cdr> const& cons, Base const& base)
{
return next::apply(cons.cdr, next_base(cons.car, base));
}
};
template<class Base, class Iterator, class = void>
struct seek_descent
{
typedef make_descent_cons<Iterator> make_descent_cons_;
typedef typename make_descent_cons_::type cons_type;
typedef
build_flatten_view_iterator<cons_type, Base>
build_flatten_view_iterator_;
typedef typename build_flatten_view_iterator_::type type;
static inline type apply(Base const& base, Iterator const& it)
{
return build_flatten_view_iterator_::apply(
make_descent_cons_::apply(it), base);
}
};
template<class Base, class Iterator>
struct seek_descent<Base, Iterator,
typename enable_if<
result_of::equal_to<Iterator, typename result_of::end<
typename result_of::value_of<Base>::type>::type> >::type>
{
typedef typename result_of::next<Base>::type type;
static inline type apply(Base const& base, Iterator const&)
{
return fusion::next(base);
}
};
}}}
namespace boost { namespace fusion { namespace extension
{
template<>
struct next_impl<flatten_view_iterator_tag>
{
template<typename Iterator>
struct apply
{
typedef typename Iterator::first_type first_type;
typedef typename Iterator::base_type base_type;
typedef typename result_of::next<first_type>::type next_type;
typedef detail::seek_descent<base_type, next_type> seek_descent;
typedef typename seek_descent::type type;
static inline
type call(Iterator const& it)
{
return seek_descent::apply(it.base, fusion::next(it.first));
}
};
};
template<>
struct deref_impl<flatten_view_iterator_tag>
{
template<typename Iterator>
struct apply
{
typedef typename
result_of::deref<typename Iterator::first_type>::type
type;
static inline
type call(Iterator const& it)
{
return *it.first;
}
};
};
template<>
struct value_of_impl<flatten_view_iterator_tag>
{
template<typename Iterator>
struct apply
{
typedef typename
result_of::value_of<typename Iterator::first_type>::type
type;
};
};
}}}
#endif
|
