| //////////////////////////////////////////////////////////////////////////// |
| // lazy operator.hpp |
| // |
| // Build lazy operations for Phoenix equivalents for FC++ |
| // |
| // These are equivalents of the Boost FC++ functoids in operator.hpp |
| // |
| // Implemented so far: |
| // |
| // make_pair |
| // plus minus multiplies divides modulus |
| // negate equal not_equal greater less |
| // greater_equal less_equal positive |
| // logical_and logical_or |
| // logical_not min max inc dec |
| // |
| // These are not from the FC++ operator.hpp but were made for testing purposes. |
| // |
| // identity (renamed id) |
| // sin |
| // |
| // These are now being modified to use boost::phoenix::function |
| // so that they are available for use as arguments. |
| // Types are being defined in capitals e.g. Id id; |
| //////////////////////////////////////////////////////////////////////////// |
| /*============================================================================= |
| Copyright (c) 2000-2003 Brian McNamara and Yannis Smaragdakis |
| Copyright (c) 2001-2007 Joel de Guzman |
| Copyright (c) 2015 John Fletcher |
| |
| 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_PHOENIX_FUNCTION_LAZY_OPERATOR |
| #define BOOST_PHOENIX_FUNCTION_LAZY_OPERATOR |
| |
| #include <cmath> |
| #include <cstdlib> |
| #include <boost/phoenix/core.hpp> |
| #include <boost/phoenix/function.hpp> |
| #include <boost/function.hpp> |
| |
| namespace boost { |
| |
| namespace phoenix { |
| |
| ////////////////////////////////////////////////////////////////////// |
| // a_unique_type_for_nil |
| ////////////////////////////////////////////////////////////////////// |
| |
| // This may need to be moved elsewhere to define reuser. |
| struct a_unique_type_for_nil { |
| bool operator==( a_unique_type_for_nil ) const { return true; } |
| bool operator< ( a_unique_type_for_nil ) const { return false; } |
| typedef a_unique_type_for_nil value_type; |
| }; |
| // This maybe put into a namespace. |
| a_unique_type_for_nil NIL; |
| |
| ////////////////////////////////////////////////////////////////////// |
| // lazy_exception - renamed from fcpp_exception. |
| ////////////////////////////////////////////////////////////////////// |
| |
| #ifndef BOOST_PHOENIX_NO_LAZY_EXCEPTIONS |
| struct lazy_exception : public std::exception { |
| const char* s; |
| lazy_exception( const char* ss ) : s(ss) {} |
| const char* what() const throw() { return s; } |
| }; |
| #endif |
| |
| ////////////////////////////////////////////////////////////////////// |
| |
| // in ref_count.hpp in BoostFC++ |
| typedef unsigned int RefCountType; |
| |
| namespace impl { |
| |
| // Implemented early, moved from lazy_signature.hpp |
| template <class T> |
| struct remove_RC |
| { |
| typedef typename boost::remove_reference<T>::type TT; |
| typedef typename boost::remove_const<TT>::type type; |
| }; |
| |
| struct XId |
| { |
| template <typename Sig> |
| struct result; |
| |
| template <typename This, typename A0> |
| struct result<This(A0)> |
| : boost::remove_reference<A0> |
| {}; |
| |
| template <typename A0> |
| A0 operator()(A0 const & a0) const |
| { |
| return a0; |
| } |
| |
| }; |
| |
| |
| } |
| |
| typedef boost::phoenix::function<impl::XId> Id; |
| Id id; |
| |
| #ifdef BOOST_RESULT_OF_USE_TR1 |
| // Experiment following examples in |
| // phoenix/stl/container/container.hpp |
| |
| namespace result_of { |
| |
| template < |
| typename Arg1 |
| , typename Arg2 |
| > |
| class make_pair |
| { |
| public: |
| typedef typename impl::remove_RC<Arg1>::type Arg1Type; |
| typedef typename impl::remove_RC<Arg2>::type Arg2Type; |
| typedef std::pair<Arg1Type,Arg2Type> type; |
| typedef std::pair<Arg1Type,Arg2Type> result_type; |
| }; |
| } |
| #endif |
| |
| namespace impl |
| { |
| |
| struct XMake_pair { |
| |
| |
| #ifdef BOOST_RESULT_OF_USE_TR1 |
| template <typename Sig> |
| struct result; |
| // This fails with -O2 unless refs are removed from A1 and A2. |
| template <typename This, typename A0, typename A1> |
| struct result<This(A0, A1)> |
| { |
| typedef typename result_of::make_pair<A0,A1>::type type; |
| }; |
| #else |
| template <typename Sig> |
| struct result; |
| |
| template <typename This, typename A0, typename A1> |
| struct result<This(A0, A1)> |
| : boost::remove_reference<std::pair<A0, A1> > |
| {}; |
| |
| #endif |
| |
| |
| template <typename A0, typename A1> |
| #ifdef BOOST_RESULT_OF_USE_TR1 |
| typename result<XMake_pair(A0,A1)>::type |
| #else |
| std::pair<A0, A1> |
| #endif |
| operator()(A0 const & a0, A1 const & a1) const |
| { |
| return std::make_pair(a0,a1); |
| } |
| |
| }; |
| } |
| |
| typedef boost::phoenix::function<impl::XMake_pair> Make_pair; |
| Make_pair make_pair; |
| |
| namespace impl |
| { |
| |
| // For now I will leave the return type deduction as it is. |
| // I want to look at bringing in the sort of type deduction for |
| // mixed types which I have in FC++. |
| // Also I could look at the case where one of the arguments is |
| // another functor or a Phoenix placeholder. |
| struct XPlus |
| { |
| template <typename Sig> |
| struct result; |
| |
| template <typename This, typename A0, typename A1> |
| struct result<This(A0, A1)> |
| : boost::remove_reference<A0> |
| {}; |
| |
| template <typename This, typename A0, typename A1, typename A2> |
| struct result<This(A0, A1, A2)> |
| : boost::remove_reference<A0> |
| {}; |
| |
| template <typename A0, typename A1> |
| A0 operator()(A0 const & a0, A1 const & a1) const |
| { |
| //A0 res = a0 + a1; |
| //return res; |
| return a0 + a1; |
| } |
| |
| template <typename A0, typename A1, typename A2> |
| A0 operator()(A0 const & a0, A1 const & a1, A2 const & a2) const |
| { |
| return a0 + a1 + a2; |
| } |
| }; |
| |
| struct XMinus |
| { |
| template <typename Sig> |
| struct result; |
| |
| template <typename This, typename A0, typename A1> |
| struct result<This(A0, A1)> |
| : boost::remove_reference<A0> |
| {}; |
| |
| template <typename A0, typename A1> |
| A0 operator()(A0 const & a0, A1 const & a1) const |
| { |
| return a0 - a1; |
| } |
| |
| }; |
| |
| struct XMultiplies |
| { |
| template <typename Sig> |
| struct result; |
| |
| template <typename This, typename A0, typename A1> |
| struct result<This(A0, A1)> |
| : boost::remove_reference<A0> |
| {}; |
| |
| template <typename A0, typename A1> |
| A0 operator()(A0 const & a0, A1 const & a1) const |
| { |
| return a0 * a1; |
| } |
| |
| }; |
| |
| struct XDivides |
| { |
| template <typename Sig> |
| struct result; |
| |
| template <typename This, typename A0, typename A1> |
| struct result<This(A0, A1)> |
| : boost::remove_reference<A0> |
| {}; |
| |
| template <typename A0, typename A1> |
| A0 operator()(A0 const & a0, A1 const & a1) const |
| { |
| return a0 / a1; |
| } |
| |
| }; |
| |
| struct XModulus |
| { |
| template <typename Sig> |
| struct result; |
| |
| template <typename This, typename A0, typename A1> |
| struct result<This(A0, A1)> |
| : boost::remove_reference<A0> |
| {}; |
| |
| template <typename A0, typename A1> |
| A0 operator()(A0 const & a0, A1 const & a1) const |
| { |
| return a0 % a1; |
| } |
| |
| }; |
| |
| struct XNegate |
| { |
| template <typename Sig> |
| struct result; |
| |
| template <typename This, typename A0> |
| struct result<This(A0)> |
| : boost::remove_reference<A0> |
| {}; |
| |
| template <typename A0> |
| A0 operator()(A0 const & a0) const |
| { |
| return -a0; |
| } |
| }; |
| |
| struct XEqual |
| { |
| template <typename Sig> |
| struct result; |
| |
| template <typename This, typename A0, typename A1> |
| struct result<This(A0,A1)> |
| { |
| typedef bool type; |
| }; |
| |
| template <typename A0, typename A1> |
| bool operator()(A0 const & a0, A1 const & a1) const |
| { |
| return a0 == a1; |
| } |
| }; |
| |
| struct XNot_equal |
| { |
| template <typename Sig> |
| struct result; |
| |
| template <typename This, typename A0, typename A1> |
| struct result<This(A0,A1)> |
| { |
| typedef bool type; |
| }; |
| |
| template <typename A0, typename A1> |
| bool operator()(A0 const & a0, A1 const & a1) const |
| { |
| return a0 != a1; |
| } |
| }; |
| |
| struct XGreater |
| { |
| template <typename Sig> |
| struct result; |
| |
| template <typename This, typename A0, typename A1> |
| struct result<This(A0,A1)> |
| { |
| typedef bool type; |
| }; |
| |
| template <typename A0, typename A1> |
| bool operator()(A0 const & a0, A1 const & a1) const |
| { |
| return a0 > a1; |
| } |
| }; |
| |
| struct XLess |
| { |
| template <typename Sig> |
| struct result; |
| |
| template <typename This, typename A0, typename A1> |
| struct result<This(A0,A1)> |
| { |
| typedef bool type; |
| }; |
| |
| template <typename A0, typename A1> |
| bool operator()(A0 const & a0, A1 const & a1) const |
| { |
| return a0 < a1; |
| } |
| }; |
| |
| struct XGreater_equal |
| { |
| template <typename Sig> |
| struct result; |
| |
| template <typename This, typename A0, typename A1> |
| struct result<This(A0,A1)> |
| { |
| typedef bool type; |
| }; |
| |
| template <typename A0, typename A1> |
| bool operator()(A0 const & a0, A1 const & a1) const |
| { |
| return a0 >= a1; |
| } |
| }; |
| |
| struct XLess_equal |
| { |
| template <typename Sig> |
| struct result; |
| |
| template <typename This, typename A0, typename A1> |
| struct result<This(A0,A1)> |
| { |
| typedef bool type; |
| }; |
| |
| template <typename A0, typename A1> |
| bool operator()(A0 const & a0, A1 const & a1) const |
| { |
| return a0 <= a1; |
| } |
| }; |
| |
| struct XPositive |
| { |
| template <typename Sig> |
| struct result; |
| |
| template <typename This, typename A0> |
| struct result<This(A0)> |
| { |
| typedef bool type; |
| }; |
| |
| template <typename A0> |
| bool operator()(A0 const & a0) const |
| { |
| return a0 >= A0(0); |
| } |
| }; |
| |
| struct XLogical_and |
| { |
| template <typename Sig> |
| struct result; |
| |
| template <typename This, typename A0, typename A1> |
| struct result<This(A0,A1)> |
| { |
| typedef bool type; |
| }; |
| |
| template <typename A0, typename A1> |
| bool operator()(A0 const & a0, A1 const & a1) const |
| { |
| return a0 && a1; |
| } |
| }; |
| |
| struct XLogical_or |
| { |
| template <typename Sig> |
| struct result; |
| |
| template <typename This, typename A0, typename A1> |
| struct result<This(A0,A1)> |
| { |
| typedef bool type; |
| }; |
| |
| template <typename A0, typename A1> |
| bool operator()(A0 const & a0, A1 const & a1) const |
| { |
| return a0 || a1; |
| } |
| }; |
| |
| struct XLogical_not |
| { |
| template <typename Sig> |
| struct result; |
| |
| template <typename This, typename A0> |
| struct result<This(A0)> |
| { |
| typedef bool type; |
| }; |
| |
| template <typename A0> |
| bool operator()(A0 const & a0) const |
| { |
| return !a0; |
| } |
| }; |
| |
| struct XMin |
| { |
| template <typename Sig> |
| struct result; |
| |
| template <typename This, typename A0, typename A1> |
| struct result<This(A0, A1)> |
| : boost::remove_reference<A0> |
| {}; |
| |
| template <typename A0, typename A1> |
| A0 operator()(A0 const & a0, A1 const & a1) const |
| { |
| if ( a0 < a1 ) return a0; else return a1; |
| } |
| |
| }; |
| |
| struct XMax |
| { |
| template <typename Sig> |
| struct result; |
| |
| template <typename This, typename A0, typename A1> |
| struct result<This(A0, A1)> |
| : boost::remove_reference<A0> |
| {}; |
| |
| template <typename A0, typename A1> |
| A0 operator()(A0 const & a0, A1 const & a1) const |
| { |
| if ( a0 < a1 ) return a1; else return a0; |
| } |
| |
| }; |
| |
| struct XInc |
| { |
| template <typename Sig> |
| struct result; |
| |
| template <typename This, typename A0> |
| struct result<This(A0)> |
| : boost::remove_reference<A0> |
| {}; |
| |
| template <typename A0> |
| A0 operator()(A0 const & a0) const |
| { |
| return a0 + 1; |
| } |
| |
| }; |
| |
| struct XDec |
| { |
| template <typename Sig> |
| struct result; |
| |
| template <typename This, typename A0> |
| struct result<This(A0)> |
| : boost::remove_reference<A0> |
| {}; |
| |
| template <typename A0> |
| A0 operator()(A0 const & a0) const |
| { |
| return a0 - 1; |
| } |
| |
| }; |
| |
| struct XSin |
| { |
| template <typename Sig> |
| struct result; |
| |
| template <typename This, typename A0> |
| struct result<This(A0)> |
| : boost::remove_reference<A0> |
| {}; |
| |
| template <typename A0> |
| A0 operator()(A0 const & a0) const |
| { |
| return std::sin(a0); |
| } |
| |
| }; |
| |
| // Example of templated struct. |
| // How do I make it callable? |
| template <typename Result> |
| struct what { |
| |
| typedef Result result_type; |
| |
| Result operator()(Result const & r) const |
| { |
| return r; |
| } |
| // what is not complete - error. |
| //static boost::function1<Result,Result> res = what<Result>(); |
| }; |
| |
| template <typename Result> |
| struct what0 { |
| |
| typedef Result result_type; |
| |
| Result operator()() const |
| { |
| return Result(100); |
| } |
| |
| }; |
| |
| |
| template <class Result, class F> |
| class MonomorphicWrapper0 /* : public c_fun_type<Res> */ |
| { |
| F f; |
| public: |
| typedef Result result_type; |
| MonomorphicWrapper0( const F& g ) : f(g) {} |
| Result operator()() const { |
| return f(); |
| } |
| }; |
| |
| } |
| ///////////////////////////////////////////////////////// |
| // Look at this. How to use Phoenix with a templated |
| // struct. First adapt with boost::function and then |
| // convert that to Phoenix!! |
| // I have not found out how to do it directly. |
| ///////////////////////////////////////////////////////// |
| boost::function1<int, int > what_int = impl::what<int>(); |
| typedef boost::function1<int,int> fun1_int_int; |
| typedef boost::function0<int> fun0_int; |
| boost::function0<int> what0_int = impl::what0<int>(); |
| BOOST_PHOENIX_ADAPT_FUNCTION(int,what,what_int,1) |
| BOOST_PHOENIX_ADAPT_FUNCTION_NULLARY(int,what0,what0_int) |
| // And this shows how to make them into argument callable functions. |
| typedef boost::phoenix::function<fun1_int_int> What_arg; |
| typedef boost::phoenix::function<fun0_int> What0_arg; |
| What_arg what_arg(what_int); |
| What0_arg what0_arg(what0_int); |
| |
| |
| // To use these as arguments they have to be defined like this. |
| typedef boost::phoenix::function<impl::XPlus> Plus; |
| typedef boost::phoenix::function<impl::XMinus> Minus; |
| typedef boost::phoenix::function<impl::XMultiplies> Multiplies; |
| typedef boost::phoenix::function<impl::XDivides> Divides; |
| typedef boost::phoenix::function<impl::XModulus> Modulus; |
| typedef boost::phoenix::function<impl::XNegate> Negate; |
| typedef boost::phoenix::function<impl::XEqual> Equal; |
| typedef boost::phoenix::function<impl::XNot_equal> Not_equal; |
| typedef boost::phoenix::function<impl::XGreater> Greater; |
| typedef boost::phoenix::function<impl::XLess> Less; |
| typedef boost::phoenix::function<impl::XGreater_equal> Greater_equal; |
| typedef boost::phoenix::function<impl::XLess_equal> Less_equal; |
| typedef boost::phoenix::function<impl::XPositive> Positive; |
| typedef boost::phoenix::function<impl::XLogical_and> Logical_and; |
| typedef boost::phoenix::function<impl::XLogical_or> Logical_or; |
| typedef boost::phoenix::function<impl::XLogical_not> Logical_not; |
| typedef boost::phoenix::function<impl::XMax> Max; |
| typedef boost::phoenix::function<impl::XMin> Min; |
| typedef boost::phoenix::function<impl::XInc> Inc; |
| typedef boost::phoenix::function<impl::XDec> Dec; |
| typedef boost::phoenix::function<impl::XSin> Sin; |
| Plus plus; |
| Minus minus; |
| Multiplies multiplies; |
| Divides divides; |
| Modulus modulus; |
| Negate negate; |
| Equal equal; |
| Not_equal not_equal; |
| Greater greater; |
| Less less; |
| Greater_equal greater_equal; |
| Less_equal less_equal; |
| Positive positive; |
| Logical_and logical_and; |
| Logical_or logical_or; |
| Logical_not logical_not; |
| Max max; |
| Min min; |
| Inc inc; |
| Dec dec; |
| Sin sin; |
| } |
| |
| } |
| |
| |
| #endif |
