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
|
/*=============================================================================
Copyright (c) 2005-2013 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
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)
==============================================================================*/
#if !defined(BOOST_FUSION_MAP_ITERATOR_02042013_0835)
#define BOOST_FUSION_MAP_ITERATOR_02042013_0835
#include <boost/fusion/support/config.hpp>
#include <boost/fusion/iterator/iterator_facade.hpp>
#include <boost/mpl/minus.hpp>
#include <boost/mpl/equal_to.hpp>
namespace boost { namespace fusion
{
struct random_access_traversal_tag;
template <typename Seq, int Pos>
struct map_iterator
: iterator_facade<
map_iterator<Seq, Pos>
, typename Seq::category>
{
typedef Seq sequence;
typedef mpl::int_<Pos> index;
BOOST_FUSION_GPU_ENABLED
map_iterator(Seq& seq)
: seq_(seq)
{}
template<typename Iterator>
struct value_of
{
typedef typename Iterator::sequence sequence;
typedef typename Iterator::index index;
typedef
decltype(std::declval<sequence>().get_val(index()))
type;
};
template<typename Iterator>
struct value_of_data
{
typedef typename Iterator::sequence sequence;
typedef typename Iterator::index index;
typedef
decltype(std::declval<sequence>().get_val(index()).second)
type;
};
template<typename Iterator>
struct key_of
{
typedef typename Iterator::sequence sequence;
typedef typename Iterator::index index;
typedef decltype(std::declval<sequence>().get_key(index())) key_identity_type;
typedef typename key_identity_type::type type;
};
template<typename Iterator>
struct deref
{
typedef typename Iterator::sequence sequence;
typedef typename Iterator::index index;
typedef
decltype(std::declval<sequence>().get(index()))
type;
BOOST_FUSION_GPU_ENABLED
static type
call(Iterator const& it)
{
return it.seq_.get(typename Iterator::index());
}
};
template<typename Iterator>
struct deref_data
{
typedef typename Iterator::sequence sequence;
typedef typename Iterator::index index;
typedef
decltype(std::declval<sequence>().get(index()).second)
type;
BOOST_FUSION_GPU_ENABLED
static type
call(Iterator const& it)
{
return it.seq_.get(typename Iterator::index()).second;
}
};
template <typename Iterator, typename N>
struct advance
{
typedef typename Iterator::index index;
typedef typename Iterator::sequence sequence;
typedef map_iterator<sequence, index::value + N::value> type;
BOOST_FUSION_GPU_ENABLED
static type
call(Iterator const& i)
{
return type(i.seq_);
}
};
template<typename Iterator>
struct next
: advance<Iterator, mpl::int_<1> >
{};
template<typename Iterator>
struct prior
: advance<Iterator, mpl::int_<-1> >
{};
template <typename I1, typename I2>
struct distance
{
typedef typename
mpl::minus<
typename I2::index, typename I1::index
>::type
type;
BOOST_FUSION_GPU_ENABLED
static type
call(I1 const&, I2 const&)
{
return type();
}
};
template<typename I1, typename I2>
struct equal_to
: mpl::equal_to<typename I1::index, typename I2::index>
{};
Seq& seq_;
private:
// silence MSVC warning C4512: assignment operator could not be generated
map_iterator& operator= (map_iterator const&);
};
}}
#endif
|
