]>
Commit | Line | Data |
---|---|---|
1 | //////////////////////////////////////////////////////////////////////////// | |
2 | // lazy operator.hpp | |
3 | // | |
4 | // Build lazy operations for Phoenix equivalents for FC++ | |
5 | // | |
6 | // These are equivalents of the Boost FC++ functoids in operator.hpp | |
7 | // | |
8 | // Implemented so far: | |
9 | // | |
10 | // make_pair | |
11 | // plus minus multiplies divides modulus | |
12 | // negate equal not_equal greater less | |
13 | // greater_equal less_equal positive | |
14 | // logical_and logical_or | |
15 | // logical_not min max inc dec | |
16 | // | |
17 | // These are not from the FC++ operator.hpp but were made for testing purposes. | |
18 | // | |
19 | // identity (renamed id) | |
20 | // sin | |
21 | // | |
22 | // These are now being modified to use boost::phoenix::function | |
23 | // so that they are available for use as arguments. | |
24 | // Types are being defined in capitals e.g. Id id; | |
25 | //////////////////////////////////////////////////////////////////////////// | |
26 | /*============================================================================= | |
27 | Copyright (c) 2000-2003 Brian McNamara and Yannis Smaragdakis | |
28 | Copyright (c) 2001-2007 Joel de Guzman | |
29 | Copyright (c) 2015 John Fletcher | |
30 | ||
31 | Distributed under the Boost Software License, Version 1.0. (See accompanying | |
32 | file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) | |
33 | ==============================================================================*/ | |
34 | ||
35 | ||
36 | #ifndef BOOST_PHOENIX_FUNCTION_LAZY_OPERATOR | |
37 | #define BOOST_PHOENIX_FUNCTION_LAZY_OPERATOR | |
38 | ||
39 | #include <cmath> | |
40 | #include <cstdlib> | |
41 | #include <boost/phoenix/core.hpp> | |
42 | #include <boost/phoenix/function.hpp> | |
43 | #include <boost/function.hpp> | |
44 | ||
45 | namespace boost { | |
46 | ||
47 | namespace phoenix { | |
48 | ||
49 | ////////////////////////////////////////////////////////////////////// | |
50 | // a_unique_type_for_nil | |
51 | ////////////////////////////////////////////////////////////////////// | |
52 | ||
53 | // This may need to be moved elsewhere to define reuser. | |
54 | struct a_unique_type_for_nil { | |
55 | bool operator==( a_unique_type_for_nil ) const { return true; } | |
56 | bool operator< ( a_unique_type_for_nil ) const { return false; } | |
57 | typedef a_unique_type_for_nil value_type; | |
58 | }; | |
59 | // This maybe put into a namespace. | |
60 | a_unique_type_for_nil NIL; | |
61 | ||
62 | ////////////////////////////////////////////////////////////////////// | |
63 | // lazy_exception - renamed from fcpp_exception. | |
64 | ////////////////////////////////////////////////////////////////////// | |
65 | ||
66 | #ifndef BOOST_PHOENIX_NO_LAZY_EXCEPTIONS | |
67 | struct lazy_exception : public std::exception { | |
68 | const char* s; | |
69 | lazy_exception( const char* ss ) : s(ss) {} | |
70 | const char* what() const throw() { return s; } | |
71 | }; | |
72 | #endif | |
73 | ||
74 | ////////////////////////////////////////////////////////////////////// | |
75 | ||
76 | // in ref_count.hpp in BoostFC++ | |
77 | typedef unsigned int RefCountType; | |
78 | ||
79 | namespace impl { | |
80 | ||
81 | // Implemented early, moved from lazy_signature.hpp | |
82 | template <class T> | |
83 | struct remove_RC | |
84 | { | |
85 | typedef typename boost::remove_reference<T>::type TT; | |
86 | typedef typename boost::remove_const<TT>::type type; | |
87 | }; | |
88 | ||
89 | struct XId | |
90 | { | |
91 | template <typename Sig> | |
92 | struct result; | |
93 | ||
94 | template <typename This, typename A0> | |
95 | struct result<This(A0)> | |
96 | : boost::remove_reference<A0> | |
97 | {}; | |
98 | ||
99 | template <typename A0> | |
100 | A0 operator()(A0 const & a0) const | |
101 | { | |
102 | return a0; | |
103 | } | |
104 | ||
105 | }; | |
106 | ||
107 | ||
108 | } | |
109 | ||
110 | typedef boost::phoenix::function<impl::XId> Id; | |
111 | Id id; | |
112 | ||
113 | #ifdef BOOST_RESULT_OF_USE_TR1 | |
114 | // Experiment following examples in | |
115 | // phoenix/stl/container/container.hpp | |
116 | ||
117 | namespace result_of { | |
118 | ||
119 | template < | |
120 | typename Arg1 | |
121 | , typename Arg2 | |
122 | > | |
123 | class make_pair | |
124 | { | |
125 | public: | |
126 | typedef typename impl::remove_RC<Arg1>::type Arg1Type; | |
127 | typedef typename impl::remove_RC<Arg2>::type Arg2Type; | |
128 | typedef std::pair<Arg1Type,Arg2Type> type; | |
129 | typedef std::pair<Arg1Type,Arg2Type> result_type; | |
130 | }; | |
131 | } | |
132 | #endif | |
133 | ||
134 | namespace impl | |
135 | { | |
136 | ||
137 | struct XMake_pair { | |
138 | ||
139 | ||
140 | #ifdef BOOST_RESULT_OF_USE_TR1 | |
141 | template <typename Sig> | |
142 | struct result; | |
143 | // This fails with -O2 unless refs are removed from A1 and A2. | |
144 | template <typename This, typename A0, typename A1> | |
145 | struct result<This(A0, A1)> | |
146 | { | |
147 | typedef typename result_of::make_pair<A0,A1>::type type; | |
148 | }; | |
149 | #else | |
150 | template <typename Sig> | |
151 | struct result; | |
152 | ||
153 | template <typename This, typename A0, typename A1> | |
154 | struct result<This(A0, A1)> | |
155 | : boost::remove_reference<std::pair<A0, A1> > | |
156 | {}; | |
157 | ||
158 | #endif | |
159 | ||
160 | ||
161 | template <typename A0, typename A1> | |
162 | #ifdef BOOST_RESULT_OF_USE_TR1 | |
163 | typename result<XMake_pair(A0,A1)>::type | |
164 | #else | |
165 | std::pair<A0, A1> | |
166 | #endif | |
167 | operator()(A0 const & a0, A1 const & a1) const | |
168 | { | |
169 | return std::make_pair(a0,a1); | |
170 | } | |
171 | ||
172 | }; | |
173 | } | |
174 | ||
175 | typedef boost::phoenix::function<impl::XMake_pair> Make_pair; | |
176 | Make_pair make_pair; | |
177 | ||
178 | namespace impl | |
179 | { | |
180 | ||
181 | // For now I will leave the return type deduction as it is. | |
182 | // I want to look at bringing in the sort of type deduction for | |
183 | // mixed types which I have in FC++. | |
184 | // Also I could look at the case where one of the arguments is | |
185 | // another functor or a Phoenix placeholder. | |
186 | struct XPlus | |
187 | { | |
188 | template <typename Sig> | |
189 | struct result; | |
190 | ||
191 | template <typename This, typename A0, typename A1> | |
192 | struct result<This(A0, A1)> | |
193 | : boost::remove_reference<A0> | |
194 | {}; | |
195 | ||
196 | template <typename This, typename A0, typename A1, typename A2> | |
197 | struct result<This(A0, A1, A2)> | |
198 | : boost::remove_reference<A0> | |
199 | {}; | |
200 | ||
201 | template <typename A0, typename A1> | |
202 | A0 operator()(A0 const & a0, A1 const & a1) const | |
203 | { | |
204 | //A0 res = a0 + a1; | |
205 | //return res; | |
206 | return a0 + a1; | |
207 | } | |
208 | ||
209 | template <typename A0, typename A1, typename A2> | |
210 | A0 operator()(A0 const & a0, A1 const & a1, A2 const & a2) const | |
211 | { | |
212 | return a0 + a1 + a2; | |
213 | } | |
214 | }; | |
215 | ||
216 | struct XMinus | |
217 | { | |
218 | template <typename Sig> | |
219 | struct result; | |
220 | ||
221 | template <typename This, typename A0, typename A1> | |
222 | struct result<This(A0, A1)> | |
223 | : boost::remove_reference<A0> | |
224 | {}; | |
225 | ||
226 | template <typename A0, typename A1> | |
227 | A0 operator()(A0 const & a0, A1 const & a1) const | |
228 | { | |
229 | return a0 - a1; | |
230 | } | |
231 | ||
232 | }; | |
233 | ||
234 | struct XMultiplies | |
235 | { | |
236 | template <typename Sig> | |
237 | struct result; | |
238 | ||
239 | template <typename This, typename A0, typename A1> | |
240 | struct result<This(A0, A1)> | |
241 | : boost::remove_reference<A0> | |
242 | {}; | |
243 | ||
244 | template <typename A0, typename A1> | |
245 | A0 operator()(A0 const & a0, A1 const & a1) const | |
246 | { | |
247 | return a0 * a1; | |
248 | } | |
249 | ||
250 | }; | |
251 | ||
252 | struct XDivides | |
253 | { | |
254 | template <typename Sig> | |
255 | struct result; | |
256 | ||
257 | template <typename This, typename A0, typename A1> | |
258 | struct result<This(A0, A1)> | |
259 | : boost::remove_reference<A0> | |
260 | {}; | |
261 | ||
262 | template <typename A0, typename A1> | |
263 | A0 operator()(A0 const & a0, A1 const & a1) const | |
264 | { | |
265 | return a0 / a1; | |
266 | } | |
267 | ||
268 | }; | |
269 | ||
270 | struct XModulus | |
271 | { | |
272 | template <typename Sig> | |
273 | struct result; | |
274 | ||
275 | template <typename This, typename A0, typename A1> | |
276 | struct result<This(A0, A1)> | |
277 | : boost::remove_reference<A0> | |
278 | {}; | |
279 | ||
280 | template <typename A0, typename A1> | |
281 | A0 operator()(A0 const & a0, A1 const & a1) const | |
282 | { | |
283 | return a0 % a1; | |
284 | } | |
285 | ||
286 | }; | |
287 | ||
288 | struct XNegate | |
289 | { | |
290 | template <typename Sig> | |
291 | struct result; | |
292 | ||
293 | template <typename This, typename A0> | |
294 | struct result<This(A0)> | |
295 | : boost::remove_reference<A0> | |
296 | {}; | |
297 | ||
298 | template <typename A0> | |
299 | A0 operator()(A0 const & a0) const | |
300 | { | |
301 | return -a0; | |
302 | } | |
303 | }; | |
304 | ||
305 | struct XEqual | |
306 | { | |
307 | template <typename Sig> | |
308 | struct result; | |
309 | ||
310 | template <typename This, typename A0, typename A1> | |
311 | struct result<This(A0,A1)> | |
312 | { | |
313 | typedef bool type; | |
314 | }; | |
315 | ||
316 | template <typename A0, typename A1> | |
317 | bool operator()(A0 const & a0, A1 const & a1) const | |
318 | { | |
319 | return a0 == a1; | |
320 | } | |
321 | }; | |
322 | ||
323 | struct XNot_equal | |
324 | { | |
325 | template <typename Sig> | |
326 | struct result; | |
327 | ||
328 | template <typename This, typename A0, typename A1> | |
329 | struct result<This(A0,A1)> | |
330 | { | |
331 | typedef bool type; | |
332 | }; | |
333 | ||
334 | template <typename A0, typename A1> | |
335 | bool operator()(A0 const & a0, A1 const & a1) const | |
336 | { | |
337 | return a0 != a1; | |
338 | } | |
339 | }; | |
340 | ||
341 | struct XGreater | |
342 | { | |
343 | template <typename Sig> | |
344 | struct result; | |
345 | ||
346 | template <typename This, typename A0, typename A1> | |
347 | struct result<This(A0,A1)> | |
348 | { | |
349 | typedef bool type; | |
350 | }; | |
351 | ||
352 | template <typename A0, typename A1> | |
353 | bool operator()(A0 const & a0, A1 const & a1) const | |
354 | { | |
355 | return a0 > a1; | |
356 | } | |
357 | }; | |
358 | ||
359 | struct XLess | |
360 | { | |
361 | template <typename Sig> | |
362 | struct result; | |
363 | ||
364 | template <typename This, typename A0, typename A1> | |
365 | struct result<This(A0,A1)> | |
366 | { | |
367 | typedef bool type; | |
368 | }; | |
369 | ||
370 | template <typename A0, typename A1> | |
371 | bool operator()(A0 const & a0, A1 const & a1) const | |
372 | { | |
373 | return a0 < a1; | |
374 | } | |
375 | }; | |
376 | ||
377 | struct XGreater_equal | |
378 | { | |
379 | template <typename Sig> | |
380 | struct result; | |
381 | ||
382 | template <typename This, typename A0, typename A1> | |
383 | struct result<This(A0,A1)> | |
384 | { | |
385 | typedef bool type; | |
386 | }; | |
387 | ||
388 | template <typename A0, typename A1> | |
389 | bool operator()(A0 const & a0, A1 const & a1) const | |
390 | { | |
391 | return a0 >= a1; | |
392 | } | |
393 | }; | |
394 | ||
395 | struct XLess_equal | |
396 | { | |
397 | template <typename Sig> | |
398 | struct result; | |
399 | ||
400 | template <typename This, typename A0, typename A1> | |
401 | struct result<This(A0,A1)> | |
402 | { | |
403 | typedef bool type; | |
404 | }; | |
405 | ||
406 | template <typename A0, typename A1> | |
407 | bool operator()(A0 const & a0, A1 const & a1) const | |
408 | { | |
409 | return a0 <= a1; | |
410 | } | |
411 | }; | |
412 | ||
413 | struct XPositive | |
414 | { | |
415 | template <typename Sig> | |
416 | struct result; | |
417 | ||
418 | template <typename This, typename A0> | |
419 | struct result<This(A0)> | |
420 | { | |
421 | typedef bool type; | |
422 | }; | |
423 | ||
424 | template <typename A0> | |
425 | bool operator()(A0 const & a0) const | |
426 | { | |
427 | return a0 >= A0(0); | |
428 | } | |
429 | }; | |
430 | ||
431 | struct XLogical_and | |
432 | { | |
433 | template <typename Sig> | |
434 | struct result; | |
435 | ||
436 | template <typename This, typename A0, typename A1> | |
437 | struct result<This(A0,A1)> | |
438 | { | |
439 | typedef bool type; | |
440 | }; | |
441 | ||
442 | template <typename A0, typename A1> | |
443 | bool operator()(A0 const & a0, A1 const & a1) const | |
444 | { | |
445 | return a0 && a1; | |
446 | } | |
447 | }; | |
448 | ||
449 | struct XLogical_or | |
450 | { | |
451 | template <typename Sig> | |
452 | struct result; | |
453 | ||
454 | template <typename This, typename A0, typename A1> | |
455 | struct result<This(A0,A1)> | |
456 | { | |
457 | typedef bool type; | |
458 | }; | |
459 | ||
460 | template <typename A0, typename A1> | |
461 | bool operator()(A0 const & a0, A1 const & a1) const | |
462 | { | |
463 | return a0 || a1; | |
464 | } | |
465 | }; | |
466 | ||
467 | struct XLogical_not | |
468 | { | |
469 | template <typename Sig> | |
470 | struct result; | |
471 | ||
472 | template <typename This, typename A0> | |
473 | struct result<This(A0)> | |
474 | { | |
475 | typedef bool type; | |
476 | }; | |
477 | ||
478 | template <typename A0> | |
479 | bool operator()(A0 const & a0) const | |
480 | { | |
481 | return !a0; | |
482 | } | |
483 | }; | |
484 | ||
485 | struct XMin | |
486 | { | |
487 | template <typename Sig> | |
488 | struct result; | |
489 | ||
490 | template <typename This, typename A0, typename A1> | |
491 | struct result<This(A0, A1)> | |
492 | : boost::remove_reference<A0> | |
493 | {}; | |
494 | ||
495 | template <typename A0, typename A1> | |
496 | A0 operator()(A0 const & a0, A1 const & a1) const | |
497 | { | |
498 | if ( a0 < a1 ) return a0; else return a1; | |
499 | } | |
500 | ||
501 | }; | |
502 | ||
503 | struct XMax | |
504 | { | |
505 | template <typename Sig> | |
506 | struct result; | |
507 | ||
508 | template <typename This, typename A0, typename A1> | |
509 | struct result<This(A0, A1)> | |
510 | : boost::remove_reference<A0> | |
511 | {}; | |
512 | ||
513 | template <typename A0, typename A1> | |
514 | A0 operator()(A0 const & a0, A1 const & a1) const | |
515 | { | |
516 | if ( a0 < a1 ) return a1; else return a0; | |
517 | } | |
518 | ||
519 | }; | |
520 | ||
521 | struct XInc | |
522 | { | |
523 | template <typename Sig> | |
524 | struct result; | |
525 | ||
526 | template <typename This, typename A0> | |
527 | struct result<This(A0)> | |
528 | : boost::remove_reference<A0> | |
529 | {}; | |
530 | ||
531 | template <typename A0> | |
532 | A0 operator()(A0 const & a0) const | |
533 | { | |
534 | return a0 + 1; | |
535 | } | |
536 | ||
537 | }; | |
538 | ||
539 | struct XDec | |
540 | { | |
541 | template <typename Sig> | |
542 | struct result; | |
543 | ||
544 | template <typename This, typename A0> | |
545 | struct result<This(A0)> | |
546 | : boost::remove_reference<A0> | |
547 | {}; | |
548 | ||
549 | template <typename A0> | |
550 | A0 operator()(A0 const & a0) const | |
551 | { | |
552 | return a0 - 1; | |
553 | } | |
554 | ||
555 | }; | |
556 | ||
557 | struct XSin | |
558 | { | |
559 | template <typename Sig> | |
560 | struct result; | |
561 | ||
562 | template <typename This, typename A0> | |
563 | struct result<This(A0)> | |
564 | : boost::remove_reference<A0> | |
565 | {}; | |
566 | ||
567 | template <typename A0> | |
568 | A0 operator()(A0 const & a0) const | |
569 | { | |
570 | return std::sin(a0); | |
571 | } | |
572 | ||
573 | }; | |
574 | ||
575 | // Example of templated struct. | |
576 | // How do I make it callable? | |
577 | template <typename Result> | |
578 | struct what { | |
579 | ||
580 | typedef Result result_type; | |
581 | ||
582 | Result operator()(Result const & r) const | |
583 | { | |
584 | return r; | |
585 | } | |
586 | // what is not complete - error. | |
587 | //static boost::function1<Result,Result> res = what<Result>(); | |
588 | }; | |
589 | ||
590 | template <typename Result> | |
591 | struct what0 { | |
592 | ||
593 | typedef Result result_type; | |
594 | ||
595 | Result operator()() const | |
596 | { | |
597 | return Result(100); | |
598 | } | |
599 | ||
600 | }; | |
601 | ||
602 | ||
603 | template <class Result, class F> | |
604 | class MonomorphicWrapper0 /* : public c_fun_type<Res> */ | |
605 | { | |
606 | F f; | |
607 | public: | |
608 | typedef Result result_type; | |
609 | MonomorphicWrapper0( const F& g ) : f(g) {} | |
610 | Result operator()() const { | |
611 | return f(); | |
612 | } | |
613 | }; | |
614 | ||
615 | } | |
616 | ///////////////////////////////////////////////////////// | |
617 | // Look at this. How to use Phoenix with a templated | |
618 | // struct. First adapt with boost::function and then | |
619 | // convert that to Phoenix!! | |
620 | // I have not found out how to do it directly. | |
621 | ///////////////////////////////////////////////////////// | |
622 | boost::function1<int, int > what_int = impl::what<int>(); | |
623 | typedef boost::function1<int,int> fun1_int_int; | |
624 | typedef boost::function0<int> fun0_int; | |
625 | boost::function0<int> what0_int = impl::what0<int>(); | |
626 | BOOST_PHOENIX_ADAPT_FUNCTION(int,what,what_int,1) | |
627 | BOOST_PHOENIX_ADAPT_FUNCTION_NULLARY(int,what0,what0_int) | |
628 | // And this shows how to make them into argument callable functions. | |
629 | typedef boost::phoenix::function<fun1_int_int> What_arg; | |
630 | typedef boost::phoenix::function<fun0_int> What0_arg; | |
631 | What_arg what_arg(what_int); | |
632 | What0_arg what0_arg(what0_int); | |
633 | ||
634 | ||
635 | // To use these as arguments they have to be defined like this. | |
636 | typedef boost::phoenix::function<impl::XPlus> Plus; | |
637 | typedef boost::phoenix::function<impl::XMinus> Minus; | |
638 | typedef boost::phoenix::function<impl::XMultiplies> Multiplies; | |
639 | typedef boost::phoenix::function<impl::XDivides> Divides; | |
640 | typedef boost::phoenix::function<impl::XModulus> Modulus; | |
641 | typedef boost::phoenix::function<impl::XNegate> Negate; | |
642 | typedef boost::phoenix::function<impl::XEqual> Equal; | |
643 | typedef boost::phoenix::function<impl::XNot_equal> Not_equal; | |
644 | typedef boost::phoenix::function<impl::XGreater> Greater; | |
645 | typedef boost::phoenix::function<impl::XLess> Less; | |
646 | typedef boost::phoenix::function<impl::XGreater_equal> Greater_equal; | |
647 | typedef boost::phoenix::function<impl::XLess_equal> Less_equal; | |
648 | typedef boost::phoenix::function<impl::XPositive> Positive; | |
649 | typedef boost::phoenix::function<impl::XLogical_and> Logical_and; | |
650 | typedef boost::phoenix::function<impl::XLogical_or> Logical_or; | |
651 | typedef boost::phoenix::function<impl::XLogical_not> Logical_not; | |
652 | typedef boost::phoenix::function<impl::XMax> Max; | |
653 | typedef boost::phoenix::function<impl::XMin> Min; | |
654 | typedef boost::phoenix::function<impl::XInc> Inc; | |
655 | typedef boost::phoenix::function<impl::XDec> Dec; | |
656 | typedef boost::phoenix::function<impl::XSin> Sin; | |
657 | Plus plus; | |
658 | Minus minus; | |
659 | Multiplies multiplies; | |
660 | Divides divides; | |
661 | Modulus modulus; | |
662 | Negate negate; | |
663 | Equal equal; | |
664 | Not_equal not_equal; | |
665 | Greater greater; | |
666 | Less less; | |
667 | Greater_equal greater_equal; | |
668 | Less_equal less_equal; | |
669 | Positive positive; | |
670 | Logical_and logical_and; | |
671 | Logical_or logical_or; | |
672 | Logical_not logical_not; | |
673 | Max max; | |
674 | Min min; | |
675 | Inc inc; | |
676 | Dec dec; | |
677 | Sin sin; | |
678 | } | |
679 | ||
680 | } | |
681 | ||
682 | ||
683 | #endif |