Update of /cvsroot/boost/boost/libs/function_types/test/synthesis
In directory
sc8-pr-cvs3.sourceforge.net:/tmp/cvs-serv18022/function_types/test/synthesis
Added Files:
cv_function_synthesis.cpp function_pointer.cpp
function_reference.cpp function_type.cpp mem_func_ptr_cv1.cpp
mem_func_ptr_cv2.cpp mem_func_ptr_cv_ptr_to_this.cpp
member_function_pointer.cpp member_object_pointer.cpp
transformation.cpp variadic_function_synthesis.cpp
Log Message:
libs/function_types/* - check-in
--- NEW FILE: cv_function_synthesis.cpp ---
// (C) Copyright Tobias Schwinger
//
// Use modification and distribution are subject to the boost Software License,
// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
//------------------------------------------------------------------------------
#include <boost/mpl/assert.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/function_types/function_type.hpp>
namespace ft = boost::function_types;
namespace mpl = boost::mpl;
template<typename C, typename T>
void test_non_cv(T C::*)
{
BOOST_MPL_ASSERT(( boost::is_same<
ft::function_type< mpl::vector<void,int>,
ft::tag<ft::non_const,ft::non_volatile> >::type
, T
>));
BOOST_MPL_ASSERT(( boost::is_same<
ft::function_type< mpl::vector<void,int>, ft::non_const >::type
, T
>));
BOOST_MPL_ASSERT(( boost::is_same<
ft::function_type< mpl::vector<void,int>, ft::non_volatile >::type
, T
>));
BOOST_MPL_ASSERT(( boost::is_same<
ft::function_type< mpl::vector<void,int> >::type
, T
>));
BOOST_MPL_ASSERT_NOT(( boost::is_same<
ft::function_type< mpl::vector<void,int>,
ft::tag<ft::const_qualified,ft::non_volatile> >::type
, T
>));
BOOST_MPL_ASSERT_NOT(( boost::is_same<
ft::function_type< mpl::vector<void,int>, ft::const_qualified >::type
, T
>));
BOOST_MPL_ASSERT_NOT(( boost::is_same<
ft::function_type< mpl::vector<void,int>,
ft::tag<ft::non_const,ft::volatile_qualified> >::type
, T
>));
BOOST_MPL_ASSERT_NOT((
boost::is_same<
ft::function_type< mpl::vector<void,int>, ft::volatile_qualified >::type
, T
>));
BOOST_MPL_ASSERT_NOT(( boost::is_same<
ft::function_type< mpl::vector<void,int>,
ft::tag<ft::const_qualified,ft::volatile_qualified> >::type
, T
>));
}
template<typename C, typename T>
void test_c_non_v(T C::*)
{
BOOST_MPL_ASSERT_NOT(( boost::is_same<
ft::function_type< mpl::vector<void,int>,
ft::tag<ft::non_const,ft::non_volatile> >::type
, T
>));
BOOST_MPL_ASSERT_NOT(( boost::is_same<
ft::function_type< mpl::vector<void,int>, ft::non_const >::type
, T
>));
BOOST_MPL_ASSERT_NOT(( boost::is_same<
ft::function_type< mpl::vector<void,int>, ft::non_volatile >::type
, T
>));
BOOST_MPL_ASSERT_NOT(( boost::is_same<
ft::function_type< mpl::vector<void,int> >::type
, T
>));
BOOST_MPL_ASSERT(( boost::is_same<
ft::function_type< mpl::vector<void,int>,
ft::tag<ft::const_qualified,ft::non_volatile> >::type
, T
>));
BOOST_MPL_ASSERT(( boost::is_same<
ft::function_type< mpl::vector<void,int>, ft::const_qualified >::type
, T
>));
BOOST_MPL_ASSERT_NOT(( boost::is_same<
ft::function_type< mpl::vector<void,int>,
ft::tag<ft::non_const,ft::volatile_qualified> >::type
, T
>));
BOOST_MPL_ASSERT_NOT((
boost::is_same<
ft::function_type< mpl::vector<void,int>, ft::volatile_qualified >::type
, T
>));
BOOST_MPL_ASSERT_NOT(( boost::is_same<
ft::function_type< mpl::vector<void,int>,
ft::tag<ft::const_qualified,ft::volatile_qualified> >::type
, T
>));
}
template<typename C, typename T>
void test_v_non_c(T C::*)
{
BOOST_MPL_ASSERT_NOT(( boost::is_same<
ft::function_type< mpl::vector<void,int>,
ft::tag<ft::non_const,ft::non_volatile> >::type
, T
>));
BOOST_MPL_ASSERT_NOT(( boost::is_same<
ft::function_type< mpl::vector<void,int>, ft::non_const >::type
, T
>));
BOOST_MPL_ASSERT_NOT(( boost::is_same<
ft::function_type< mpl::vector<void,int>, ft::non_volatile >::type
, T
>));
BOOST_MPL_ASSERT_NOT(( boost::is_same<
ft::function_type< mpl::vector<void,int> >::type
, T
>));
BOOST_MPL_ASSERT_NOT(( boost::is_same<
ft::function_type< mpl::vector<void,int>,
ft::tag<ft::const_qualified,ft::non_volatile> >::type
, T
>));
BOOST_MPL_ASSERT_NOT(( boost::is_same<
ft::function_type< mpl::vector<void,int>, ft::const_qualified >::type
, T
>));
BOOST_MPL_ASSERT(( boost::is_same<
ft::function_type< mpl::vector<void,int>,
ft::tag<ft::non_const,ft::volatile_qualified> >::type
, T
>));
BOOST_MPL_ASSERT((
boost::is_same<
ft::function_type< mpl::vector<void,int>, ft::volatile_qualified >::type
, T
>));
BOOST_MPL_ASSERT_NOT(( boost::is_same<
ft::function_type< mpl::vector<void,int>,
ft::tag<ft::const_qualified,ft::volatile_qualified> >::type
, T
>));
}
template<typename C, typename T>
void test_cv(T C::*)
{
BOOST_MPL_ASSERT_NOT(( boost::is_same<
ft::function_type< mpl::vector<void,int>,
ft::tag<ft::non_const,ft::non_volatile> >::type
, T
>));
BOOST_MPL_ASSERT_NOT(( boost::is_same<
ft::function_type< mpl::vector<void,int>, ft::non_const >::type
, T
>));
BOOST_MPL_ASSERT_NOT(( boost::is_same<
ft::function_type< mpl::vector<void,int>, ft::non_volatile >::type
, T
>));
BOOST_MPL_ASSERT_NOT(( boost::is_same<
ft::function_type< mpl::vector<void,int> >::type
, T
>));
BOOST_MPL_ASSERT_NOT(( boost::is_same<
ft::function_type< mpl::vector<void,int>,
ft::tag<ft::const_qualified,ft::non_volatile> >::type
, T
>));
BOOST_MPL_ASSERT_NOT(( boost::is_same<
ft::function_type< mpl::vector<void,int>, ft::const_qualified >::type
, T
>));
BOOST_MPL_ASSERT_NOT(( boost::is_same<
ft::function_type< mpl::vector<void,int>,
ft::tag<ft::non_const,ft::volatile_qualified> >::type
, T
>));
BOOST_MPL_ASSERT_NOT((
boost::is_same<
ft::function_type< mpl::vector<void,int>, ft::volatile_qualified >::type
, T
>));
BOOST_MPL_ASSERT(( boost::is_same<
ft::function_type< mpl::vector<void,int>,
ft::tag<ft::const_qualified,ft::volatile_qualified> >::type
, T
>));
}
struct C
{
void non_cv(int) { }
void c_non_v(int) const { }
void v_non_c(int) volatile { }
void cv(int) const volatile { }
};
void instanitate()
{
test_non_cv(& C::non_cv);
test_c_non_v(& C::c_non_v);
test_v_non_c(& C::v_non_c);
test_cv(& C::cv);
}
--- NEW FILE: function_pointer.cpp ---
// (C) Copyright Tobias Schwinger
//
// Use modification and distribution are subject to the boost Software License,
// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
//------------------------------------------------------------------------------
#include <boost/mpl/assert.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/function_types/function_pointer.hpp>
namespace ft = boost::function_types;
namespace mpl = boost::mpl;
using boost::is_same;
typedef int (* expected)(int,int);
BOOST_MPL_ASSERT((
is_same< ft::function_pointer< mpl::vector<int,int,int> >::type, expected >
));
--- NEW FILE: function_reference.cpp ---
// (C) Copyright Tobias Schwinger
//
// Use modification and distribution are subject to the boost Software License,
// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
//------------------------------------------------------------------------------
#include <boost/mpl/assert.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/function_types/function_reference.hpp>
namespace ft = boost::function_types;
namespace mpl = boost::mpl;
using boost::is_same;
typedef int (& expected)(int);
BOOST_MPL_ASSERT((
is_same< ft::function_reference< mpl::vector<int,int> >::type, expected >
));
--- NEW FILE: function_type.cpp ---
// (C) Copyright Tobias Schwinger
//
// Use modification and distribution are subject to the boost Software License,
// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
//------------------------------------------------------------------------------
#include <boost/mpl/assert.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/function_types/function_type.hpp>
namespace ft = boost::function_types;
namespace mpl = boost::mpl;
using boost::is_same;
typedef int expected(int,int);
BOOST_MPL_ASSERT((
is_same< ft::function_type< mpl::vector<int,int,int> >::type, expected >
));
--- NEW FILE: mem_func_ptr_cv1.cpp ---
// (C) Copyright Tobias Schwinger
//
// Use modification and distribution are subject to the boost Software License,
// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
//------------------------------------------------------------------------------
#include <boost/mpl/assert.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/function_types/member_function_pointer.hpp>
namespace ft = boost::function_types;
namespace mpl = boost::mpl;
using boost::is_same;
class C;
typedef int (C::* expected1)(int);
typedef int (C::* expected2)(int) const;
typedef int (C::* expected3)(int) volatile;
typedef int (C::* expected4)(int) const volatile;
// implicitly specified cv qualification
BOOST_MPL_ASSERT((
is_same< ft::member_function_pointer< mpl::vector<int,C,int> >::type
, expected1 >
));
BOOST_MPL_ASSERT((
is_same< ft::member_function_pointer< mpl::vector<int,C const,int> >::type
, expected2 >
));
BOOST_MPL_ASSERT((
is_same< ft::member_function_pointer<
mpl::vector<int,C volatile,int> >::type
, expected3 >
));
BOOST_MPL_ASSERT((
is_same< ft::member_function_pointer<
mpl::vector<int,C const volatile,int> >::type
, expected4 >
));
// implicit & explicit/overrides
BOOST_MPL_ASSERT((
is_same< ft::member_function_pointer<
mpl::vector<int,C const volatile,int>
, ft::tag<ft::non_const, ft::non_volatile> >::type
, expected1 >
));
BOOST_MPL_ASSERT((
is_same< ft::member_function_pointer< mpl::vector<int,C volatile,int>,
ft::tag<ft::const_qualified, ft::non_volatile> >::type
, expected2 >
));
BOOST_MPL_ASSERT((
is_same< ft::member_function_pointer< mpl::vector<int,C const,int>,
ft::tag<ft::non_const, ft::volatile_qualified> >::type
, expected3 >
));
BOOST_MPL_ASSERT((
is_same< ft::member_function_pointer< mpl::vector<int,C const,int>,
ft::tag<ft::const_qualified, ft::volatile_qualified> >::type
, expected4 >
));
BOOST_MPL_ASSERT((
is_same< ft::member_function_pointer< mpl::vector<int,C volatile,int>,
ft::tag<ft::const_qualified, ft::volatile_qualified> >::type
, expected4 >
));
BOOST_MPL_ASSERT((
is_same< ft::member_function_pointer< mpl::vector<int,C volatile,int>
, ft::const_qualified >::type
, expected4 >
));
BOOST_MPL_ASSERT((
is_same< ft::member_function_pointer< mpl::vector<int,C const,int>
, ft::volatile_qualified >::type
, expected4 >
));
--- NEW FILE: mem_func_ptr_cv2.cpp ---
// (C) Copyright Tobias Schwinger
//
// Use modification and distribution are subject to the boost Software License,
// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
//------------------------------------------------------------------------------
#include <boost/mpl/assert.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/function_types/member_function_pointer.hpp>
namespace ft = boost::function_types;
namespace mpl = boost::mpl;
using boost::is_same;
class C;
typedef int (C::* expected1)(int);
typedef int (C::* expected2)(int) const;
typedef int (C::* expected3)(int) volatile;
typedef int (C::* expected4)(int) const volatile;
// implicitly specified cv qualification
BOOST_MPL_ASSERT((
is_same< ft::member_function_pointer< mpl::vector<int,C &,int> >::type
, expected1 >
));
BOOST_MPL_ASSERT((
is_same< ft::member_function_pointer< mpl::vector<int,C const &,int> >::type
, expected2 >
));
BOOST_MPL_ASSERT((
is_same< ft::member_function_pointer<
mpl::vector<int,C volatile &,int> >::type
, expected3 >
));
BOOST_MPL_ASSERT((
is_same< ft::member_function_pointer<
mpl::vector<int,C const volatile &,int> >::type
, expected4 >
));
// implicit & explicit/overrides
BOOST_MPL_ASSERT((
is_same< ft::member_function_pointer<
mpl::vector<int,C const volatile &,int>
, ft::tag<ft::non_const, ft::non_volatile> >::type
, expected1 >
));
BOOST_MPL_ASSERT((
is_same< ft::member_function_pointer< mpl::vector<int,C volatile &,int>,
ft::tag<ft::const_qualified, ft::non_volatile> >::type
, expected2 >
));
BOOST_MPL_ASSERT((
is_same< ft::member_function_pointer< mpl::vector<int,C const &,int>,
ft::tag<ft::non_const, ft::volatile_qualified> >::type
, expected3 >
));
BOOST_MPL_ASSERT((
is_same< ft::member_function_pointer< mpl::vector<int,C const &,int>,
ft::tag<ft::const_qualified, ft::volatile_qualified> >::type
, expected4 >
));
BOOST_MPL_ASSERT((
is_same< ft::member_function_pointer< mpl::vector<int,C volatile &,int>,
ft::tag<ft::const_qualified, ft::volatile_qualified> >::type
, expected4 >
));
BOOST_MPL_ASSERT((
is_same< ft::member_function_pointer< mpl::vector<int,C volatile &,int>
, ft::const_qualified >::type
, expected4 >
));
BOOST_MPL_ASSERT((
is_same< ft::member_function_pointer< mpl::vector<int,C const &,int>
, ft::volatile_qualified >::type
, expected4 >
));
--- NEW FILE: mem_func_ptr_cv_ptr_to_this.cpp ---
// (C) Copyright Tobias Schwinger
//
// Use modification and distribution are subject to the boost Software License,
// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
//------------------------------------------------------------------------------
#include <boost/mpl/assert.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/function_types/member_function_pointer.hpp>
namespace ft = boost::function_types;
namespace mpl = boost::mpl;
using boost::is_same;
class C;
typedef int (C::* expected)();
BOOST_MPL_ASSERT((
is_same< ft::member_function_pointer< mpl::vector<int,C * const> >::type
, expected >
));
BOOST_MPL_ASSERT((
is_same< ft::member_function_pointer< mpl::vector<int,C * volatile> >::type
, expected >
));
BOOST_MPL_ASSERT((
is_same< ft::member_function_pointer< mpl::vector<int,C * const volatile>
>::type
, expected >
));
--- NEW FILE: member_function_pointer.cpp ---
// (C) Copyright Tobias Schwinger
//
// Use modification and distribution are subject to the boost Software License,
// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
//------------------------------------------------------------------------------
#include <boost/mpl/assert.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/function_types/member_function_pointer.hpp>
namespace ft = boost::function_types;
namespace mpl = boost::mpl;
using boost::is_same;
class C;
typedef int (C::* expected1)(int);
typedef int (C::* expected2)(int) const;
typedef int (C::* expected3)(int) volatile;
typedef int (C::* expected4)(int) const volatile;
BOOST_MPL_ASSERT((
is_same< ft::member_function_pointer< mpl::vector<int,C,int> >::type
, expected1 >
));
BOOST_MPL_ASSERT((
is_same< ft::member_function_pointer< mpl::vector<int,C,int>,
ft::tag<ft::non_const, ft::non_volatile> >::type
, expected1 >
));
BOOST_MPL_ASSERT((
is_same< ft::member_function_pointer< mpl::vector<int,C,int>
, ft::const_qualified >::type
, expected2 >
));
BOOST_MPL_ASSERT((
is_same< ft::member_function_pointer< mpl::vector<int,C,int>,
ft::tag<ft::const_qualified, ft::non_volatile> >::type
, expected2 >
));
BOOST_MPL_ASSERT((
is_same< ft::member_function_pointer< mpl::vector<int,C,int>
, ft::volatile_qualified >::type
, expected3 >
));
BOOST_MPL_ASSERT((
is_same< ft::member_function_pointer< mpl::vector<int,C,int>,
ft::tag<ft::non_const, ft::volatile_qualified> >::type
, expected3 >
));
BOOST_MPL_ASSERT((
is_same< ft::member_function_pointer< mpl::vector<int,C,int>,
ft::tag<ft::const_qualified, ft::volatile_qualified> >::type
, expected4 >
));
--- NEW FILE: member_object_pointer.cpp ---
// (C) Copyright Tobias Schwinger
//
// Use modification and distribution are subject to the boost Software License,
// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
//------------------------------------------------------------------------------
#include <boost/mpl/assert.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/function_types/member_object_pointer.hpp>
namespace ft = boost::function_types;
namespace mpl = boost::mpl;
using boost::is_same;
class C;
typedef int C::* expected;
BOOST_MPL_ASSERT((
is_same< ft::member_object_pointer< mpl::vector<int,C> >::type
, expected >
));
--- NEW FILE: transformation.cpp ---
// (C) Copyright Tobias Schwinger
//
// Use modification and distribution are subject to the boost Software License,
// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
//------------------------------------------------------------------------------
#include <boost/mpl/assert.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/function_types/function_type.hpp>
#include <boost/function_types/function_pointer.hpp>
#include <boost/function_types/function_reference.hpp>
#include <boost/function_types/member_function_pointer.hpp>
namespace ft = boost::function_types;
namespace mpl = boost::mpl;
using boost::is_same;
class C;
typedef C func1(C &);
typedef C (*func_ptr1)(C &);
typedef C (&func_ref1)(C &);
typedef C (C::*mem_func_ptr1)();
BOOST_MPL_ASSERT(( is_same< func1, ft::function_type<func1>::type > ));
BOOST_MPL_ASSERT(( is_same< func1, ft::function_type<func_ptr1>::type > ));
BOOST_MPL_ASSERT(( is_same< func1, ft::function_type<func_ref1>::type > ));
BOOST_MPL_ASSERT(( is_same< func1, ft::function_type<mem_func_ptr1>::type > ));
BOOST_MPL_ASSERT(( is_same< func_ptr1, ft::function_pointer<func1>::type > ));
BOOST_MPL_ASSERT(( is_same< func_ptr1, ft::function_pointer<func_ptr1>::type >
));
BOOST_MPL_ASSERT(( is_same< func_ptr1, ft::function_pointer<func_ref1>::type >
));
BOOST_MPL_ASSERT(( is_same< func_ptr1,
ft::function_pointer<mem_func_ptr1>::type > ));
BOOST_MPL_ASSERT(( is_same< func_ref1, ft::function_reference<func1>::type > ));
BOOST_MPL_ASSERT(( is_same< func_ref1, ft::function_reference<func_ptr1>::type
> ));
BOOST_MPL_ASSERT(( is_same< func_ref1, ft::function_reference<func_ref1>::type
> ));
BOOST_MPL_ASSERT(( is_same< func_ref1,
ft::function_reference<mem_func_ptr1>::type > ));
BOOST_MPL_ASSERT(( is_same< mem_func_ptr1,
ft::member_function_pointer<func1>::type > ));
BOOST_MPL_ASSERT(( is_same< mem_func_ptr1,
ft::member_function_pointer<func_ptr1>::type > ));
BOOST_MPL_ASSERT(( is_same< mem_func_ptr1,
ft::member_function_pointer<func_ref1>::type > ));
BOOST_MPL_ASSERT(( is_same< mem_func_ptr1,
ft::member_function_pointer<mem_func_ptr1>::type > ));
typedef C func2(C const &);
typedef C (*func_ptr2)(C const &);
typedef C (&func_ref2)(C const &);
typedef C (C::*mem_func_ptr2)() const;
BOOST_MPL_ASSERT(( is_same< func2, ft::function_type<func2>::type > ));
BOOST_MPL_ASSERT(( is_same< func2, ft::function_type<func_ptr2>::type > ));
BOOST_MPL_ASSERT(( is_same< func2, ft::function_type<func_ref2>::type > ));
BOOST_MPL_ASSERT(( is_same< func2, ft::function_type<mem_func_ptr2>::type > ));
BOOST_MPL_ASSERT(( is_same< func_ptr2, ft::function_pointer<func2>::type > ));
BOOST_MPL_ASSERT(( is_same< func_ptr2, ft::function_pointer<func_ptr2>::type >
));
BOOST_MPL_ASSERT(( is_same< func_ptr2, ft::function_pointer<func_ref2>::type >
));
BOOST_MPL_ASSERT(( is_same< func_ptr2,
ft::function_pointer<mem_func_ptr2>::type > ));
BOOST_MPL_ASSERT(( is_same< func_ref2, ft::function_reference<func2>::type > ));
BOOST_MPL_ASSERT(( is_same< func_ref2, ft::function_reference<func_ptr2>::type
> ));
BOOST_MPL_ASSERT(( is_same< func_ref2, ft::function_reference<func_ref2>::type
> ));
BOOST_MPL_ASSERT(( is_same< func_ref2,
ft::function_reference<mem_func_ptr2>::type > ));
BOOST_MPL_ASSERT(( is_same< mem_func_ptr2,
ft::member_function_pointer<func2>::type > ));
BOOST_MPL_ASSERT(( is_same< mem_func_ptr2,
ft::member_function_pointer<func_ptr2>::type > ));
BOOST_MPL_ASSERT(( is_same< mem_func_ptr2,
ft::member_function_pointer<func_ref2>::type > ));
BOOST_MPL_ASSERT(( is_same< mem_func_ptr2,
ft::member_function_pointer<mem_func_ptr2>::type > ));
--- NEW FILE: variadic_function_synthesis.cpp ---
// (C) Copyright Tobias Schwinger
//
// Use modification and distribution are subject to the boost Software License,
// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
//------------------------------------------------------------------------------
#include <boost/mpl/assert.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/function_types/function_type.hpp>
#include <boost/function_types/function_pointer.hpp>
#include <boost/function_types/function_reference.hpp>
#include <boost/function_types/member_function_pointer.hpp>
namespace ft = boost::function_types;
namespace mpl = boost::mpl;
using boost::is_same;
class C;
typedef int expected_v_1(...);
typedef int expected_nv_1();
typedef int (C::*expected_v_2)(...);
typedef int (C::*expected_nv_2)();
BOOST_MPL_ASSERT(( is_same<
ft::function_type<mpl::vector<int>, ft::variadic>::type, expected_v_1
> ));
BOOST_MPL_ASSERT(( is_same<
ft::function_type<mpl::vector<int>, ft::non_variadic>::type, expected_nv_1
> ));
BOOST_MPL_ASSERT(( is_same<
ft::function_pointer<mpl::vector<int>, ft::variadic>::type, expected_v_1 *
> ));
BOOST_MPL_ASSERT(( is_same<
ft::function_pointer<mpl::vector<int>, ft::non_variadic>::type
, expected_nv_1 *
> ));
BOOST_MPL_ASSERT(( is_same<
ft::function_reference<mpl::vector<int>, ft::variadic>::type, expected_v_1 &
> ));
BOOST_MPL_ASSERT(( is_same<
ft::function_reference<mpl::vector<int>, ft::non_variadic>::type
, expected_nv_1 &
> ));
BOOST_MPL_ASSERT(( is_same<
ft::member_function_pointer<mpl::vector<int,C>, ft::variadic>::type
, expected_v_2
> ));
BOOST_MPL_ASSERT(( is_same<
ft::member_function_pointer<mpl::vector<int,C>, ft::non_variadic>::type
, expected_nv_2
> ));
-------------------------------------------------------------------------
This SF.net email is sponsored by DB2 Express
Download DB2 Express C - the FREE version of DB2 express and take
control of your XML. No limits. Just data. Click to get it now.
http://sourceforge.net/powerbar/db2/
_______________________________________________
Boost-cvs mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/boost-cvs
