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
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
|
/*=============================================================================
Copyright (c) 2001-2011 Hartmut Kaiser
Copyright (c) 2001-2011 Joel de Guzman
Copyright (c) 2010 Bryce Lelbach
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_SPIRIT_ATTRIBUTES_FWD_OCT_01_2009_0715AM)
#define BOOST_SPIRIT_ATTRIBUTES_FWD_OCT_01_2009_0715AM
#if defined(_MSC_VER)
#pragma once
#endif
#include <boost/config.hpp>
#if (defined(__GNUC__) && (__GNUC__ < 4)) || \
(defined(__APPLE__) && defined(__INTEL_COMPILER))
#include <boost/utility/enable_if.hpp>
#endif
#include <boost/spirit/home/support/unused.hpp>
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit { namespace result_of
{
// forward declaration only
template <typename Exposed, typename Attribute>
struct extract_from;
template <typename T, typename Attribute>
struct attribute_as;
template <typename Exposed, typename Transformed, typename Domain>
struct pre_transform;
template <typename T>
struct optional_value;
template <typename Container>
struct begin;
template <typename Container>
struct end;
template <typename Iterator>
struct deref;
}}}
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit { namespace traits
{
///////////////////////////////////////////////////////////////////////////
// Find out if T can be a strong substitute for Expected attribute
///////////////////////////////////////////////////////////////////////////
template <typename T, typename Expected, typename Enable = void>
struct is_substitute;
///////////////////////////////////////////////////////////////////////////
// Find out if T can be a weak substitute for Expected attribute
///////////////////////////////////////////////////////////////////////////
template <typename T, typename Expected, typename Enable = void>
struct is_weak_substitute;
///////////////////////////////////////////////////////////////////////////
// Determine if T is a proxy
///////////////////////////////////////////////////////////////////////////
template <typename T, typename Enable = void>
struct is_proxy;
///////////////////////////////////////////////////////////////////////////
// Retrieve the attribute type to use from the given type
//
// This is needed to extract the correct attribute type from proxy classes
// as utilized in FUSION_ADAPT_ADT et. al.
///////////////////////////////////////////////////////////////////////////
template <typename Attribute, typename Enable = void>
struct attribute_type;
///////////////////////////////////////////////////////////////////////////
// Retrieve the size of a fusion sequence (compile time)
///////////////////////////////////////////////////////////////////////////
template <typename T>
struct sequence_size;
///////////////////////////////////////////////////////////////////////////
// Retrieve the size of an attribute (runtime)
///////////////////////////////////////////////////////////////////////////
template <typename Attribute, typename Enable = void>
struct attribute_size;
template <typename Attribute>
typename attribute_size<Attribute>::type
size(Attribute const& attr);
///////////////////////////////////////////////////////////////////////////
// Determines how we pass attributes to semantic actions. This
// may be specialized. By default, all attributes are wrapped in
// a fusion sequence, because the attribute has to be treated as being
// a single value in any case (even if it actually already is a fusion
// sequence in its own).
///////////////////////////////////////////////////////////////////////////
template <typename Component, typename Attribute, typename Enable = void>
struct pass_attribute;
///////////////////////////////////////////////////////////////////////////
template <typename T, typename Enable = void>
struct optional_attribute;
///////////////////////////////////////////////////////////////////////////
// Sometimes the user needs to transform the attribute types for certain
// attributes. This template can be used as a customization point, where
// the user is able specify specific transformation rules for any attribute
// type.
///////////////////////////////////////////////////////////////////////////
template <typename Exposed, typename Transformed, typename Domain
, typename Enable = void>
struct transform_attribute;
///////////////////////////////////////////////////////////////////////////
// Qi only
template <typename Attribute, typename Iterator, typename Enable = void>
struct assign_to_attribute_from_iterators;
template <typename Iterator, typename Attribute>
void assign_to(Iterator const& first, Iterator const& last, Attribute& attr);
template <typename Iterator>
void assign_to(Iterator const&, Iterator const&, unused_type);
template <typename Attribute, typename T, typename Enable = void>
struct assign_to_attribute_from_value;
template <typename Attribute, typename T, typename Enable = void>
struct assign_to_container_from_value;
template <typename T, typename Attribute>
void assign_to(T const& val, Attribute& attr);
template <typename T>
void assign_to(T const&, unused_type);
///////////////////////////////////////////////////////////////////////////
// Karma only
template <typename Attribute, typename Exposed, typename Enable = void>
struct extract_from_attribute;
template <typename Attribute, typename Exposed, typename Enable = void>
struct extract_from_container;
template <typename Exposed, typename Attribute, typename Context>
typename spirit::result_of::extract_from<Exposed, Attribute>::type
extract_from(Attribute const& attr, Context& ctx
#if (defined(__GNUC__) && (__GNUC__ < 4)) || \
(defined(__APPLE__) && defined(__INTEL_COMPILER))
, typename enable_if<traits::not_is_unused<Attribute> >::type* = NULL
#endif
);
///////////////////////////////////////////////////////////////////////////
// Karma only
template <typename T, typename Attribute, typename Enable = void>
struct attribute_as;
template <typename T, typename Attribute>
typename spirit::result_of::attribute_as<T, Attribute>::type
as(Attribute const& attr);
template <typename T, typename Attribute>
bool valid_as(Attribute const& attr);
///////////////////////////////////////////////////////////////////////////
// return the type currently stored in the given variant
///////////////////////////////////////////////////////////////////////////
template <typename T, typename Enable = void>
struct variant_which;
template <typename T>
int which(T const& v);
///////////////////////////////////////////////////////////////////////////
// Determine, whether T is a variant like type
///////////////////////////////////////////////////////////////////////////
template <typename T, typename Domain = unused_type, typename Enable = void>
struct not_is_variant;
///////////////////////////////////////////////////////////////////////////
// Determine, whether T is a variant like type
///////////////////////////////////////////////////////////////////////////
template <typename T, typename Domain = unused_type, typename Enable = void>
struct not_is_optional;
///////////////////////////////////////////////////////////////////////////
// Clear data efficiently
///////////////////////////////////////////////////////////////////////////
template <typename T, typename Enable = void>
struct clear_value;
///////////////////////////////////////////////////////////////////////
// Determine the value type of the given container type
///////////////////////////////////////////////////////////////////////
template <typename Container, typename Enable = void>
struct container_value;
template <typename Container, typename Enable = void>
struct container_iterator;
template <typename T, typename Enable = void>
struct is_container;
template <typename T, typename Enable = void>
struct is_iterator_range;
///////////////////////////////////////////////////////////////////////////
template <typename T, typename Attribute, typename Context = unused_type
, typename Iterator = unused_type, typename Enable = void>
struct handles_container;
template <typename Container, typename ValueType, typename Attribute
, typename Sequence, typename Domain, typename Enable = void>
struct pass_through_container;
///////////////////////////////////////////////////////////////////////////
// Qi only
template <typename Container, typename T, typename Enable = void>
struct push_back_container;
template <typename Container, typename Enable = void>
struct is_empty_container;
template <typename Container, typename Enable = void>
struct make_container_attribute;
///////////////////////////////////////////////////////////////////////
// Determine the iterator type of the given container type
// Karma only
///////////////////////////////////////////////////////////////////////
template <typename Container, typename Enable = void>
struct begin_container;
template <typename Container, typename Enable = void>
struct end_container;
template <typename Iterator, typename Enable = void>
struct deref_iterator;
template <typename Iterator, typename Enable = void>
struct next_iterator;
template <typename Iterator, typename Enable = void>
struct compare_iterators;
///////////////////////////////////////////////////////////////////////////
// Print the given attribute of type T to the stream given as Out
///////////////////////////////////////////////////////////////////////////
template <typename Out, typename T, typename Enable = void>
struct print_attribute_debug;
template <typename Out, typename T>
void print_attribute(Out&, T const&);
template <typename Out>
void print_attribute(Out&, unused_type);
///////////////////////////////////////////////////////////////////////////
template <typename Char, typename Enable = void>
struct token_printer_debug;
template<typename Out, typename T>
void print_token(Out&, T const&);
///////////////////////////////////////////////////////////////////////////
// Access attributes from a karma symbol table
///////////////////////////////////////////////////////////////////////////
template <typename T, typename Attribute, typename Enable = void>
struct symbols_lookup;
template <typename Attribute, typename T, typename Enable = void>
struct symbols_value;
///////////////////////////////////////////////////////////////////////////
// transform attribute types exposed from compound operator components
///////////////////////////////////////////////////////////////////////////
template <typename Attribute, typename Domain>
struct alternative_attribute_transform;
template <typename Attribute, typename Domain>
struct sequence_attribute_transform;
template <typename Attribute, typename Domain>
struct permutation_attribute_transform;
template <typename Attribute, typename Domain>
struct sequential_or_attribute_transform;
}}}
#endif
|
