]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | /*============================================================================= |
2 | Copyright (c) 2001-2003 Joel de Guzman | |
3 | Copyright (c) 2002-2003 Hartmut Kaiser | |
4 | http://spirit.sourceforge.net/ | |
5 | ||
6 | Distributed under the Boost Software License, Version 1.0. (See accompanying | |
7 | file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) | |
8 | =============================================================================*/ | |
9 | #ifndef BOOST_SPIRIT_CLOSURE_HPP | |
10 | #define BOOST_SPIRIT_CLOSURE_HPP | |
11 | ||
12 | /////////////////////////////////////////////////////////////////////////////// | |
13 | #include <boost/spirit/home/classic/namespace.hpp> | |
14 | #include <boost/spirit/home/classic/core/parser.hpp> | |
15 | #include <boost/spirit/home/classic/core/composite/composite.hpp> | |
16 | #include <boost/spirit/home/classic/core/non_terminal/parser_context.hpp> | |
17 | #include <boost/spirit/home/classic/attribute/parametric.hpp> | |
18 | #include <boost/spirit/home/classic/attribute/closure_context.hpp> | |
19 | #include <boost/spirit/home/classic/attribute/closure_fwd.hpp> | |
20 | ||
21 | #include <boost/spirit/home/classic/phoenix/closures.hpp> | |
22 | #include <boost/spirit/home/classic/phoenix/primitives.hpp> | |
23 | #include <boost/spirit/home/classic/phoenix/casts.hpp> | |
24 | #include <boost/spirit/home/classic/phoenix/operators.hpp> | |
25 | #include <boost/spirit/home/classic/phoenix/tuple_helpers.hpp> | |
26 | ||
27 | #include <boost/static_assert.hpp> | |
28 | ||
29 | /////////////////////////////////////////////////////////////////////////////// | |
30 | // | |
31 | // Spirit predefined maximum closure limit. This limit defines the maximum | |
32 | // number of elements a closure can hold. This number defaults to 3. The | |
33 | // actual maximum is rounded up in multiples of 3. Thus, if this value | |
34 | // is 4, the actual limit is 6. The ultimate maximum limit in this | |
35 | // implementation is 15. | |
36 | // | |
37 | // It should NOT be greater than PHOENIX_LIMIT! | |
38 | // | |
39 | /////////////////////////////////////////////////////////////////////////////// | |
40 | ||
41 | #if !defined(BOOST_SPIRIT_CLOSURE_LIMIT) | |
42 | #define BOOST_SPIRIT_CLOSURE_LIMIT PHOENIX_LIMIT | |
43 | #endif | |
44 | ||
45 | /////////////////////////////////////////////////////////////////////////////// | |
46 | // | |
47 | // ensure BOOST_SPIRIT_CLOSURE_LIMIT <= PHOENIX_LIMIT and SPIRIT_CLOSURE_LIMIT <= 15 | |
48 | // | |
49 | /////////////////////////////////////////////////////////////////////////////// | |
50 | BOOST_STATIC_ASSERT(BOOST_SPIRIT_CLOSURE_LIMIT <= PHOENIX_LIMIT); | |
51 | BOOST_STATIC_ASSERT(BOOST_SPIRIT_CLOSURE_LIMIT <= 15); | |
52 | ||
53 | /////////////////////////////////////////////////////////////////////////////// | |
54 | namespace boost { namespace spirit { | |
55 | ||
56 | BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN | |
57 | ||
58 | /////////////////////////////////////////////////////////////////////////// | |
59 | // | |
60 | // closure_context class | |
61 | // | |
62 | /////////////////////////////////////////////////////////////////////////// | |
63 | template <typename ClosureT> | |
64 | class closure_context : public parser_context_base | |
65 | { | |
66 | public: | |
67 | ||
68 | typedef typename ::phoenix::tuple_element<0, | |
69 | typename ClosureT::tuple_t>::type attr_t; | |
70 | typedef ClosureT base_t; | |
71 | typedef closure_context_linker<closure_context<ClosureT> > | |
72 | context_linker_t; | |
73 | ||
74 | closure_context(ClosureT const& clos) | |
75 | : frame(clos) {} | |
76 | ||
77 | ~closure_context() {} | |
78 | ||
79 | template <typename ParserT, typename ScannerT> | |
80 | void pre_parse(ParserT const&, ScannerT const&) {} | |
81 | ||
82 | template <typename ResultT, typename ParserT, typename ScannerT> | |
83 | ResultT& post_parse(ResultT& hit, ParserT const&, ScannerT const&) | |
84 | { hit.value(frame[::phoenix::tuple_index<0>()]); return hit; } | |
85 | ||
86 | private: | |
87 | ||
88 | ::phoenix::closure_frame<typename ClosureT::phoenix_closure_t> frame; | |
89 | }; | |
90 | ||
91 | /////////////////////////////////////////////////////////////////////////// | |
92 | // | |
93 | // init_closure_context class | |
94 | // | |
95 | // The init_closure_context class is a special parser context type | |
96 | // which additionally initializes a closure contained in the derived | |
97 | // parser with values from a given tuple. Please note, that this | |
98 | // given tuple does not contain the required values directly, it | |
99 | // contains phoenix::actor objects. These actors have to be | |
100 | // dereferenced to gain the values to be used for initialization | |
101 | // (this is done by the help of the phoenix::convert_actors<> | |
102 | // template). | |
103 | // | |
104 | /////////////////////////////////////////////////////////////////////////// | |
105 | ||
106 | template <typename ClosureT> | |
107 | class init_closure_context : public parser_context_base | |
108 | { | |
109 | typedef typename ClosureT::tuple_t tuple_t; | |
110 | typedef typename ClosureT::closure_t closure_t; | |
111 | ||
112 | public: | |
113 | ||
114 | init_closure_context(ClosureT const& clos) | |
115 | : frame(clos.subject(), ::phoenix::convert_actors<tuple_t>(clos.init)) {} | |
116 | ||
117 | ~init_closure_context() {} | |
118 | ||
119 | template <typename ParserT, typename ScannerT> | |
120 | void pre_parse(ParserT const& /*p*/, ScannerT const&) {} | |
121 | ||
122 | template <typename ResultT, typename ParserT, typename ScannerT> | |
123 | ResultT& post_parse(ResultT& hit, ParserT const&, ScannerT const&) | |
124 | { hit.value(frame[::phoenix::tuple_index<0>()]); return hit; } | |
125 | ||
126 | private: | |
127 | ||
128 | ::phoenix::closure_frame<closure_t> frame; | |
129 | }; | |
130 | ||
131 | /////////////////////////////////////////////////////////////////////////// | |
132 | // | |
133 | // init_closure_parser class | |
134 | // | |
135 | /////////////////////////////////////////////////////////////////////////// | |
136 | template <typename ParserT, typename ActorTupleT> | |
137 | struct init_closure_parser | |
138 | : public unary<ParserT, parser<init_closure_parser<ParserT, ActorTupleT> > > | |
139 | { | |
140 | typedef init_closure_parser<ParserT, ActorTupleT> self_t; | |
141 | typedef unary<ParserT, parser<self_t> > base_t; | |
142 | typedef typename ParserT::phoenix_closure_t closure_t; | |
143 | typedef typename ParserT::tuple_t tuple_t; | |
144 | typedef typename ::phoenix::tuple_element<0, tuple_t>::type attr_t; | |
145 | ||
146 | template <typename ScannerT> | |
147 | struct result | |
148 | { | |
149 | typedef typename match_result<ScannerT, attr_t>::type type; | |
150 | }; | |
151 | ||
152 | init_closure_parser(ParserT const& p, ActorTupleT const& init_) | |
153 | : base_t(p), init(init_) {} | |
154 | ||
155 | template <typename ScannerT> | |
156 | typename parser_result<self_t, ScannerT>::type | |
157 | parse_main(ScannerT const& scan) const | |
158 | { | |
159 | return this->subject().parse_main(scan); | |
160 | } | |
161 | ||
162 | template <typename ScannerT> | |
163 | typename parser_result<self_t, ScannerT>::type | |
164 | parse(ScannerT const& scan) const | |
165 | { | |
166 | typedef init_closure_context<self_t> init_context_t; | |
167 | typedef parser_scanner_linker<ScannerT> scanner_t; | |
168 | typedef closure_context_linker<init_context_t> context_t; | |
169 | typedef typename parser_result<self_t, ScannerT>::type result_t; | |
170 | BOOST_SPIRIT_CONTEXT_PARSE( | |
171 | scan, *this, scanner_t, context_t, result_t); | |
172 | } | |
173 | ||
174 | ActorTupleT init; | |
175 | }; | |
176 | ||
177 | /////////////////////////////////////////////////////////////////////////// | |
178 | // | |
179 | // closure class | |
180 | // | |
181 | /////////////////////////////////////////////////////////////////////////// | |
182 | template < | |
183 | typename DerivedT | |
184 | , typename T0 | |
185 | , typename T1 | |
186 | , typename T2 | |
187 | ||
188 | #if BOOST_SPIRIT_CLOSURE_LIMIT > 3 | |
189 | , typename T3 | |
190 | , typename T4 | |
191 | , typename T5 | |
192 | ||
193 | #if BOOST_SPIRIT_CLOSURE_LIMIT > 6 | |
194 | , typename T6 | |
195 | , typename T7 | |
196 | , typename T8 | |
197 | ||
198 | #if BOOST_SPIRIT_CLOSURE_LIMIT > 9 | |
199 | , typename T9 | |
200 | , typename T10 | |
201 | , typename T11 | |
202 | ||
203 | #if BOOST_SPIRIT_CLOSURE_LIMIT > 12 | |
204 | , typename T12 | |
205 | , typename T13 | |
206 | , typename T14 | |
207 | #endif | |
208 | #endif | |
209 | #endif | |
210 | #endif | |
211 | > | |
212 | struct closure : | |
213 | public ::phoenix::closure< | |
214 | T0, T1, T2 | |
215 | #if BOOST_SPIRIT_CLOSURE_LIMIT > 3 | |
216 | , T3, T4, T5 | |
217 | #if BOOST_SPIRIT_CLOSURE_LIMIT > 6 | |
218 | , T6, T7, T8 | |
219 | #if BOOST_SPIRIT_CLOSURE_LIMIT > 9 | |
220 | , T9, T10, T11 | |
221 | #if BOOST_SPIRIT_CLOSURE_LIMIT > 12 | |
222 | , T12, T13, T14 | |
223 | #endif | |
224 | #endif | |
225 | #endif | |
226 | #endif | |
227 | > | |
228 | { | |
229 | typedef ::phoenix::closure< | |
230 | T0, T1, T2 | |
231 | #if BOOST_SPIRIT_CLOSURE_LIMIT > 3 | |
232 | , T3, T4, T5 | |
233 | #if BOOST_SPIRIT_CLOSURE_LIMIT > 6 | |
234 | , T6, T7, T8 | |
235 | #if BOOST_SPIRIT_CLOSURE_LIMIT > 9 | |
236 | , T9, T10, T11 | |
237 | #if BOOST_SPIRIT_CLOSURE_LIMIT > 12 | |
238 | , T12, T13, T14 | |
239 | #endif | |
240 | #endif | |
241 | #endif | |
242 | #endif | |
243 | > phoenix_closure_t; | |
244 | ||
245 | typedef closure_context<DerivedT> context_t; | |
246 | ||
247 | template <typename DerivedT2> | |
248 | struct aux | |
249 | { | |
250 | DerivedT2& aux_derived() | |
251 | { return *static_cast<DerivedT2*>(this); } | |
252 | ||
253 | DerivedT2 const& aux_derived() const | |
254 | { return *static_cast<DerivedT2 const*>(this); } | |
255 | ||
256 | // initialization functions | |
257 | template <typename A> | |
258 | init_closure_parser< | |
259 | DerivedT2, | |
260 | ::phoenix::tuple< | |
261 | typename ::phoenix::as_actor<A>::type | |
262 | > | |
263 | > | |
264 | operator()(A const &a) const | |
265 | { | |
266 | typedef typename ::phoenix::as_actor<A>::type a_t; | |
267 | typedef ::phoenix::tuple<a_t> actor_tuple_t; | |
268 | ||
269 | return init_closure_parser<DerivedT2, actor_tuple_t>( | |
270 | aux_derived(), | |
271 | actor_tuple_t( | |
272 | ::phoenix::as_actor<A>::convert(a) | |
273 | ) | |
274 | ); | |
275 | } | |
276 | ||
277 | template <typename A, typename B> | |
278 | init_closure_parser< | |
279 | DerivedT2, | |
280 | ::phoenix::tuple< | |
281 | typename ::phoenix::as_actor<A>::type, | |
282 | typename ::phoenix::as_actor<B>::type | |
283 | > | |
284 | > | |
285 | operator()(A const &a, B const &b) const | |
286 | { | |
287 | typedef typename ::phoenix::as_actor<A>::type a_t; | |
288 | typedef typename ::phoenix::as_actor<B>::type b_t; | |
289 | typedef ::phoenix::tuple<a_t, b_t> actor_tuple_t; | |
290 | ||
291 | return init_closure_parser<DerivedT2, actor_tuple_t>( | |
292 | aux_derived(), | |
293 | actor_tuple_t( | |
294 | ::phoenix::as_actor<A>::convert(a), | |
295 | ::phoenix::as_actor<B>::convert(b) | |
296 | ) | |
297 | ); | |
298 | } | |
299 | ||
300 | template <typename A, typename B, typename C> | |
301 | init_closure_parser< | |
302 | DerivedT2, | |
303 | ::phoenix::tuple< | |
304 | typename ::phoenix::as_actor<A>::type, | |
305 | typename ::phoenix::as_actor<B>::type, | |
306 | typename ::phoenix::as_actor<C>::type | |
307 | > | |
308 | > | |
309 | operator()(A const &a, B const &b, C const &c) const | |
310 | { | |
311 | typedef typename ::phoenix::as_actor<A>::type a_t; | |
312 | typedef typename ::phoenix::as_actor<B>::type b_t; | |
313 | typedef typename ::phoenix::as_actor<C>::type c_t; | |
314 | typedef ::phoenix::tuple<a_t, b_t, c_t> actor_tuple_t; | |
315 | ||
316 | return init_closure_parser<DerivedT2, actor_tuple_t>( | |
317 | aux_derived(), | |
318 | actor_tuple_t( | |
319 | ::phoenix::as_actor<A>::convert(a), | |
320 | ::phoenix::as_actor<B>::convert(b), | |
321 | ::phoenix::as_actor<C>::convert(c) | |
322 | ) | |
323 | ); | |
324 | } | |
325 | ||
326 | #if BOOST_SPIRIT_CLOSURE_LIMIT > 3 | |
327 | ||
328 | template < | |
329 | typename A, typename B, typename C, typename D | |
330 | > | |
331 | init_closure_parser< | |
332 | DerivedT2, | |
333 | ::phoenix::tuple< | |
334 | typename ::phoenix::as_actor<A>::type, | |
335 | typename ::phoenix::as_actor<B>::type, | |
336 | typename ::phoenix::as_actor<C>::type, | |
337 | typename ::phoenix::as_actor<D>::type | |
338 | > | |
339 | > | |
340 | operator()( | |
341 | A const &a, B const &b, C const &c, D const &d | |
342 | ) const | |
343 | { | |
344 | typedef typename ::phoenix::as_actor<A>::type a_t; | |
345 | typedef typename ::phoenix::as_actor<B>::type b_t; | |
346 | typedef typename ::phoenix::as_actor<C>::type c_t; | |
347 | typedef typename ::phoenix::as_actor<D>::type d_t; | |
348 | typedef ::phoenix::tuple< | |
349 | a_t, b_t, c_t, d_t | |
350 | > actor_tuple_t; | |
351 | ||
352 | return init_closure_parser<DerivedT2, actor_tuple_t>( | |
353 | aux_derived(), | |
354 | actor_tuple_t( | |
355 | ::phoenix::as_actor<A>::convert(a), | |
356 | ::phoenix::as_actor<B>::convert(b), | |
357 | ::phoenix::as_actor<C>::convert(c), | |
358 | ::phoenix::as_actor<D>::convert(d) | |
359 | ) | |
360 | ); | |
361 | } | |
362 | ||
363 | template < | |
364 | typename A, typename B, typename C, typename D, typename E | |
365 | > | |
366 | init_closure_parser< | |
367 | DerivedT2, | |
368 | ::phoenix::tuple< | |
369 | typename ::phoenix::as_actor<A>::type, | |
370 | typename ::phoenix::as_actor<B>::type, | |
371 | typename ::phoenix::as_actor<C>::type, | |
372 | typename ::phoenix::as_actor<D>::type, | |
373 | typename ::phoenix::as_actor<E>::type | |
374 | > | |
375 | > | |
376 | operator()( | |
377 | A const &a, B const &b, C const &c, D const &d, E const &e | |
378 | ) const | |
379 | { | |
380 | typedef typename ::phoenix::as_actor<A>::type a_t; | |
381 | typedef typename ::phoenix::as_actor<B>::type b_t; | |
382 | typedef typename ::phoenix::as_actor<C>::type c_t; | |
383 | typedef typename ::phoenix::as_actor<D>::type d_t; | |
384 | typedef typename ::phoenix::as_actor<E>::type e_t; | |
385 | typedef ::phoenix::tuple< | |
386 | a_t, b_t, c_t, d_t, e_t | |
387 | > actor_tuple_t; | |
388 | ||
389 | return init_closure_parser<DerivedT2, actor_tuple_t>( | |
390 | aux_derived(), | |
391 | actor_tuple_t( | |
392 | ::phoenix::as_actor<A>::convert(a), | |
393 | ::phoenix::as_actor<B>::convert(b), | |
394 | ::phoenix::as_actor<C>::convert(c), | |
395 | ::phoenix::as_actor<D>::convert(d), | |
396 | ::phoenix::as_actor<E>::convert(e) | |
397 | ) | |
398 | ); | |
399 | } | |
400 | ||
401 | template < | |
402 | typename A, typename B, typename C, typename D, typename E, | |
403 | typename F | |
404 | > | |
405 | init_closure_parser< | |
406 | DerivedT2, | |
407 | ::phoenix::tuple< | |
408 | typename ::phoenix::as_actor<A>::type, | |
409 | typename ::phoenix::as_actor<B>::type, | |
410 | typename ::phoenix::as_actor<C>::type, | |
411 | typename ::phoenix::as_actor<D>::type, | |
412 | typename ::phoenix::as_actor<E>::type, | |
413 | typename ::phoenix::as_actor<F>::type | |
414 | > | |
415 | > | |
416 | operator()( | |
417 | A const &a, B const &b, C const &c, D const &d, E const &e, | |
418 | F const &f | |
419 | ) const | |
420 | { | |
421 | typedef typename ::phoenix::as_actor<A>::type a_t; | |
422 | typedef typename ::phoenix::as_actor<B>::type b_t; | |
423 | typedef typename ::phoenix::as_actor<C>::type c_t; | |
424 | typedef typename ::phoenix::as_actor<D>::type d_t; | |
425 | typedef typename ::phoenix::as_actor<E>::type e_t; | |
426 | typedef typename ::phoenix::as_actor<F>::type f_t; | |
427 | typedef ::phoenix::tuple< | |
428 | a_t, b_t, c_t, d_t, e_t, f_t | |
429 | > actor_tuple_t; | |
430 | ||
431 | return init_closure_parser<DerivedT2, actor_tuple_t>( | |
432 | aux_derived(), | |
433 | actor_tuple_t( | |
434 | ::phoenix::as_actor<A>::convert(a), | |
435 | ::phoenix::as_actor<B>::convert(b), | |
436 | ::phoenix::as_actor<C>::convert(c), | |
437 | ::phoenix::as_actor<D>::convert(d), | |
438 | ::phoenix::as_actor<E>::convert(e), | |
439 | ::phoenix::as_actor<F>::convert(f) | |
440 | ) | |
441 | ); | |
442 | } | |
443 | ||
444 | #if BOOST_SPIRIT_CLOSURE_LIMIT > 6 | |
445 | ||
446 | template < | |
447 | typename A, typename B, typename C, typename D, typename E, | |
448 | typename F, typename G | |
449 | > | |
450 | init_closure_parser< | |
451 | DerivedT2, | |
452 | ::phoenix::tuple< | |
453 | typename ::phoenix::as_actor<A>::type, | |
454 | typename ::phoenix::as_actor<B>::type, | |
455 | typename ::phoenix::as_actor<C>::type, | |
456 | typename ::phoenix::as_actor<D>::type, | |
457 | typename ::phoenix::as_actor<E>::type, | |
458 | typename ::phoenix::as_actor<F>::type, | |
459 | typename ::phoenix::as_actor<G>::type | |
460 | > | |
461 | > | |
462 | operator()( | |
463 | A const &a, B const &b, C const &c, D const &d, E const &e, | |
464 | F const &f, G const &g | |
465 | ) const | |
466 | { | |
467 | typedef typename ::phoenix::as_actor<A>::type a_t; | |
468 | typedef typename ::phoenix::as_actor<B>::type b_t; | |
469 | typedef typename ::phoenix::as_actor<C>::type c_t; | |
470 | typedef typename ::phoenix::as_actor<D>::type d_t; | |
471 | typedef typename ::phoenix::as_actor<E>::type e_t; | |
472 | typedef typename ::phoenix::as_actor<F>::type f_t; | |
473 | typedef typename ::phoenix::as_actor<G>::type g_t; | |
474 | typedef ::phoenix::tuple< | |
475 | a_t, b_t, c_t, d_t, e_t, f_t, g_t | |
476 | > actor_tuple_t; | |
477 | ||
478 | return init_closure_parser<DerivedT2, actor_tuple_t>( | |
479 | aux_derived(), | |
480 | actor_tuple_t( | |
481 | ::phoenix::as_actor<A>::convert(a), | |
482 | ::phoenix::as_actor<B>::convert(b), | |
483 | ::phoenix::as_actor<C>::convert(c), | |
484 | ::phoenix::as_actor<D>::convert(d), | |
485 | ::phoenix::as_actor<E>::convert(e), | |
486 | ::phoenix::as_actor<F>::convert(f), | |
487 | ::phoenix::as_actor<G>::convert(g) | |
488 | ) | |
489 | ); | |
490 | } | |
491 | ||
492 | template < | |
493 | typename A, typename B, typename C, typename D, typename E, | |
494 | typename F, typename G, typename H | |
495 | > | |
496 | init_closure_parser< | |
497 | DerivedT2, | |
498 | ::phoenix::tuple< | |
499 | typename ::phoenix::as_actor<A>::type, | |
500 | typename ::phoenix::as_actor<B>::type, | |
501 | typename ::phoenix::as_actor<C>::type, | |
502 | typename ::phoenix::as_actor<D>::type, | |
503 | typename ::phoenix::as_actor<E>::type, | |
504 | typename ::phoenix::as_actor<F>::type, | |
505 | typename ::phoenix::as_actor<G>::type, | |
506 | typename ::phoenix::as_actor<H>::type | |
507 | > | |
508 | > | |
509 | operator()( | |
510 | A const &a, B const &b, C const &c, D const &d, E const &e, | |
511 | F const &f, G const &g, H const &h | |
512 | ) const | |
513 | { | |
514 | typedef typename ::phoenix::as_actor<A>::type a_t; | |
515 | typedef typename ::phoenix::as_actor<B>::type b_t; | |
516 | typedef typename ::phoenix::as_actor<C>::type c_t; | |
517 | typedef typename ::phoenix::as_actor<D>::type d_t; | |
518 | typedef typename ::phoenix::as_actor<E>::type e_t; | |
519 | typedef typename ::phoenix::as_actor<F>::type f_t; | |
520 | typedef typename ::phoenix::as_actor<G>::type g_t; | |
521 | typedef typename ::phoenix::as_actor<H>::type h_t; | |
522 | typedef ::phoenix::tuple< | |
523 | a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t | |
524 | > actor_tuple_t; | |
525 | ||
526 | return init_closure_parser<DerivedT2, actor_tuple_t>( | |
527 | aux_derived(), | |
528 | actor_tuple_t( | |
529 | ::phoenix::as_actor<A>::convert(a), | |
530 | ::phoenix::as_actor<B>::convert(b), | |
531 | ::phoenix::as_actor<C>::convert(c), | |
532 | ::phoenix::as_actor<D>::convert(d), | |
533 | ::phoenix::as_actor<E>::convert(e), | |
534 | ::phoenix::as_actor<F>::convert(f), | |
535 | ::phoenix::as_actor<G>::convert(g), | |
536 | ::phoenix::as_actor<H>::convert(h) | |
537 | ) | |
538 | ); | |
539 | } | |
540 | ||
541 | template < | |
542 | typename A, typename B, typename C, typename D, typename E, | |
543 | typename F, typename G, typename H, typename I | |
544 | > | |
545 | init_closure_parser< | |
546 | DerivedT2, | |
547 | ::phoenix::tuple< | |
548 | typename ::phoenix::as_actor<A>::type, | |
549 | typename ::phoenix::as_actor<B>::type, | |
550 | typename ::phoenix::as_actor<C>::type, | |
551 | typename ::phoenix::as_actor<D>::type, | |
552 | typename ::phoenix::as_actor<E>::type, | |
553 | typename ::phoenix::as_actor<F>::type, | |
554 | typename ::phoenix::as_actor<G>::type, | |
555 | typename ::phoenix::as_actor<H>::type, | |
556 | typename ::phoenix::as_actor<I>::type | |
557 | > | |
558 | > | |
559 | operator()( | |
560 | A const &a, B const &b, C const &c, D const &d, E const &e, | |
561 | F const &f, G const &g, H const &h, I const &i | |
562 | ) const | |
563 | { | |
564 | typedef typename ::phoenix::as_actor<A>::type a_t; | |
565 | typedef typename ::phoenix::as_actor<B>::type b_t; | |
566 | typedef typename ::phoenix::as_actor<C>::type c_t; | |
567 | typedef typename ::phoenix::as_actor<D>::type d_t; | |
568 | typedef typename ::phoenix::as_actor<E>::type e_t; | |
569 | typedef typename ::phoenix::as_actor<F>::type f_t; | |
570 | typedef typename ::phoenix::as_actor<G>::type g_t; | |
571 | typedef typename ::phoenix::as_actor<H>::type h_t; | |
572 | typedef typename ::phoenix::as_actor<I>::type i_t; | |
573 | typedef ::phoenix::tuple< | |
574 | a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t | |
575 | > actor_tuple_t; | |
576 | ||
577 | return init_closure_parser<DerivedT2, actor_tuple_t>( | |
578 | aux_derived(), | |
579 | actor_tuple_t( | |
580 | ::phoenix::as_actor<A>::convert(a), | |
581 | ::phoenix::as_actor<B>::convert(b), | |
582 | ::phoenix::as_actor<C>::convert(c), | |
583 | ::phoenix::as_actor<D>::convert(d), | |
584 | ::phoenix::as_actor<E>::convert(e), | |
585 | ::phoenix::as_actor<F>::convert(f), | |
586 | ::phoenix::as_actor<G>::convert(g), | |
587 | ::phoenix::as_actor<H>::convert(h), | |
588 | ::phoenix::as_actor<I>::convert(i) | |
589 | ) | |
590 | ); | |
591 | } | |
592 | ||
593 | #if BOOST_SPIRIT_CLOSURE_LIMIT > 9 | |
594 | ||
595 | template < | |
596 | typename A, typename B, typename C, typename D, typename E, | |
597 | typename F, typename G, typename H, typename I, typename J | |
598 | > | |
599 | init_closure_parser< | |
600 | DerivedT2, | |
601 | ::phoenix::tuple< | |
602 | typename ::phoenix::as_actor<A>::type, | |
603 | typename ::phoenix::as_actor<B>::type, | |
604 | typename ::phoenix::as_actor<C>::type, | |
605 | typename ::phoenix::as_actor<D>::type, | |
606 | typename ::phoenix::as_actor<E>::type, | |
607 | typename ::phoenix::as_actor<F>::type, | |
608 | typename ::phoenix::as_actor<G>::type, | |
609 | typename ::phoenix::as_actor<H>::type, | |
610 | typename ::phoenix::as_actor<I>::type, | |
611 | typename ::phoenix::as_actor<J>::type | |
612 | > | |
613 | > | |
614 | operator()( | |
615 | A const &a, B const &b, C const &c, D const &d, E const &e, | |
616 | F const &f, G const &g, H const &h, I const &i, J const &j | |
617 | ) const | |
618 | { | |
619 | typedef typename ::phoenix::as_actor<A>::type a_t; | |
620 | typedef typename ::phoenix::as_actor<B>::type b_t; | |
621 | typedef typename ::phoenix::as_actor<C>::type c_t; | |
622 | typedef typename ::phoenix::as_actor<D>::type d_t; | |
623 | typedef typename ::phoenix::as_actor<E>::type e_t; | |
624 | typedef typename ::phoenix::as_actor<F>::type f_t; | |
625 | typedef typename ::phoenix::as_actor<G>::type g_t; | |
626 | typedef typename ::phoenix::as_actor<H>::type h_t; | |
627 | typedef typename ::phoenix::as_actor<I>::type i_t; | |
628 | typedef typename ::phoenix::as_actor<J>::type j_t; | |
629 | typedef ::phoenix::tuple< | |
630 | a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t, j_t | |
631 | > actor_tuple_t; | |
632 | ||
633 | return init_closure_parser<DerivedT2, actor_tuple_t>( | |
634 | aux_derived(), | |
635 | actor_tuple_t( | |
636 | ::phoenix::as_actor<A>::convert(a), | |
637 | ::phoenix::as_actor<B>::convert(b), | |
638 | ::phoenix::as_actor<C>::convert(c), | |
639 | ::phoenix::as_actor<D>::convert(d), | |
640 | ::phoenix::as_actor<E>::convert(e), | |
641 | ::phoenix::as_actor<F>::convert(f), | |
642 | ::phoenix::as_actor<G>::convert(g), | |
643 | ::phoenix::as_actor<H>::convert(h), | |
644 | ::phoenix::as_actor<I>::convert(i), | |
645 | ::phoenix::as_actor<J>::convert(j) | |
646 | ) | |
647 | ); | |
648 | } | |
649 | ||
650 | template < | |
651 | typename A, typename B, typename C, typename D, typename E, | |
652 | typename F, typename G, typename H, typename I, typename J, | |
653 | typename K | |
654 | > | |
655 | init_closure_parser< | |
656 | DerivedT2, | |
657 | ::phoenix::tuple< | |
658 | typename ::phoenix::as_actor<A>::type, | |
659 | typename ::phoenix::as_actor<B>::type, | |
660 | typename ::phoenix::as_actor<C>::type, | |
661 | typename ::phoenix::as_actor<D>::type, | |
662 | typename ::phoenix::as_actor<E>::type, | |
663 | typename ::phoenix::as_actor<F>::type, | |
664 | typename ::phoenix::as_actor<G>::type, | |
665 | typename ::phoenix::as_actor<H>::type, | |
666 | typename ::phoenix::as_actor<I>::type, | |
667 | typename ::phoenix::as_actor<J>::type, | |
668 | typename ::phoenix::as_actor<K>::type | |
669 | > | |
670 | > | |
671 | operator()( | |
672 | A const &a, B const &b, C const &c, D const &d, E const &e, | |
673 | F const &f, G const &g, H const &h, I const &i, J const &j, | |
674 | K const &k | |
675 | ) const | |
676 | { | |
677 | typedef typename ::phoenix::as_actor<A>::type a_t; | |
678 | typedef typename ::phoenix::as_actor<B>::type b_t; | |
679 | typedef typename ::phoenix::as_actor<C>::type c_t; | |
680 | typedef typename ::phoenix::as_actor<D>::type d_t; | |
681 | typedef typename ::phoenix::as_actor<E>::type e_t; | |
682 | typedef typename ::phoenix::as_actor<F>::type f_t; | |
683 | typedef typename ::phoenix::as_actor<G>::type g_t; | |
684 | typedef typename ::phoenix::as_actor<H>::type h_t; | |
685 | typedef typename ::phoenix::as_actor<I>::type i_t; | |
686 | typedef typename ::phoenix::as_actor<J>::type j_t; | |
687 | typedef typename ::phoenix::as_actor<K>::type k_t; | |
688 | typedef ::phoenix::tuple< | |
689 | a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t, j_t, | |
690 | k_t | |
691 | > actor_tuple_t; | |
692 | ||
693 | return init_closure_parser<DerivedT2, actor_tuple_t>( | |
694 | aux_derived(), | |
695 | actor_tuple_t( | |
696 | ::phoenix::as_actor<A>::convert(a), | |
697 | ::phoenix::as_actor<B>::convert(b), | |
698 | ::phoenix::as_actor<C>::convert(c), | |
699 | ::phoenix::as_actor<D>::convert(d), | |
700 | ::phoenix::as_actor<E>::convert(e), | |
701 | ::phoenix::as_actor<F>::convert(f), | |
702 | ::phoenix::as_actor<G>::convert(g), | |
703 | ::phoenix::as_actor<H>::convert(h), | |
704 | ::phoenix::as_actor<I>::convert(i), | |
705 | ::phoenix::as_actor<J>::convert(j), | |
706 | ::phoenix::as_actor<K>::convert(k) | |
707 | ) | |
708 | ); | |
709 | } | |
710 | ||
711 | template < | |
712 | typename A, typename B, typename C, typename D, typename E, | |
713 | typename F, typename G, typename H, typename I, typename J, | |
714 | typename K, typename L | |
715 | > | |
716 | init_closure_parser< | |
717 | DerivedT2, | |
718 | ::phoenix::tuple< | |
719 | typename ::phoenix::as_actor<A>::type, | |
720 | typename ::phoenix::as_actor<B>::type, | |
721 | typename ::phoenix::as_actor<C>::type, | |
722 | typename ::phoenix::as_actor<D>::type, | |
723 | typename ::phoenix::as_actor<E>::type, | |
724 | typename ::phoenix::as_actor<F>::type, | |
725 | typename ::phoenix::as_actor<G>::type, | |
726 | typename ::phoenix::as_actor<H>::type, | |
727 | typename ::phoenix::as_actor<I>::type, | |
728 | typename ::phoenix::as_actor<J>::type, | |
729 | typename ::phoenix::as_actor<K>::type, | |
730 | typename ::phoenix::as_actor<L>::type | |
731 | > | |
732 | > | |
733 | operator()( | |
734 | A const &a, B const &b, C const &c, D const &d, E const &e, | |
735 | F const &f, G const &g, H const &h, I const &i, J const &j, | |
736 | K const &k, L const &l | |
737 | ) const | |
738 | { | |
739 | typedef typename ::phoenix::as_actor<A>::type a_t; | |
740 | typedef typename ::phoenix::as_actor<B>::type b_t; | |
741 | typedef typename ::phoenix::as_actor<C>::type c_t; | |
742 | typedef typename ::phoenix::as_actor<D>::type d_t; | |
743 | typedef typename ::phoenix::as_actor<E>::type e_t; | |
744 | typedef typename ::phoenix::as_actor<F>::type f_t; | |
745 | typedef typename ::phoenix::as_actor<G>::type g_t; | |
746 | typedef typename ::phoenix::as_actor<H>::type h_t; | |
747 | typedef typename ::phoenix::as_actor<I>::type i_t; | |
748 | typedef typename ::phoenix::as_actor<J>::type j_t; | |
749 | typedef typename ::phoenix::as_actor<K>::type k_t; | |
750 | typedef typename ::phoenix::as_actor<L>::type l_t; | |
751 | typedef ::phoenix::tuple< | |
752 | a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t, j_t, | |
753 | k_t, l_t | |
754 | > actor_tuple_t; | |
755 | ||
756 | return init_closure_parser<DerivedT2, actor_tuple_t>( | |
757 | aux_derived(), | |
758 | actor_tuple_t( | |
759 | ::phoenix::as_actor<A>::convert(a), | |
760 | ::phoenix::as_actor<B>::convert(b), | |
761 | ::phoenix::as_actor<C>::convert(c), | |
762 | ::phoenix::as_actor<D>::convert(d), | |
763 | ::phoenix::as_actor<E>::convert(e), | |
764 | ::phoenix::as_actor<F>::convert(f), | |
765 | ::phoenix::as_actor<G>::convert(g), | |
766 | ::phoenix::as_actor<H>::convert(h), | |
767 | ::phoenix::as_actor<I>::convert(i), | |
768 | ::phoenix::as_actor<J>::convert(j), | |
769 | ::phoenix::as_actor<K>::convert(k), | |
770 | ::phoenix::as_actor<L>::convert(l) | |
771 | ) | |
772 | ); | |
773 | } | |
774 | ||
775 | #if BOOST_SPIRIT_CLOSURE_LIMIT > 12 | |
776 | ||
777 | template < | |
778 | typename A, typename B, typename C, typename D, typename E, | |
779 | typename F, typename G, typename H, typename I, typename J, | |
780 | typename K, typename L, typename M | |
781 | > | |
782 | init_closure_parser< | |
783 | DerivedT2, | |
784 | ::phoenix::tuple< | |
785 | typename ::phoenix::as_actor<A>::type, | |
786 | typename ::phoenix::as_actor<B>::type, | |
787 | typename ::phoenix::as_actor<C>::type, | |
788 | typename ::phoenix::as_actor<D>::type, | |
789 | typename ::phoenix::as_actor<E>::type, | |
790 | typename ::phoenix::as_actor<F>::type, | |
791 | typename ::phoenix::as_actor<G>::type, | |
792 | typename ::phoenix::as_actor<H>::type, | |
793 | typename ::phoenix::as_actor<I>::type, | |
794 | typename ::phoenix::as_actor<J>::type, | |
795 | typename ::phoenix::as_actor<K>::type, | |
796 | typename ::phoenix::as_actor<L>::type, | |
797 | typename ::phoenix::as_actor<M>::type | |
798 | > | |
799 | > | |
800 | operator()( | |
801 | A const &a, B const &b, C const &c, D const &d, E const &e, | |
802 | F const &f, G const &g, H const &h, I const &i, J const &j, | |
803 | K const &k, L const &l, M const &m | |
804 | ) const | |
805 | { | |
806 | typedef typename ::phoenix::as_actor<A>::type a_t; | |
807 | typedef typename ::phoenix::as_actor<B>::type b_t; | |
808 | typedef typename ::phoenix::as_actor<C>::type c_t; | |
809 | typedef typename ::phoenix::as_actor<D>::type d_t; | |
810 | typedef typename ::phoenix::as_actor<E>::type e_t; | |
811 | typedef typename ::phoenix::as_actor<F>::type f_t; | |
812 | typedef typename ::phoenix::as_actor<G>::type g_t; | |
813 | typedef typename ::phoenix::as_actor<H>::type h_t; | |
814 | typedef typename ::phoenix::as_actor<I>::type i_t; | |
815 | typedef typename ::phoenix::as_actor<J>::type j_t; | |
816 | typedef typename ::phoenix::as_actor<K>::type k_t; | |
817 | typedef typename ::phoenix::as_actor<L>::type l_t; | |
818 | typedef typename ::phoenix::as_actor<M>::type m_t; | |
819 | typedef ::phoenix::tuple< | |
820 | a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t, j_t, | |
821 | k_t, l_t, m_t | |
822 | > actor_tuple_t; | |
823 | ||
824 | return init_closure_parser<DerivedT2, actor_tuple_t>( | |
825 | aux_derived(), | |
826 | actor_tuple_t( | |
827 | ::phoenix::as_actor<A>::convert(a), | |
828 | ::phoenix::as_actor<B>::convert(b), | |
829 | ::phoenix::as_actor<C>::convert(c), | |
830 | ::phoenix::as_actor<D>::convert(d), | |
831 | ::phoenix::as_actor<E>::convert(e), | |
832 | ::phoenix::as_actor<F>::convert(f), | |
833 | ::phoenix::as_actor<G>::convert(g), | |
834 | ::phoenix::as_actor<H>::convert(h), | |
835 | ::phoenix::as_actor<I>::convert(i), | |
836 | ::phoenix::as_actor<J>::convert(j), | |
837 | ::phoenix::as_actor<K>::convert(k), | |
838 | ::phoenix::as_actor<L>::convert(l), | |
839 | ::phoenix::as_actor<M>::convert(m) | |
840 | ) | |
841 | ); | |
842 | } | |
843 | ||
844 | template < | |
845 | typename A, typename B, typename C, typename D, typename E, | |
846 | typename F, typename G, typename H, typename I, typename J, | |
847 | typename K, typename L, typename M, typename N | |
848 | > | |
849 | init_closure_parser< | |
850 | DerivedT2, | |
851 | ::phoenix::tuple< | |
852 | typename ::phoenix::as_actor<A>::type, | |
853 | typename ::phoenix::as_actor<B>::type, | |
854 | typename ::phoenix::as_actor<C>::type, | |
855 | typename ::phoenix::as_actor<D>::type, | |
856 | typename ::phoenix::as_actor<E>::type, | |
857 | typename ::phoenix::as_actor<F>::type, | |
858 | typename ::phoenix::as_actor<G>::type, | |
859 | typename ::phoenix::as_actor<H>::type, | |
860 | typename ::phoenix::as_actor<I>::type, | |
861 | typename ::phoenix::as_actor<J>::type, | |
862 | typename ::phoenix::as_actor<K>::type, | |
863 | typename ::phoenix::as_actor<L>::type, | |
864 | typename ::phoenix::as_actor<M>::type, | |
865 | typename ::phoenix::as_actor<N>::type | |
866 | > | |
867 | > | |
868 | operator()( | |
869 | A const &a, B const &b, C const &c, D const &d, E const &e, | |
870 | F const &f, G const &g, H const &h, I const &i, J const &j, | |
871 | K const &k, L const &l, M const &m, N const &n | |
872 | ) const | |
873 | { | |
874 | typedef typename ::phoenix::as_actor<A>::type a_t; | |
875 | typedef typename ::phoenix::as_actor<B>::type b_t; | |
876 | typedef typename ::phoenix::as_actor<C>::type c_t; | |
877 | typedef typename ::phoenix::as_actor<D>::type d_t; | |
878 | typedef typename ::phoenix::as_actor<E>::type e_t; | |
879 | typedef typename ::phoenix::as_actor<F>::type f_t; | |
880 | typedef typename ::phoenix::as_actor<G>::type g_t; | |
881 | typedef typename ::phoenix::as_actor<H>::type h_t; | |
882 | typedef typename ::phoenix::as_actor<I>::type i_t; | |
883 | typedef typename ::phoenix::as_actor<J>::type j_t; | |
884 | typedef typename ::phoenix::as_actor<K>::type k_t; | |
885 | typedef typename ::phoenix::as_actor<L>::type l_t; | |
886 | typedef typename ::phoenix::as_actor<M>::type m_t; | |
887 | typedef typename ::phoenix::as_actor<N>::type n_t; | |
888 | typedef ::phoenix::tuple< | |
889 | a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t, j_t, | |
890 | k_t, l_t, m_t, n_t | |
891 | > actor_tuple_t; | |
892 | ||
893 | return init_closure_parser<DerivedT2, actor_tuple_t>( | |
894 | aux_derived(), | |
895 | actor_tuple_t( | |
896 | ::phoenix::as_actor<A>::convert(a), | |
897 | ::phoenix::as_actor<B>::convert(b), | |
898 | ::phoenix::as_actor<C>::convert(c), | |
899 | ::phoenix::as_actor<D>::convert(d), | |
900 | ::phoenix::as_actor<E>::convert(e), | |
901 | ::phoenix::as_actor<F>::convert(f), | |
902 | ::phoenix::as_actor<G>::convert(g), | |
903 | ::phoenix::as_actor<H>::convert(h), | |
904 | ::phoenix::as_actor<I>::convert(i), | |
905 | ::phoenix::as_actor<J>::convert(j), | |
906 | ::phoenix::as_actor<K>::convert(k), | |
907 | ::phoenix::as_actor<L>::convert(l), | |
908 | ::phoenix::as_actor<M>::convert(m), | |
909 | ::phoenix::as_actor<N>::convert(n) | |
910 | ) | |
911 | ); | |
912 | } | |
913 | ||
914 | template < | |
915 | typename A, typename B, typename C, typename D, typename E, | |
916 | typename F, typename G, typename H, typename I, typename J, | |
917 | typename K, typename L, typename M, typename N, typename O | |
918 | > | |
919 | init_closure_parser< | |
920 | DerivedT2, | |
921 | ::phoenix::tuple< | |
922 | typename ::phoenix::as_actor<A>::type, | |
923 | typename ::phoenix::as_actor<B>::type, | |
924 | typename ::phoenix::as_actor<C>::type, | |
925 | typename ::phoenix::as_actor<D>::type, | |
926 | typename ::phoenix::as_actor<E>::type, | |
927 | typename ::phoenix::as_actor<F>::type, | |
928 | typename ::phoenix::as_actor<G>::type, | |
929 | typename ::phoenix::as_actor<H>::type, | |
930 | typename ::phoenix::as_actor<I>::type, | |
931 | typename ::phoenix::as_actor<J>::type, | |
932 | typename ::phoenix::as_actor<K>::type, | |
933 | typename ::phoenix::as_actor<L>::type, | |
934 | typename ::phoenix::as_actor<M>::type, | |
935 | typename ::phoenix::as_actor<N>::type, | |
936 | typename ::phoenix::as_actor<O>::type | |
937 | > | |
938 | > | |
939 | operator()( | |
940 | A const &a, B const &b, C const &c, D const &d, E const &e, | |
941 | F const &f, G const &g, H const &h, I const &i, J const &j, | |
942 | K const &k, L const &l, M const &m, N const &n, O const &o | |
943 | ) const | |
944 | { | |
945 | typedef typename ::phoenix::as_actor<A>::type a_t; | |
946 | typedef typename ::phoenix::as_actor<B>::type b_t; | |
947 | typedef typename ::phoenix::as_actor<C>::type c_t; | |
948 | typedef typename ::phoenix::as_actor<D>::type d_t; | |
949 | typedef typename ::phoenix::as_actor<E>::type e_t; | |
950 | typedef typename ::phoenix::as_actor<F>::type f_t; | |
951 | typedef typename ::phoenix::as_actor<G>::type g_t; | |
952 | typedef typename ::phoenix::as_actor<H>::type h_t; | |
953 | typedef typename ::phoenix::as_actor<I>::type i_t; | |
954 | typedef typename ::phoenix::as_actor<J>::type j_t; | |
955 | typedef typename ::phoenix::as_actor<K>::type k_t; | |
956 | typedef typename ::phoenix::as_actor<L>::type l_t; | |
957 | typedef typename ::phoenix::as_actor<M>::type m_t; | |
958 | typedef typename ::phoenix::as_actor<N>::type n_t; | |
959 | typedef typename ::phoenix::as_actor<O>::type o_t; | |
960 | typedef ::phoenix::tuple< | |
961 | a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t, j_t, | |
962 | k_t, l_t, m_t, n_t, o_t | |
963 | > actor_tuple_t; | |
964 | ||
965 | return init_closure_parser<DerivedT2, actor_tuple_t>( | |
966 | aux_derived(), | |
967 | actor_tuple_t( | |
968 | ::phoenix::as_actor<A>::convert(a), | |
969 | ::phoenix::as_actor<B>::convert(b), | |
970 | ::phoenix::as_actor<C>::convert(c), | |
971 | ::phoenix::as_actor<D>::convert(d), | |
972 | ::phoenix::as_actor<E>::convert(e), | |
973 | ::phoenix::as_actor<F>::convert(f), | |
974 | ::phoenix::as_actor<G>::convert(g), | |
975 | ::phoenix::as_actor<H>::convert(h), | |
976 | ::phoenix::as_actor<I>::convert(i), | |
977 | ::phoenix::as_actor<J>::convert(j), | |
978 | ::phoenix::as_actor<K>::convert(k), | |
979 | ::phoenix::as_actor<L>::convert(l), | |
980 | ::phoenix::as_actor<M>::convert(m), | |
981 | ::phoenix::as_actor<N>::convert(n), | |
982 | ::phoenix::as_actor<O>::convert(o) | |
983 | ) | |
984 | ); | |
985 | } | |
986 | ||
987 | #endif | |
988 | #endif | |
989 | #endif | |
990 | #endif | |
991 | }; | |
992 | ||
993 | ~closure() {} | |
994 | }; | |
995 | ||
996 | /////////////////////////////////////////////////////////////////////////// | |
997 | // | |
998 | // overloads for chseq_p and str_p taking in phoenix actors | |
999 | // | |
1000 | /////////////////////////////////////////////////////////////////////////// | |
1001 | template <typename ActorT> | |
1002 | struct container_begin | |
1003 | { | |
1004 | typedef container_begin<ActorT> self_t; | |
1005 | ||
1006 | template <typename TupleT> | |
1007 | struct result | |
1008 | { | |
1009 | typedef typename ::phoenix::actor_result<ActorT, TupleT> | |
1010 | ::plain_type::iterator type; | |
1011 | }; | |
1012 | ||
1013 | container_begin(ActorT actor_) | |
1014 | : actor(actor_) {} | |
1015 | ||
1016 | template <typename TupleT> | |
1017 | typename ::phoenix::actor_result<self_t, TupleT>::type | |
1018 | eval(TupleT const& /*args*/) const | |
1019 | { return actor().begin(); } | |
1020 | ||
1021 | ActorT actor; | |
1022 | }; | |
1023 | ||
1024 | template <typename ActorT> | |
1025 | struct container_end | |
1026 | { | |
1027 | typedef container_begin<ActorT> self_t; | |
1028 | ||
1029 | template <typename TupleT> | |
1030 | struct result | |
1031 | { | |
1032 | typedef typename ::phoenix::actor_result<ActorT, TupleT> | |
1033 | ::plain_type::iterator type; | |
1034 | }; | |
1035 | ||
1036 | container_end(ActorT actor_) | |
1037 | : actor(actor_) {} | |
1038 | ||
1039 | template <typename TupleT> | |
1040 | typename ::phoenix::actor_result<self_t, TupleT>::type | |
1041 | eval(TupleT const& /*args*/) const | |
1042 | { return actor().end(); } | |
1043 | ||
1044 | ActorT actor; | |
1045 | }; | |
1046 | ||
1047 | template <typename BaseT> | |
1048 | inline f_chseq< | |
1049 | ::phoenix::actor<container_begin< ::phoenix::actor<BaseT> > >, | |
1050 | ::phoenix::actor<container_end< ::phoenix::actor<BaseT> > > | |
1051 | > | |
1052 | f_chseq_p(::phoenix::actor<BaseT> const& a) | |
1053 | { | |
1054 | typedef ::phoenix::actor<container_begin< ::phoenix::actor<BaseT> > > | |
1055 | container_begin_t; | |
1056 | typedef ::phoenix::actor<container_end< ::phoenix::actor<BaseT> > > | |
1057 | container_end_t; | |
1058 | typedef f_chseq<container_begin_t, container_end_t> result_t; | |
1059 | ||
1060 | return result_t(container_begin_t(a), container_end_t(a)); | |
1061 | } | |
1062 | ||
1063 | template <typename BaseT> | |
1064 | inline f_strlit< | |
1065 | ::phoenix::actor<container_begin< ::phoenix::actor<BaseT> > >, | |
1066 | ::phoenix::actor<container_end< ::phoenix::actor<BaseT> > > | |
1067 | > | |
1068 | f_str_p(::phoenix::actor<BaseT> const& a) | |
1069 | { | |
1070 | typedef ::phoenix::actor<container_begin< ::phoenix::actor<BaseT> > > | |
1071 | container_begin_t; | |
1072 | typedef ::phoenix::actor<container_end< ::phoenix::actor<BaseT> > > | |
1073 | container_end_t; | |
1074 | typedef f_strlit<container_begin_t, container_end_t> result_t; | |
1075 | ||
1076 | return result_t(container_begin_t(a), container_end_t(a)); | |
1077 | } | |
1078 | ||
1079 | BOOST_SPIRIT_CLASSIC_NAMESPACE_END | |
1080 | ||
1081 | }} // namespace BOOST_SPIRIT_CLASSIC_NS | |
1082 | ||
1083 | #endif |