| // bind_tests_advanced.cpp -- The Boost Lambda Library ------------------ |
| // |
| // Copyright (C) 2000-2003 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi) |
| // Copyright (C) 2000-2003 Gary Powell (powellg@amazon.com) |
| // Copyright (C) 2010 Steven Watanabe |
| // |
| // 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) |
| // |
| // For more information, see www.boost.org |
| |
| // ----------------------------------------------------------------------- |
| |
| |
| #include <boost/test/minimal.hpp> // see "Header Implementation Option" |
| |
| /* |
| #include "boost/lambda/lambda.hpp" |
| #include "boost/lambda/bind.hpp" |
| */ |
| #include <boost/phoenix/core.hpp> |
| #include <boost/phoenix/operator.hpp> |
| #include <boost/phoenix/bind.hpp> |
| #include <boost/phoenix/scope.hpp> |
| |
| #include "boost/any.hpp" |
| #include "boost/type_traits/is_reference.hpp" |
| #include "boost/mpl/assert.hpp" |
| #include "boost/mpl/if.hpp" |
| |
| #include <iostream> |
| |
| #include <functional> |
| |
| #include <algorithm> |
| |
| namespace phoenix = boost::phoenix; |
| |
| int sum_0() { return 0; } |
| int sum_1(int a) { return a; } |
| int sum_2(int a, int b) { return a+b; } |
| |
| int product_2(int a, int b) { return a*b; } |
| |
| // unary function that returns a pointer to a binary function |
| typedef int (*fptr_type)(int, int); |
| fptr_type sum_or_product(bool x) { |
| return x ? sum_2 : product_2; |
| } |
| |
| // a nullary functor that returns a pointer to a unary function that |
| // returns a pointer to a binary function. |
| struct which_one { |
| typedef fptr_type (*result_type)(bool x); |
| |
| // Was: |
| // template <class T> struct sig { typedef result_type type; }; |
| // phoenix follows the standard result_of protocol |
| |
| result_type operator()() const { return sum_or_product; } |
| }; |
| |
| void test_nested_binds() |
| { |
| using phoenix::bind; |
| using phoenix::placeholders::_1; |
| using phoenix::placeholders::_2; |
| using phoenix::placeholders::_3; |
| int j = 2; int k = 3; |
| |
| // bind calls can be nested (the target function can be a lambda functor) |
| // The interpretation is, that the innermost lambda functor returns something |
| // that is bindable (another lambda functor, function pointer ...) |
| bool condition; |
| |
| condition = true; |
| BOOST_CHECK(bind(bind(&sum_or_product, _1), 1, 2)(condition)==3); |
| BOOST_CHECK(bind(bind(&sum_or_product, _1), _2, _3)(condition, j, k)==5); |
| |
| condition = false; |
| BOOST_CHECK(bind(bind(&sum_or_product, _1), 1, 2)(condition)==2); |
| BOOST_CHECK(bind(bind(&sum_or_product, _1), _2, _3)(condition, j, k)==6); |
| |
| |
| which_one wo; |
| BOOST_CHECK(bind(bind(bind(wo), _1), _2, _3)(condition, j, k)==6); |
| |
| |
| return; |
| } |
| |
| |
| // unlambda ------------------------------------------------- |
| |
| // Sometimes it may be necessary to prevent the argument substitution of |
| // taking place. For example, we may end up with a nested bind expression |
| // inadvertently when using the target function is received as a parameter |
| |
| template<class F> |
| int call_with_100(const F& f) { |
| |
| |
| |
| // bind(f, _1)(make_const(100)); |
| // This would result in; |
| // bind(_1 + 1, _1)(make_const(100)) , which would be a compile time error |
| |
| //return bl::bind(unlambda(f), _1)(make_const(100)); |
| return 5; |
| |
| // for other functors than lambda functors, unlambda has no effect |
| // (except for making them const) |
| } |
| |
| template<class F> |
| int call_with_101(const F& f) { |
| |
| //return bind(unlambda(f), _1)(make_const(101)); |
| return 5; |
| |
| } |
| |
| |
| void test_unlambda() { |
| |
| using phoenix::placeholders::_1; |
| using phoenix::placeholders::_2; |
| |
| int i = 1; |
| |
| //BOOST_CHECK(unlambda(_1 + _2)(i, i) == 2); |
| //BOOST_CHECK(unlambda(++var(i))() == 2); |
| //BOOST_CHECK(call_with_100(_1 + 1) == 101); |
| |
| |
| //BOOST_CHECK(call_with_101(_1 + 1) == 102); |
| |
| //BOOST_CHECK(call_with_100(bl::bind(std_functor(std::bind1st(std::plus<int>(), 1)), _1)) == 101); |
| |
| // Was: |
| // std_functor insturcts LL that the functor defines a result_type typedef |
| // rather than a sig template. |
| //bl::bind(std_functor(std::plus<int>()), _1, _2)(i, i); |
| // Standard functors can be used without any further action needed. |
| phoenix::bind(std::plus<int>(), _1, _2)(i, i); |
| } |
| |
| |
| |
| |
| // protect ------------------------------------------------------------ |
| |
| // protect protects a lambda functor from argument substitution. |
| // protect is useful e.g. with nested stl algorithm calls. |
| |
| #if 0 |
| namespace ll { |
| |
| struct for_each { |
| |
| // Was: |
| // note, std::for_each returns it's last argument |
| // We want the same behaviour from our ll::for_each. |
| // However, the functor can be called with any arguments, and |
| // the return type thus depends on the argument types. |
| |
| // 1. Provide a sig class member template: |
| |
| // The return type deduction system instantiate this class as: |
| // sig<Args>::type, where Args is a boost::tuples::cons-list |
| // The head type is the function object type itself |
| // cv-qualified (so it is possilbe to provide different return types |
| // for differently cv-qualified operator()'s. |
| |
| // The tail type is the list of the types of the actual arguments the |
| // function was called with. |
| // So sig should contain a typedef type, which defines a mapping from |
| // the operator() arguments to its return type. |
| // Note, that it is possible to provide different sigs for the same functor |
| // if the functor has several operator()'s, even if they have different |
| // number of arguments. |
| |
| // Note, that the argument types in Args are guaranteed to be non-reference |
| // types, but they can have cv-qualifiers. |
| |
| // template <class Args> |
| //struct sig { |
| // typedef typename boost::remove_const< |
| // typename boost::tuples::element<3, Args>::type |
| // >::type type; |
| //}; |
| |
| // We follow the result_of protocol ... |
| template <typename Sig> |
| struct result; |
| |
| template <typename This, typename A, typename B, typename C> |
| struct result<This(A&,B&,C&)> |
| {typedef C type;}; |
| |
| template <class A, class B, class C> |
| C |
| operator()(const A& a, const B& b, const C& c) const |
| { return std::for_each(a, b, c);} |
| }; |
| |
| } // end of ll namespace |
| #endif |
| |
| void test_protect() |
| { |
| using phoenix::placeholders::_1; |
| int i = 0; |
| int b[3][5]; |
| int* a[3]; |
| |
| for(int j=0; j<3; ++j) a[j] = b[j]; |
| |
| // Was: |
| //std::for_each(a, a+3, |
| // bind(ll::for_each(), _1, _1 + 5, protect(_1 = ++var(i)))); |
| #if 0 |
| std::for_each(a, a+3, |
| phoenix::bind(ll::for_each(), _1, _1 + 5, phoenix::lambda[_1 = ++phoenix::ref(i)])); |
| #endif |
| |
| |
| // This is how you could output the values (it is uncommented, no output |
| // from a regression test file): |
| // std::for_each(a, a+3, |
| // bind(ll::for_each(), _1, _1 + 5, |
| // std::cout << constant("\nLine ") << (&_1 - a) << " : " |
| // << protect(_1) |
| // ) |
| // ); |
| |
| int sum = 0; |
| |
| // Was: |
| //std::for_each(a, a+3, |
| // bind(ll::for_each(), _1, _1 + 5, |
| // protect(sum += _1)) |
| // ); |
| #if 0 |
| std::for_each(a, a+3, |
| phoenix::bind(ll::for_each(), _1, _1 + 5, |
| phoenix::lambda[phoenix::ref(sum) += _1]) |
| ); |
| BOOST_CHECK(sum == (1+15)*15/2); |
| #endif |
| |
| sum = 0; |
| |
| // Was: |
| //std::for_each(a, a+3, |
| // bind(ll::for_each(), _1, _1 + 5, |
| // sum += 1 + protect(_1)) // add element count |
| // ); |
| #if 0 |
| std::for_each(a, a+3, |
| phoenix::bind(ll::for_each(), _1, _1 + 5, |
| phoenix::ref(sum) += 1 + phoenix::lambda[_1]) // add element count |
| ); |
| BOOST_CHECK(sum == (1+15)*15/2 + 15); |
| #endif |
| |
| // Was: |
| //(1 + protect(_1))(sum); |
| (1 + phoenix::lambda[_1])(sum); |
| |
| int k = 0; |
| // Was: |
| //((k += constant(1)) += protect(constant(2)))(); |
| ((phoenix::ref(k) += 1) += phoenix::lambda[phoenix::cref(2)])(); |
| BOOST_CHECK(k==1); |
| |
| k = 0; |
| // Was: |
| //((k += constant(1)) += protect(constant(2)))()(); |
| //((phoenix::ref(k) += 1) += phoenix::lambda[std::cout << phoenix::cref("ok ...\n"), phoenix::cref(2)])()(); |
| //std::cout << ((phoenix::ref(k) += 1) + phoenix::lambda[phoenix::cref(2)])()() << "\n"; |
| ((phoenix::ref(k) += 1) += 2)(); |
| std::cout << k << "\n"; |
| BOOST_CHECK(k==3); |
| |
| // note, the following doesn't work: |
| |
| // ((var(k) = constant(1)) = protect(constant(2)))(); |
| |
| // (var(k) = constant(1))() returns int& and thus the |
| // second assignment fails. |
| |
| // We should have something like: |
| // bind(var, var(k) = constant(1)) = protect(constant(2)))(); |
| // But currently var is not bindable. |
| |
| // The same goes with ret. A bindable ret could be handy sometimes as well |
| // (protect(std::cout << _1), std::cout << _1)(i)(j); does not work |
| // because the comma operator tries to store the result of the evaluation |
| // of std::cout << _1 as a copy (and you can't copy std::ostream). |
| // something like this: |
| // (protect(std::cout << _1), bind(ref, std::cout << _1))(i)(j); |
| |
| |
| // the stuff below works, but we do not want extra output to |
| // cout, must be changed to stringstreams but stringstreams do not |
| // work due to a bug in the type deduction. Will be fixed... |
| #if 0 |
| // But for now, ref is not bindable. There are other ways around this: |
| |
| int x = 1, y = 2; |
| (protect(std::cout << _1), (std::cout << _1, 0))(x)(y); |
| |
| // added one dummy value to make the argument to comma an int |
| // instead of ostream& |
| |
| // Note, the same problem is more apparent without protect |
| // (std::cout << 1, std::cout << constant(2))(); // does not work |
| |
| (boost::ref(std::cout << 1), std::cout << constant(2))(); // this does |
| |
| #endif |
| |
| } |
| |
| |
| void test_lambda_functors_as_arguments_to_lambda_functors() { |
| using phoenix::bind; |
| using phoenix::cref; |
| using phoenix::placeholders::_1; |
| using phoenix::placeholders::_2; |
| using phoenix::placeholders::_3; |
| |
| // lambda functor is a function object, and can therefore be used |
| // as an argument to another lambda functors function call object. |
| |
| // Note however, that the argument/type substitution is not entered again. |
| // This means, that something like this will not work: |
| |
| (_1 + _2)(_1, cref(7)); |
| (_1 + _2)(bind(&sum_0), cref(7)); |
| |
| // or it does work, but the effect is not to call |
| // sum_0() + 7, but rather |
| // bind(sum_0) + 7, which results in another lambda functor |
| // (lambda functor + int) and can be called again |
| BOOST_CHECK((_1 + _2)(bind(&sum_0), cref(7))() == 7); |
| |
| int i = 3, j = 12; |
| BOOST_CHECK((_1 - _2)(_2, _1)(i, j) == j - i); |
| |
| // also, note that lambda functor are no special case for bind if received |
| // as a parameter. In oder to be bindable, the functor must |
| // defint the sig template, or then |
| // the return type must be defined within the bind call. Lambda functors |
| // do define the sig template, so if the return type deduction system |
| // covers the case, there is no need to specify the return type |
| // explicitly. |
| |
| int a = 5, b = 6; |
| |
| // Let type deduction find out the return type |
| //BOOST_CHECK(bind(_1, _2, _3)(unlambda(_1 + _2), a, b) == 11); |
| |
| //specify it yourself: |
| BOOST_CHECK(bind(_1, _2, _3)(_1 + _2, a, b) == 11); |
| |
| bind(_1,1.0)(_1+_1); |
| return; |
| |
| } |
| /* |
| template<class T> |
| struct func { |
| template<class Args> |
| struct sig { |
| typedef typename boost::tuples::element<1, Args>::type arg1; |
| // If the argument type is not the same as the expected type, |
| // return void, which will cause an error. Note that we |
| // can't just assert that the types are the same, because |
| // both const and non-const versions can be instantiated |
| // even though only one is ultimately used. |
| typedef typename boost::mpl::if_<boost::is_same<arg1, T>, |
| typename boost::remove_const<arg1>::type, |
| void |
| >::type type; |
| }; |
| template<class U> |
| U operator()(const U& arg) const { |
| return arg; |
| } |
| }; |
| |
| void test_sig() |
| { |
| int i = 1; |
| BOOST_CHECK(bind(func<int>(), 1)() == 1); |
| BOOST_CHECK(bind(func<const int>(), _1)(static_cast<const int&>(i)) == 1); |
| BOOST_CHECK(bind(func<int>(), _1)(i) == 1); |
| } |
| |
| class base { |
| public: |
| virtual int foo() = 0; |
| }; |
| |
| class derived : public base { |
| public: |
| virtual int foo() { |
| return 1; |
| } |
| }; |
| |
| void test_abstract() |
| { |
| derived d; |
| base& b = d; |
| BOOST_CHECK(bind(&base::foo, var(b))() == 1); |
| BOOST_CHECK(bind(&base::foo, *_1)(&b) == 1); |
| } |
| */ |
| |
| int test_main(int, char *[]) { |
| |
| test_nested_binds(); |
| test_unlambda(); |
| test_protect(); |
| test_lambda_functors_as_arguments_to_lambda_functors(); |
| //test_sig(); |
| //test_abstract(); |
| return 0; |
| } |