| /*============================================================================= |
| Copyright (c) 2001-2006 Joel de Guzman |
| Copyright (c) 2007 Dan Marsden |
| |
| 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) |
| ==============================================================================*/ |
| #include <boost/detail/lightweight_test.hpp> |
| #include <boost/fusion/container/vector/vector.hpp> |
| #include <boost/fusion/adapted/mpl.hpp> |
| #include <boost/fusion/sequence/io/out.hpp> |
| #include <boost/fusion/container/generation/make_vector.hpp> |
| #include <boost/fusion/sequence/comparison/equal_to.hpp> |
| #include <boost/fusion/algorithm/transformation/transform.hpp> |
| #include <boost/type_traits/is_class.hpp> |
| #include <boost/type_traits/is_same.hpp> |
| #include <boost/mpl/range_c.hpp> |
| #include <boost/type_traits/is_reference.hpp> |
| |
| struct square |
| { |
| template<typename Sig> |
| struct result; |
| |
| template <typename T> |
| struct result<square(T)> |
| { |
| typedef int type; |
| }; |
| |
| template <typename T> |
| int operator()(T x) const |
| { |
| return x * x; |
| } |
| }; |
| |
| struct add |
| { |
| template<typename Sig> |
| struct result; |
| |
| template <typename A, typename B> |
| struct result<add(A, B)> |
| { |
| typedef int type; |
| }; |
| |
| template <typename A, typename B> |
| int operator()(A a, B b) const |
| { |
| return a + b; |
| } |
| }; |
| |
| struct unary_lvalue_transform |
| { |
| template<typename Sig> |
| struct result; |
| |
| template<typename T> |
| struct result<unary_lvalue_transform(T&)> |
| { |
| typedef T* type; |
| }; |
| |
| template<typename T> |
| T* operator()(T& t) const |
| { |
| return &t; |
| } |
| }; |
| |
| int twice(int v) |
| { |
| return v*2; |
| } |
| |
| struct binary_lvalue_transform |
| { |
| template<typename Sig> |
| struct result; |
| |
| template<typename T0, typename T1> |
| struct result<binary_lvalue_transform(T0&,T1&)> |
| { |
| typedef T0* type; |
| }; |
| |
| template<typename T0, typename T1> |
| T0* operator()(T0& t0, T1&) const |
| { |
| return &t0; |
| } |
| }; |
| |
| int |
| main() |
| { |
| using namespace boost::fusion; |
| using boost::mpl::range_c; |
| |
| std::cout << tuple_open('['); |
| std::cout << tuple_close(']'); |
| std::cout << tuple_delimiter(", "); |
| |
| /// Testing the transform |
| |
| { |
| typedef range_c<int, 5, 9> sequence_type; |
| sequence_type sequence; |
| std::cout << transform(sequence, square()) << std::endl; |
| BOOST_TEST((transform(sequence, square()) == make_vector(25, 36, 49, 64))); |
| } |
| |
| { |
| typedef range_c<int, 5, 9> mpl_list1; |
| std::cout << transform(mpl_list1(), square()) << std::endl; |
| BOOST_TEST((transform(mpl_list1(), square()) == make_vector(25, 36, 49, 64))); |
| } |
| |
| { |
| vector<int, int, int> tup(1, 2, 3); |
| std::cout << transform(tup, square()) << std::endl; |
| BOOST_TEST((transform(tup, square()) == make_vector(1, 4, 9))); |
| } |
| |
| { |
| vector<int, int, int> tup1(1, 2, 3); |
| vector<int, int, int> tup2(4, 5, 6); |
| std::cout << transform(tup1, tup2, add()) << std::endl; |
| BOOST_TEST((transform(tup1, tup2, add()) == make_vector(5, 7, 9))); |
| } |
| |
| { |
| // Unary transform that requires lvalues, just check compilation |
| vector<int, int, int> tup1(1, 2, 3); |
| BOOST_TEST(at_c<0>(transform(tup1, unary_lvalue_transform())) == &at_c<0>(tup1)); |
| BOOST_TEST(*begin(transform(tup1, unary_lvalue_transform())) == &at_c<0>(tup1)); |
| } |
| |
| { |
| vector<int, int, int> tup1(1, 2, 3); |
| vector<int, int, int> tup2(4, 5, 6); |
| BOOST_TEST(at_c<0>(transform(tup1, tup2, binary_lvalue_transform())) == &at_c<0>(tup1)); |
| BOOST_TEST(*begin(transform(tup1, tup2, binary_lvalue_transform())) == &at_c<0>(tup1)); |
| } |
| |
| { |
| vector<int, int, int> tup1(1, 2, 3); |
| BOOST_TEST(transform(tup1, twice) == make_vector(2,4,6)); |
| } |
| |
| |
| return boost::report_errors(); |
| } |
| |