| // Copyright Daniel Wallin 2006. |
| // 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/parameter/preprocessor.hpp> |
| #include <boost/parameter/binding.hpp> |
| #include <boost/parameter/config.hpp> |
| #include "basics.hpp" |
| |
| #if defined(BOOST_PARAMETER_CAN_USE_MP11) |
| #include <type_traits> |
| #else |
| #include <boost/mpl/bool.hpp> |
| #include <boost/mpl/if.hpp> |
| #include <boost/type_traits/is_same.hpp> |
| #endif |
| |
| namespace test { |
| |
| BOOST_PARAMETER_BASIC_FUNCTION((int), f, test::tag, |
| (required |
| (tester, *) |
| (name, *) |
| ) |
| (optional |
| (value, *) |
| (index, (int)) |
| ) |
| ) |
| { |
| typedef typename boost::parameter::binding< |
| Args,test::tag::index,int& |
| >::type index_type; |
| |
| #if defined(BOOST_PARAMETER_CAN_USE_MP11) |
| static_assert( |
| std::is_same<index_type,int&>::value |
| , "index_type == int&" |
| ); |
| #else |
| BOOST_MPL_ASSERT(( |
| typename boost::mpl::if_< |
| boost::is_same<index_type,int&> |
| , boost::mpl::true_ |
| , boost::mpl::false_ |
| >::type |
| )); |
| #endif |
| |
| args[test::_tester]( |
| args[test::_name] |
| , args[test::_value | 1.f] |
| , args[test::_index | 2] |
| ); |
| |
| return 1; |
| } |
| } // namespace test |
| |
| #include <boost/parameter/value_type.hpp> |
| |
| #if !defined(BOOST_PARAMETER_CAN_USE_MP11) |
| #include <boost/type_traits/remove_const.hpp> |
| #endif |
| |
| namespace test { |
| |
| BOOST_PARAMETER_BASIC_FUNCTION((int), g, test::tag, |
| (required |
| (tester, *) |
| (name, *) |
| ) |
| (optional |
| (value, *) |
| (index, (int)) |
| ) |
| ) |
| { |
| typedef typename boost::parameter::value_type< |
| Args,test::tag::index,int |
| >::type index_type; |
| |
| #if defined(BOOST_PARAMETER_CAN_USE_MP11) |
| static_assert( |
| std::is_same< |
| typename std::remove_const<index_type>::type |
| , int |
| >::value |
| , "remove_const<index_type>::type == int" |
| ); |
| #else |
| BOOST_MPL_ASSERT(( |
| typename boost::mpl::if_< |
| boost::is_same< |
| typename boost::remove_const<index_type>::type |
| , int |
| > |
| , boost::mpl::true_ |
| , boost::mpl::false_ |
| >::type |
| )); |
| #endif |
| |
| args[test::_tester]( |
| args[test::_name] |
| , args[test::_value | 1.f] |
| , args[test::_index | 2] |
| ); |
| |
| return 1; |
| } |
| } // namespace test |
| |
| #if !defined(BOOST_PARAMETER_CAN_USE_MP11) |
| #include <boost/type_traits/remove_reference.hpp> |
| #endif |
| |
| namespace test { |
| |
| BOOST_PARAMETER_FUNCTION((int), h, test::tag, |
| (required |
| (tester, *) |
| (name, *) |
| ) |
| (optional |
| (value, *, 1.f) |
| (index, (int), 2) |
| ) |
| ) |
| { |
| #if defined(BOOST_PARAMETER_CAN_USE_MP11) |
| static_assert( |
| std::is_same< |
| typename std::remove_const< |
| typename std::remove_reference<index_type>::type |
| >::type |
| , int |
| >::value |
| , "remove_cref<index_type>::type == int" |
| ); |
| #elif !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564)) && \ |
| !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) |
| BOOST_MPL_ASSERT(( |
| typename boost::mpl::if_< |
| boost::is_same< |
| typename boost::remove_const< |
| typename boost::remove_reference<index_type>::type |
| >::type |
| , int |
| > |
| , boost::mpl::true_ |
| , boost::mpl::false_ |
| >::type |
| )); |
| #endif // BOOST_PARAMETER_CAN_USE_MP11 || Borland/MSVC workarounds not needed |
| |
| tester(name, value, index); |
| |
| return 1; |
| } |
| |
| BOOST_PARAMETER_FUNCTION((int), h2, test::tag, |
| (required |
| (tester, *) |
| (name, *) |
| ) |
| (optional |
| (value, *, 1.f) |
| (index, (int), static_cast<int>(value * 2)) |
| ) |
| ) |
| { |
| #if defined(BOOST_PARAMETER_CAN_USE_MP11) |
| static_assert( |
| std::is_same< |
| typename std::remove_const< |
| typename std::remove_reference<index_type>::type |
| >::type |
| , int |
| >::value |
| , "remove_cref<index_type>::type == int" |
| ); |
| #elif !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564)) && \ |
| !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) |
| BOOST_MPL_ASSERT(( |
| typename boost::mpl::if_< |
| boost::is_same< |
| typename boost::remove_const< |
| typename boost::remove_reference<index_type>::type |
| >::type |
| , int |
| > |
| , boost::mpl::true_ |
| , boost::mpl::false_ |
| >::type |
| )); |
| #endif // BOOST_PARAMETER_CAN_USE_MP11 || Borland/MSVC workarounds not needed |
| |
| tester(name, value, index); |
| |
| return 1; |
| } |
| } // namespace test |
| |
| #include <string> |
| |
| #if !defined(BOOST_NO_SFINAE) |
| #include <boost/parameter/aux_/preprocessor/nullptr.hpp> |
| #include <boost/core/enable_if.hpp> |
| #if !defined(BOOST_PARAMETER_CAN_USE_MP11) |
| #include <boost/type_traits/is_base_of.hpp> |
| #include <boost/type_traits/is_convertible.hpp> |
| #endif |
| #endif |
| |
| namespace test { |
| |
| struct base_0 |
| { |
| float f; |
| int i; |
| |
| template <typename Args> |
| explicit base_0( |
| Args const& args |
| #if !defined(BOOST_NO_SFINAE) |
| , typename boost::disable_if< |
| typename boost::mpl::if_< |
| boost::is_base_of<base_0,Args> |
| , boost::mpl::true_ |
| , boost::mpl::false_ |
| >::type |
| >::type* = BOOST_PARAMETER_AUX_PP_NULLPTR |
| #endif // BOOST_NO_SFINAE |
| ) : f(args[test::_value | 1.f]), i(args[test::_index | 2]) |
| { |
| } |
| }; |
| |
| struct class_0 : test::base_0 |
| { |
| BOOST_PARAMETER_CONSTRUCTOR(class_0, (test::base_0), test::tag, |
| (optional |
| (value, *) |
| (index, *) |
| ) |
| ) |
| |
| BOOST_PARAMETER_BASIC_FUNCTION_CALL_OPERATOR((int), test::tag, |
| (optional |
| (value, *) |
| (index, *) |
| ) |
| ) |
| { |
| this->f = args[test::_value | 2.f]; |
| this->i = args[test::_index | 1]; |
| return 1; |
| } |
| }; |
| |
| struct base_1 |
| { |
| template <typename Args> |
| explicit base_1( |
| Args const& args |
| #if !defined(BOOST_NO_SFINAE) |
| , typename boost::disable_if< |
| #if defined(BOOST_PARAMETER_CAN_USE_MP11) |
| std::is_base_of<base_1,Args> |
| #else |
| typename boost::mpl::if_< |
| boost::is_base_of<base_1,Args> |
| , boost::mpl::true_ |
| , boost::mpl::false_ |
| >::type |
| #endif |
| >::type* = BOOST_PARAMETER_AUX_PP_NULLPTR |
| #endif // BOOST_NO_SFINAE |
| ) |
| { |
| args[test::_tester]( |
| args[test::_name] |
| , args[test::_value | 1.f] |
| , args[test::_index | 2] |
| ); |
| } |
| }; |
| |
| struct class_1 : test::base_1 |
| { |
| BOOST_PARAMETER_CONSTRUCTOR(class_1, (test::base_1), test::tag, |
| (required |
| (tester, *) |
| (name, *) |
| ) |
| (optional |
| (value, *) |
| (index, *) |
| ) |
| ) |
| |
| BOOST_PARAMETER_BASIC_MEMBER_FUNCTION((int), f, test::tag, |
| (required |
| (tester, *) |
| (name, *) |
| ) |
| (optional |
| (value, *) |
| (index, *) |
| ) |
| ) |
| { |
| args[test::_tester]( |
| args[test::_name] |
| , args[test::_value | 1.f] |
| , args[test::_index | 2] |
| ); |
| |
| return 1; |
| } |
| |
| BOOST_PARAMETER_BASIC_CONST_MEMBER_FUNCTION((int), f, test::tag, |
| (required |
| (tester, *) |
| (name, *) |
| ) |
| (optional |
| (value, *) |
| (index, *) |
| ) |
| ) |
| { |
| args[test::_tester]( |
| args[test::_name] |
| , args[test::_value | 1.f] |
| , args[test::_index | 2] |
| ); |
| |
| return 1; |
| } |
| |
| BOOST_PARAMETER_MEMBER_FUNCTION((int), f2, test::tag, |
| (required |
| (tester, *) |
| (name, *) |
| ) |
| (optional |
| (value, *, 1.f) |
| (index, *, 2) |
| ) |
| ) |
| { |
| tester(name, value, index); |
| return 1; |
| } |
| |
| BOOST_PARAMETER_CONST_MEMBER_FUNCTION((int), f2, test::tag, |
| (required |
| (tester, *) |
| (name, *) |
| ) |
| (optional |
| (value, *, 1.f) |
| (index, *, 2) |
| ) |
| ) |
| { |
| tester(name, value, index); |
| return 1; |
| } |
| |
| BOOST_PARAMETER_MEMBER_FUNCTION((int), static f_static, test::tag, |
| (required |
| (tester, *) |
| (name, *) |
| ) |
| (optional |
| (value, *, 1.f) |
| (index, *, 2) |
| ) |
| ) |
| { |
| tester(name, value, index); |
| return 1; |
| } |
| |
| BOOST_PARAMETER_FUNCTION_CALL_OPERATOR((int), test::tag, |
| (required |
| (tester, *) |
| (name, *) |
| ) |
| (optional |
| (value, *, 1.f) |
| (index, *, 2) |
| ) |
| ) |
| { |
| tester(name, value, index); |
| return 1; |
| } |
| |
| BOOST_PARAMETER_CONST_FUNCTION_CALL_OPERATOR((int), test::tag, |
| (required |
| (tester, *) |
| (name, *) |
| ) |
| (optional |
| (value, *, 1.f) |
| (index, *, 2) |
| ) |
| ) |
| { |
| tester(name, value, index); |
| return 1; |
| } |
| }; |
| |
| BOOST_PARAMETER_FUNCTION((int), sfinae, test::tag, |
| (required |
| (name, (std::string)) |
| ) |
| ) |
| { |
| return 1; |
| } |
| |
| #if !defined(BOOST_NO_SFINAE) |
| // On compilers that actually support SFINAE, add another overload |
| // that is an equally good match and can only be in the overload set |
| // when the others are not. This tests that the SFINAE is actually |
| // working. On all other compilers we're just checking that everything |
| // about SFINAE-enabled code will work, except of course the SFINAE. |
| template <typename A0> |
| typename boost::enable_if< |
| #if defined(BOOST_PARAMETER_CAN_USE_MP11) |
| std::is_same<int,A0> |
| #else |
| typename boost::mpl::if_< |
| boost::is_same<int,A0> |
| , boost::mpl::true_ |
| , boost::mpl::false_ |
| >::type |
| #endif |
| , int |
| >::type |
| sfinae(A0 const& a0) |
| { |
| return 0; |
| } |
| #endif // BOOST_NO_SFINAE |
| |
| struct predicate |
| { |
| template <typename T, typename Args> |
| #if defined(BOOST_PARAMETER_CAN_USE_MP11) |
| using fn = std::is_convertible<T,std::string>; |
| #else |
| struct apply |
| : boost::mpl::if_< |
| boost::is_convertible<T,std::string> |
| , boost::mpl::true_ |
| , boost::mpl::false_ |
| > |
| { |
| }; |
| #endif |
| |
| BOOST_PARAMETER_BASIC_CONST_FUNCTION_CALL_OPERATOR((bool), test::tag, |
| (required |
| (value, *) |
| (index, *) |
| ) |
| ) |
| { |
| return args[test::_value] < args[test::_index]; |
| } |
| }; |
| |
| BOOST_PARAMETER_FUNCTION((int), sfinae1, test::tag, |
| (required |
| (name, *(test::predicate)) |
| ) |
| ) |
| { |
| return 1; |
| } |
| |
| #if !defined(BOOST_NO_SFINAE) |
| // On compilers that actually support SFINAE, add another overload |
| // that is an equally good match and can only be in the overload set |
| // when the others are not. This tests that the SFINAE is actually |
| // working. On all other compilers we're just checking that everything |
| // about SFINAE-enabled code will work, except of course the SFINAE. |
| template <typename A0> |
| typename boost::enable_if< |
| #if defined(BOOST_PARAMETER_CAN_USE_MP11) |
| std::is_same<int,A0> |
| #else |
| typename boost::mpl::if_< |
| boost::is_same<int,A0> |
| , boost::mpl::true_ |
| , boost::mpl::false_ |
| >::type |
| #endif |
| , int |
| >::type |
| sfinae1(A0 const& a0) |
| { |
| return 0; |
| } |
| #endif // BOOST_NO_SFINAE |
| |
| struct udt |
| { |
| udt(int foo_, int bar_) : foo(foo_), bar(bar_) |
| { |
| } |
| |
| int foo; |
| int bar; |
| }; |
| |
| BOOST_PARAMETER_FUNCTION((int), lazy_defaults, test::tag, |
| (required |
| (name, *) |
| ) |
| (optional |
| (value, *, name.foo) |
| (index, *, name.bar) |
| ) |
| ) |
| { |
| return 0; |
| } |
| } // namespace test |
| |
| #if BOOST_WORKAROUND(BOOST_MSVC, == 1300) |
| #include <boost/parameter/aux_/as_lvalue.hpp> |
| #endif |
| |
| #include <boost/core/lightweight_test.hpp> |
| |
| int main() |
| { |
| test::f( |
| test::values(std::string("foo"), 1.f, 2) |
| , std::string("foo") |
| ); |
| test::f( |
| test::_tester = test::values(std::string("foo"), 1.f, 2) |
| , test::_name = std::string("foo") |
| ); |
| |
| int index_lvalue = 2; |
| |
| test::f( |
| test::_tester = test::values(std::string("foo"), 1.f, 2) |
| , test::_name = std::string("foo") |
| , test::_value = 1.f |
| , test::_index = index_lvalue |
| ); |
| |
| test::f( |
| test::values(std::string("foo"), 1.f, 2) |
| , std::string("foo") |
| , 1.f |
| , index_lvalue |
| ); |
| |
| test::g( |
| test::values(std::string("foo"), 1.f, 2) |
| , std::string("foo") |
| , 1.f |
| #if BOOST_WORKAROUND(BOOST_MSVC, == 1300) |
| , boost::parameter::aux::as_lvalue(2) |
| #else |
| , 2 |
| #endif |
| ); |
| |
| test::h( |
| test::values(std::string("foo"), 1.f, 2) |
| , std::string("foo") |
| , 1.f |
| #if BOOST_WORKAROUND(BOOST_MSVC, == 1300) |
| , boost::parameter::aux::as_lvalue(2) |
| #else |
| , 2 |
| #endif |
| ); |
| |
| test::h2( |
| test::_tester = test::values(std::string("foo"), 1.f, 2) |
| , test::_name = std::string("foo") |
| , test::_value = 1.f |
| ); |
| |
| test::class_0 u; |
| |
| BOOST_TEST(2 == u.i); |
| BOOST_TEST(1.f == u.f); |
| |
| u(); |
| |
| BOOST_TEST(1 == u.i); |
| BOOST_TEST(2.f == u.f); |
| |
| test::class_1 x( |
| test::values(std::string("foo"), 1.f, 2) |
| , std::string("foo") |
| , test::_index = 2 |
| ); |
| |
| x.f(test::values(std::string("foo"), 1.f, 2), std::string("foo")); |
| x.f( |
| test::_tester = test::values(std::string("foo"), 1.f, 2) |
| , test::_name = std::string("foo") |
| ); |
| x.f2(test::values(std::string("foo"), 1.f, 2), std::string("foo")); |
| x.f2( |
| test::_tester = test::values(std::string("foo"), 1.f, 2) |
| , test::_name = std::string("foo") |
| ); |
| x(test::values(std::string("foo"), 1.f, 2), std::string("foo")); |
| x( |
| test::_tester = test::values(std::string("foo"), 1.f, 2) |
| , test::_name = std::string("foo") |
| ); |
| |
| test::class_1 const& x_const = x; |
| |
| x_const.f(test::values(std::string("foo"), 1.f, 2), std::string("foo")); |
| x_const.f( |
| test::_tester = test::values(std::string("foo"), 1.f, 2) |
| , test::_name = std::string("foo") |
| ); |
| x_const.f2(test::values(std::string("foo"), 1.f, 2), std::string("foo")); |
| x_const.f2( |
| test::_tester = test::values(std::string("foo"), 1.f, 2) |
| , test::_name = std::string("foo") |
| ); |
| test::class_1::f_static( |
| test::values(std::string("foo"), 1.f, 2) |
| , std::string("foo") |
| ); |
| test::class_1::f_static( |
| test::_tester = test::values(std::string("foo"), 1.f, 2) |
| , test::_name = std::string("foo") |
| ); |
| x_const(test::values(std::string("foo"), 1.f, 2), std::string("foo")); |
| x_const( |
| test::_tester = test::values(std::string("foo"), 1.f, 2) |
| , test::_name = std::string("foo") |
| ); |
| |
| test::predicate p; |
| test::predicate const& p_const = p; |
| |
| BOOST_TEST(p_const(3, 4)); |
| BOOST_TEST(!p_const(4, 3)); |
| BOOST_TEST(!p_const(test::_index = 3, test::_value = 4)); |
| |
| #if !defined(BOOST_NO_SFINAE) && \ |
| !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x592)) |
| // GCC 3- tries to bind string literals |
| // to non-const references to char const*. |
| // BOOST_TEST(test::sfinae("foo") == 1); |
| char const* foo_str = "foo"; |
| BOOST_TEST(test::sfinae(foo_str) == 1); |
| BOOST_TEST(test::sfinae(1) == 0); |
| |
| #if !BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x580)) |
| // Sun actually eliminates the desired overload for some reason. |
| // Disabling this part of the test because SFINAE abilities are |
| // not the point of this test. |
| BOOST_TEST(test::sfinae1(foo_str) == 1); |
| #endif |
| |
| BOOST_TEST(test::sfinae1(1) == 0); |
| #endif |
| |
| test::lazy_defaults(test::_name = test::udt(0, 1)); |
| test::lazy_defaults(test::_name = 0, test::_value = 1, test::_index = 2); |
| |
| return boost::report_errors(); |
| } |
| |
