One more step towards handling polymorphism: now we can sort out a 4th parameter

dabrahams · dabrahams · commit bb536a0eaa0a · 2002-11-16T20:03:59.000Z
[SVN r16287]
diff --git a/include/boost/python/detail/def_helper.hpp b/include/boost/python/detail/def_helper.hpp
@@ -65,7 +65,7 @@ namespace detail
   struct tuple_extract_base_select
   {
       typedef typename Tuple::head_type head_type;
-      typedef typename mpl::apply1<Predicate,head_type>::type match_t;
+      typedef typename mpl::apply1<Predicate, add_reference<head_type>::type>::type match_t;
       BOOST_STATIC_CONSTANT(bool, match = match_t::value);
       typedef typename tuple_extract_impl<match>::template apply<Tuple,Predicate> type;
   };
@@ -85,15 +85,15 @@ namespace detail
       Tuple,
       mpl::logical_not<
         is_reference_to_class<
-          add_reference<mpl::_1>
+          mpl::_1
         >
       > >
   {
   };
   
   template <class Tuple>
   struct keyword_extract
-      : tuple_extract<Tuple, is_reference_to_keywords<add_reference<mpl::_1> > >
+      : tuple_extract<Tuple, is_reference_to_keywords<mpl::_1 > >
   {
   };
 
@@ -103,8 +103,8 @@ namespace detail
           Tuple,
           mpl::logical_and<
              mpl::logical_not<is_same<not_specified const&,mpl::_1> >
-             , is_reference_to_class<add_reference<mpl::_> >
-             , mpl::logical_not<is_reference_to_keywords<add_reference<mpl::_1> > >
+               , is_reference_to_class<mpl::_1 >
+               , mpl::logical_not<is_reference_to_keywords<mpl::_1 > >
           >
         >
   {
@@ -115,20 +115,18 @@ namespace detail
       : tuple_extract<
           Tuple,
           mpl::logical_or<
-             is_reference_to_function_pointer<mpl::_1>
-             , is_reference_to_function<mpl::_1>
-             , is_same<mpl::_1,tuples::null_type>
+             is_reference_to_function_pointer<mpl::_1 >
+             , is_reference_to_function<mpl::_1 >
           >
         >
   {
   };
 
-# define BOOST_PYTHON_DEF_HELPER_TAIL default_call_policies, keywords<0>, char const*
   template <class T1, class T2 = not_specified, class T3 = not_specified>
   struct def_helper
   {
       typedef boost::tuples::tuple<
-          T1 const&, T2 const&, T3 const&, default_call_policies, keywords<0>, char const*
+          T1 const&, T2 const&, T3 const&, default_call_policies, keywords<0>, char const*, void(*)()
           > all_t;
 
       def_helper(T1 const& a1) : m_all(a1,m_nil,m_nil) {}
@@ -150,8 +148,14 @@ namespace detail
           return policy_extract<all_t>::extract(m_all);
       }
 
-      typedef 
-      typename default_implementation_extract<all_t>::result_type default_implementation() const
+   private:
+      typedef typename default_implementation_extract<all_t>::result_type default_implementation_t;
+   public:
+      BOOST_STATIC_CONSTANT(
+          bool, has_default_implementation = (
+              !is_same<default_implementation_t, tuples::null_type>::value));
+      
+      default_implementation_t default_implementation() const
       {
           return policy_extract<all_t>::extract(m_all);
       }
diff --git a/include/boost/python/detail/indirect_traits.hpp b/include/boost/python/detail/indirect_traits.hpp
@@ -101,6 +101,7 @@ struct is_reference_to_function_pointer_aux
                                  typename remove_reference<T>::type
                               >::type
                               >::value));
+    typedef mpl::bool_c<value> type;
 };
 
 template <class T>
@@ -274,12 +275,14 @@ struct is_pointer_to_function_aux
     BOOST_STATIC_CONSTANT(
         bool, value
         = sizeof(::boost::type_traits::is_function_ptr_tester(t)) == sizeof(::boost::type_traits::yes_type));
+    typedef mpl::bool_c<value> type;
 };
 
 template <class T>
 struct is_pointer_to_function
     : mpl::if_<is_pointer<T>, is_pointer_to_function_aux<T>, mpl::bool_c<false> >::type
 {
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_pointer_to_function,(T))
 };
 
 struct false_helper1
@@ -399,6 +402,7 @@ struct is_reference_to_function_pointer
     : mpl::if_<is_reference<T>
         , is_pointer_to_function_aux<T>, mpl::bool_c<false> >::type
 {
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_function_pointer,(T))
 };
 
 template <typename V>

