diff options
Diffstat (limited to 'libs/lambda/test/bind_tests_advanced.cpp')
| -rw-r--r-- | libs/lambda/test/bind_tests_advanced.cpp | 420 |
1 files changed, 420 insertions, 0 deletions
diff --git a/libs/lambda/test/bind_tests_advanced.cpp b/libs/lambda/test/bind_tests_advanced.cpp new file mode 100644 index 000000000..d696e4999 --- /dev/null +++ b/libs/lambda/test/bind_tests_advanced.cpp @@ -0,0 +1,420 @@ +// 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/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> + + +using namespace boost::lambda; +namespace bl = boost::lambda; + +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); + template <class T> struct sig { typedef result_type type; }; + + result_type operator()() const { return sum_or_product; } +}; + +void test_nested_binds() +{ + 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)); + + // 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)); + +} + + +void test_unlambda() { + + 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); + + // 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); +} + + + + +// protect ------------------------------------------------------------ + +// protect protects a lambda functor from argument substitution. +// protect is useful e.g. with nested stl algorithm calls. + +namespace ll { + +struct for_each { + + // 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; + }; + + 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 + +void test_protect() +{ + int i = 0; + int b[3][5]; + int* a[3]; + + for(int j=0; j<3; ++j) a[j] = b[j]; + + std::for_each(a, a+3, + bind(ll::for_each(), _1, _1 + 5, protect(_1 = ++var(i)))); + + // 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; + + std::for_each(a, a+3, + bind(ll::for_each(), _1, _1 + 5, + protect(sum += _1)) + ); + BOOST_CHECK(sum == (1+15)*15/2); + + sum = 0; + + std::for_each(a, a+3, + bind(ll::for_each(), _1, _1 + 5, + sum += 1 + protect(_1)) // add element count + ); + BOOST_CHECK(sum == (1+15)*15/2 + 15); + + (1 + protect(_1))(sum); + + int k = 0; + ((k += constant(1)) += protect(constant(2)))(); + BOOST_CHECK(k==1); + + k = 0; + ((k += constant(1)) += protect(constant(2)))()(); + 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() { + +// 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, make_const(7)); + (_1 + _2)(bind(&sum_0), make_const(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), make_const(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)(ret<int>(_1 + _2), a, b) == 11); + BOOST_CHECK(ret<int>(bind(_1, _2, _3))(_1 + _2, a, b) == 11); + BOOST_CHECK(bind<int>(_1, _2, _3)(_1 + _2, a, b) == 11); + + bind(_1,1.0)(_1+_1); + return; + +} + + +void test_const_parameters() { + + // (_1 + _2)(1, 2); // this would fail, + + // Either make arguments const: + BOOST_CHECK((_1 + _2)(make_const(1), make_const(2)) == 3); + + // Or use const_parameters: + BOOST_CHECK(const_parameters(_1 + _2)(1, 2) == 3); + + + +} + +void test_rvalue_arguments() +{ + // Not quite working yet. + // Problems with visual 7.1 + // BOOST_CHECK((_1 + _2)(1, 2) == 3); +} + +void test_break_const() +{ + + // break_const is currently unnecessary, as LL supports perfect forwarding + // for up to there argument lambda functors, and LL does not support + // lambda functors with more than 3 args. + + // I'll keep the test case around anyway, if more arguments will be supported + // in the future. + + + + // break_const breaks constness! Be careful! + // You need this only if you need to have side effects on some argument(s) + // and some arguments are non-const rvalues and your lambda functors + // take more than 3 arguments. + + + int i = 1; + // OLD COMMENT: (_1 += _2)(i, 2) // fails, 2 is a non-const rvalue + // OLD COMMENT: const_parameters(_1 += _2)(i, 2) // fails, side-effect to i + break_const(_1 += _2)(i, 2); // ok + BOOST_CHECK(i == 3); +} + +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_const_parameters(); + test_rvalue_arguments(); + test_break_const(); + test_sig(); + test_abstract(); + return 0; +} |