mirrors/turtle
3
0
Fork 0
mirror of https://github.com/mat007/turtle.git synced 2026-06-22 12:13:43 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

A boost::lambda functor is now successfully identified by is_functor

Browse source 
git-svn-id: https://svn.code.sf.net/p/turtle/code/trunk@10 860be788-9bd5-4423-9f1e-828f051e677b
This commit is contained in:
mat007 2009-08-30 20:42:11 +00:00
parent f2f1125a1a
commit 1bee70f758
2 changed files with 87 additions and 27 deletions
Download patch file Download diff file Expand all files Collapse all files

66
src/libraries/turtle/is_functor.hpp
View file

@ -10,35 +10,63 @@
#define MOCK_IS_FUNCTOR_HPP_INCLUDED #define MOCK_IS_FUNCTOR_HPP_INCLUDED
#include <boost/function_types/is_callable_builtin.hpp> #include <boost/function_types/is_callable_builtin.hpp>
#include <boost/type_traits/integral_constant.hpp>
#include <boost/mpl/or.hpp>
namespace mock namespace mock
{ {
namespace detail namespace detail
{ {
typedef char true_type[2]; typedef char true_type;
typedef char false_type[1]; struct false_type
template< typename T >
true_type& has_result_type_helper( T*, BOOST_DEDUCED_TYPENAME T::result_type* = 0 );
template< typename T >
false_type& has_result_type_helper( T, ... );
template< typename T >
struct has_result_type
{ {
static T* t(); char padding[8];
enum { value = sizeof( has_result_type_helper( t() ) ) == sizeof( true_type ) };
}; };
template< typename T, bool B = has_result_type< T >::value > template< typename T >
true_type& has_result_type_tester( T*, BOOST_DEDUCED_TYPENAME T::result_type* = 0 );
template< typename T >
false_type& has_result_type_tester( T, ... );
template< typename T >
struct has_result_type_impl
{
static T* t;
enum { value = sizeof( has_result_type_tester( t ) ) == sizeof( true_type ) };
};
template< typename T >
struct has_result_type : public boost::integral_constant< bool, has_result_type_impl< T >::value >
{
};
template< typename T >
true_type& has_sig_tester( T*, BOOST_DEDUCED_TYPENAME T::template sig< void >* = 0 );
template< typename T >
false_type& has_sig_tester( T, ... );
template< typename T >
struct has_sig_impl
{
static T* t;
enum { value = sizeof( has_sig_tester( t ) ) == sizeof( true_type ) };
};
template< typename T >
struct has_sig : public boost::integral_constant< bool, has_sig_impl< T >::value >
{
};
template< typename T >
struct is_functor struct is_functor
{ {
typedef BOOST_DEDUCED_TYPENAME boost::function_types::is_callable_builtin< T >::type type; typedef BOOST_DEDUCED_TYPENAME boost::mpl::or_<
}; BOOST_DEDUCED_TYPENAME boost::mpl::or_<
template< typename T > BOOST_DEDUCED_TYPENAME boost::function_types::is_callable_builtin< T >::type,
struct is_functor< T, true > BOOST_DEDUCED_TYPENAME has_result_type< T >::type
{ >::type,
typedef boost::true_type type; BOOST_DEDUCED_TYPENAME has_sig< T >::type
>::type type;
}; };
} }
} }

58
src/tests/turtle_test/is_functor_test.cpp
View file

@ -9,6 +9,13 @@
#include <turtle/is_functor.hpp> #include <turtle/is_functor.hpp>
#include <boost/function.hpp> #include <boost/function.hpp>
#include <boost/bind.hpp> #include <boost/bind.hpp>
#ifdef _MSC_VER
#pragma warning( push, 0 )
#endif
#include <boost/lambda/lambda.hpp>
#ifdef _MSC_VER
#pragma warning( pop )
#endif
#include <boost/test/auto_unit_test.hpp> #include <boost/test/auto_unit_test.hpp>
#define BOOST_LIB_NAME boost_unit_test_framework #define BOOST_LIB_NAME boost_unit_test_framework
@ -25,18 +32,6 @@ namespace
void f0 () {} void f0 () {}
bool f1( int ) { return false; } bool f1( int ) { return false; }
bool f2( std::string, int ) { return false; } bool f2( std::string, int ) { return false; }
struct unary_functor0 : public std::unary_function< void, void >
{
};
struct unary_functor1 : public std::unary_function< int, void >
{
};
struct s
{
typedef void result_type;
};
} }
BOOST_AUTO_TEST_CASE( function_is_functor ) BOOST_AUTO_TEST_CASE( function_is_functor )
@ -64,6 +59,15 @@ BOOST_AUTO_TEST_CASE( std_bind_first_is_functor )
check( std::bind1st( std::ptr_fun( &f2 ), "" ) ); check( std::bind1st( std::ptr_fun( &f2 ), "" ) );
} }
namespace
{
struct unary_functor0 : public std::unary_function< void, void >
{
};
struct unary_functor1 : public std::unary_function< int, void >
{
};
}
BOOST_AUTO_TEST_CASE( std_unary_functor_is_functor ) BOOST_AUTO_TEST_CASE( std_unary_functor_is_functor )
{ {
check( unary_functor0() ); check( unary_functor0() );
@ -77,12 +81,40 @@ BOOST_AUTO_TEST_CASE( boost_bind_is_functor )
check( boost::bind( &f2, "", _1 ) ); check( boost::bind( &f2, "", _1 ) );
} }
BOOST_AUTO_TEST_CASE( boost_lambda_is_functor )
{
check( boost::lambda::_1 < 42 );
}
BOOST_AUTO_TEST_CASE( boost_function_is_functor ) BOOST_AUTO_TEST_CASE( boost_function_is_functor )
{ {
check( boost::function< void() >() ); check( boost::function< void() >() );
} }
namespace
{
struct result_type_functor
{
typedef void result_type;
};
}
BOOST_AUTO_TEST_CASE( class_with_result_type_is_functor ) BOOST_AUTO_TEST_CASE( class_with_result_type_is_functor )
{ {
check( s() ); check( result_type_functor() );
}
namespace
{
struct sig_functor
{
template< typename Args >
struct sig
{
typedef void type;
};
};
}
BOOST_AUTO_TEST_CASE( class_with_sig_is_functor )
{
check( sig_functor() );
} }