Original file line number	Diff line number	Diff line change
`@@ -65,7 +65,7 @@ namespace detail`
`65`	`65`	`struct tuple_extract_base_select`
`66`	`66`	`{`
`67`	`67`	`typedef typename Tuple::head_type head_type;`
`68`		`- typedef typename mpl::apply1<Predicate,head_type>::type match_t;`
	`68`	`+ typedef typename mpl::apply1<Predicate, add_reference<head_type>::type>::type match_t;`
`69`	`69`	`BOOST_STATIC_CONSTANT(bool, match = match_t::value);`
`70`	`70`	`typedef typename tuple_extract_impl<match>::template apply<Tuple,Predicate> type;`
`71`	`71`	`};`
`@@ -85,15 +85,15 @@ namespace detail`
`85`	`85`	`Tuple,`
`86`	`86`	`mpl::logical_not<`
`87`	`87`	`is_reference_to_class<`
`88`		`- add_reference<mpl::_1>`
	`88`	`+ mpl::_1`
`89`	`89`	`>`
`90`	`90`	`> >`
`91`	`91`	`{`
`92`	`92`	`};`
`93`	`93`
`94`	`94`	`template <class Tuple>`
`95`	`95`	`struct keyword_extract`
`96`		`- : tuple_extract<Tuple, is_reference_to_keywords<add_reference<mpl::_1> > >`
	`96`	`+ : tuple_extract<Tuple, is_reference_to_keywords<mpl::_1 > >`
`97`	`97`	`{`
`98`	`98`	`};`
`99`	`99`
`@@ -103,8 +103,8 @@ namespace detail`
`103`	`103`	`Tuple,`
`104`	`104`	`mpl::logical_and<`
`105`	`105`	`mpl::logical_not<is_same<not_specified const&,mpl::_1> >`
`106`		`- , is_reference_to_class<add_reference<mpl::_> >`
`107`		`- , mpl::logical_not<is_reference_to_keywords<add_reference<mpl::_1> > >`
	`106`	`+ , is_reference_to_class<mpl::_1 >`
	`107`	`+ , mpl::logical_not<is_reference_to_keywords<mpl::_1 > >`
`108`	`108`	`>`
`109`	`109`	`>`
`110`	`110`	`{`
`@@ -115,20 +115,18 @@ namespace detail`
`115`	`115`	`: tuple_extract<`
`116`	`116`	`Tuple,`
`117`	`117`	`mpl::logical_or<`
`118`		`- is_reference_to_function_pointer<mpl::_1>`
`119`		`- , is_reference_to_function<mpl::_1>`
`120`		`- , is_same<mpl::_1,tuples::null_type>`
	`118`	`+ is_reference_to_function_pointer<mpl::_1 >`
	`119`	`+ , is_reference_to_function<mpl::_1 >`
`121`	`120`	`>`
`122`	`121`	`>`
`123`	`122`	`{`
`124`	`123`	`};`
`125`	`124`
`126`		`-# define BOOST_PYTHON_DEF_HELPER_TAIL default_call_policies, keywords<0>, char const*`
`127`	`125`	`template <class T1, class T2 = not_specified, class T3 = not_specified>`
`128`	`126`	`struct def_helper`
`129`	`127`	`{`
`130`	`128`	`typedef boost::tuples::tuple<`
`131`		`- T1 const&, T2 const&, T3 const&, default_call_policies, keywords<0>, char const*`
	`129`	`+ T1 const&, T2 const&, T3 const&, default_call_policies, keywords<0>, char const, void()()`
`132`	`130`	`> all_t;`
`133`	`131`
`134`	`132`	`def_helper(T1 const& a1) : m_all(a1,m_nil,m_nil) {}`
`@@ -150,8 +148,14 @@ namespace detail`
`150`	`148`	`return policy_extract<all_t>::extract(m_all);`
`151`	`149`	`}`
`152`	`150`
`153`		`- typedef`
`154`		`- typename default_implementation_extract<all_t>::result_type default_implementation() const`
	`151`	`+ private:`
	`152`	`+ typedef typename default_implementation_extract<all_t>::result_type default_implementation_t;`
	`153`	`+ public:`
	`154`	`+ BOOST_STATIC_CONSTANT(`
	`155`	`+ bool, has_default_implementation = (`
	`156`	`+ !is_same<default_implementation_t, tuples::null_type>::value));`
	`157`	`+`
	`158`	`+ default_implementation_t default_implementation() const`
`155`	`159`	`{`
`156`	`160`	`return policy_extract<all_t>::extract(m_all);`
`157`	`161`	`}`