From 962a08700ef632c399b2087d09b8bec22d2502fa Mon Sep 17 00:00:00 2001 From: Dave Abrahams Date: Fri, 12 Apr 2002 18:29:14 +0000 Subject: [PATCH] Use PP lib [SVN r13463] --- include/boost/python/call.hpp | 49 ++++++ include/boost/python/call_method.hpp | 50 ++++++ include/boost/python/converter/callback.hpp | 36 +++++ include/boost/python/detail/preprocessor.hpp | 2 + .../boost/python/object/pointer_holder.hpp | 2 +- include/boost/python/preprocessed/call.hpp | 151 +++++++++--------- .../boost/python/preprocessed/call_method.hpp | 147 +++++++++++++++++ .../pointer_holder_back_reference.hpp | 17 +- test/callbacks.cpp | 27 ++-- test/virtual_functions.cpp | 6 +- 10 files changed, 387 insertions(+), 100 deletions(-) create mode 100644 include/boost/python/call.hpp create mode 100644 include/boost/python/call_method.hpp create mode 100644 include/boost/python/preprocessed/call_method.hpp diff --git a/include/boost/python/call.hpp b/include/boost/python/call.hpp new file mode 100644 index 00000000..746b7075 --- /dev/null +++ b/include/boost/python/call.hpp @@ -0,0 +1,49 @@ +// Copyright David Abrahams 2002. Permission to copy, use, +// modify, sell and distribute this software is granted provided this +// copyright notice appears in all copies. This software is provided +// "as is" without express or implied warranty, and with no claim as +// to its suitability for any purpose. +#ifndef CALL_DWA2002411_HPP +# define CALL_DWA2002411_HPP + +# include +# include +# include +# include +# include +# include +# include +# include + +namespace boost { namespace python { + +# ifndef BOOST_PYTHON_GENERATE_CODE +# include +# endif + +# define BOOST_PYTHON_CALL_FUNCTION(nargs,ignored) \ +template < \ + class R \ + BOOST_PP_COMMA_IF(nargs) BOOST_PP_ENUM_PARAMS(nargs, class A) \ + > \ +typename converter::callback_from_python::result_type \ +call(PyObject* callable \ + BOOST_PP_COMMA_IF(nargs) BOOST_PYTHON_ENUM_PARAMS2(nargs, (A,const& a)) \ + , boost::type* = 0 \ + ) \ +{ \ + converter::callback_from_python converter; \ + return converter( \ + PyEval_CallFunction( \ + callable \ + , const_cast(BOOST_PYTHON_ARG_STRING(nargs)) \ + BOOST_PP_COMMA_IF(nargs) \ + BOOST_PP_ENUM(nargs,BOOST_PYTHON_CALLBACK_TO_PYTHON_GET,nil) \ + )); \ +} + +BOOST_PYTHON_REPEAT_ARITY_2ND(BOOST_PYTHON_CALL_FUNCTION,data) + +}} // namespace boost::python + +#endif // CALL_DWA2002411_HPP diff --git a/include/boost/python/call_method.hpp b/include/boost/python/call_method.hpp new file mode 100644 index 00000000..219b1e19 --- /dev/null +++ b/include/boost/python/call_method.hpp @@ -0,0 +1,50 @@ +// Copyright David Abrahams 2002. Permission to copy, use, +// modify, sell and distribute this software is granted provided this +// copyright notice appears in all copies. This software is provided +// "as is" without express or implied warranty, and with no claim as +// to its suitability for any purpose. +#ifndef CALL_METHOD_DWA2002411_HPP +# define CALL_METHOD_DWA2002411_HPP + +# include +# include +# include +# include +# include +# include +# include +# include + +namespace boost { namespace python { + +# ifndef BOOST_PYTHON_GENERATE_CODE +# include +# endif + +# define BOOST_PYTHON_CALL_METHOD_FUNCTION(nargs,ignored) \ +template < \ + class R \ + BOOST_PP_COMMA_IF(nargs) BOOST_PP_ENUM_PARAMS(nargs, class A) \ + > \ +typename converter::callback_from_python::result_type \ +call_method(PyObject* self, char const* name \ + BOOST_PP_COMMA_IF(nargs) BOOST_PYTHON_ENUM_PARAMS2(nargs, (A,const& a)) \ + , boost::type* = 0 \ + ) \ +{ \ + converter::callback_from_python converter; \ + return converter( \ + PyEval_CallMethod( \ + self \ + , const_cast(name) \ + , const_cast(BOOST_PYTHON_ARG_STRING(nargs)) \ + BOOST_PP_COMMA_IF(nargs) \ + BOOST_PP_ENUM(nargs,BOOST_PYTHON_CALLBACK_TO_PYTHON_GET,nil) \ + )); \ +} + +BOOST_PYTHON_REPEAT_ARITY_2ND(BOOST_PYTHON_CALL_METHOD_FUNCTION,data) + +}} // namespace boost::python + +#endif // CALL_METHOD_DWA2002411_HPP diff --git a/include/boost/python/converter/callback.hpp b/include/boost/python/converter/callback.hpp index a8fceb53..9e9c694f 100644 --- a/include/boost/python/converter/callback.hpp +++ b/include/boost/python/converter/callback.hpp @@ -17,6 +17,7 @@ # include # include # include +# include namespace boost { namespace python { namespace converter { @@ -132,6 +133,33 @@ template struct callback_from_python : detail::select_callback_from_python::type { + typedef T result_type; +}; + +struct void_result +{ + private: + void_result() {} + void operator=(void_result const&); + + // I would prefer to make this completely untouchable, but few + // compilers support template friends +# if 0 + void_result(void_result const&); +# endif + friend struct callback_from_python; +}; + +// Specialization as a convenience for call and call_method +template <> +struct callback_from_python +{ + typedef void_result result_type; + result_type operator()(PyObject* x) const + { + Py_DECREF(expect_non_null(x)); + return result_type(); + } }; template @@ -144,6 +172,14 @@ struct callback_to_python callback_to_python(T const& x); }; +// Convenience macros for call<> and call_method<> code generation +# define BOOST_PYTHON_CALLBACK_TO_PYTHON_GET(index,ignored) \ + converter::callback_to_python( \ + BOOST_PP_CAT(a,index)).get() + +# define BOOST_PYTHON_ARG_STRING(nargs) \ + "(" BOOST_PP_REPEAT(nargs,BOOST_PYTHON_PROJECT_2ND,"O") ")" + // // Implementations // diff --git a/include/boost/python/detail/preprocessor.hpp b/include/boost/python/detail/preprocessor.hpp index 728c4699..510e0755 100644 --- a/include/boost/python/detail/preprocessor.hpp +++ b/include/boost/python/detail/preprocessor.hpp @@ -91,6 +91,8 @@ namespace boost { namespace python { namespace detail { #define BOOST_PYTHON_ENUM_PARAMS2(N, Pair) BOOST_PP_ENUM(N, BOOST_PYTHON_NUMBER_PAIR, Pair) +# define BOOST_PYTHON_PROJECT_1ST(a1,a2) a1 +# define BOOST_PYTHON_PROJECT_2ND(a1,a2) a2 }}} // namespace boost::python::detail diff --git a/include/boost/python/object/pointer_holder.hpp b/include/boost/python/object/pointer_holder.hpp index 31e8fead..8ae778b4 100644 --- a/include/boost/python/object/pointer_holder.hpp +++ b/include/boost/python/object/pointer_holder.hpp @@ -74,7 +74,7 @@ struct pointer_holder_back_reference : instance_holder BOOST_PP_COMMA_IF(nargs) \ BOOST_PYTHON_ENUM_PARAMS2(nargs, (A,a))) \ : m_p(new held_type( \ - p, \ + p BOOST_PP_COMMA_IF(nargs) \ BOOST_PP_ENUM(nargs, BOOST_PYTHON_UNFORWARD, nil) \ )) \ { \ diff --git a/include/boost/python/preprocessed/call.hpp b/include/boost/python/preprocessed/call.hpp index 4346116a..2e0e31a1 100644 --- a/include/boost/python/preprocessed/call.hpp +++ b/include/boost/python/preprocessed/call.hpp @@ -1,98 +1,101 @@ -// Copyright David Abrahams 2002. Permission to copy, use, -// modify, sell and distribute this software is granted provided this -// copyright notice appears in all copies. This software is provided -// "as is" without express or implied warranty, and with no claim as -// to its suitability for any purpose. +//Copyright David Abrahams 2002.Permission to copy,use, +//modify,sell and distribute this software is granted provided this +//copyright notice appears in all copies.This software is provided +//"as is" without express or implied warranty,and with no claim as +//to its suitability for any purpose. #ifndef CALL_PP_DWA2002411_HPP -# define CALL_PP_DWA2002411_HPP +#define CALL_PP_DWA2002411_HPP -call(PyObject*self) - :m_result( - PyEval_CallFunction(self,const_cast("(" ")"))) +template +typename converter::callback_from_python::result_type call(PyObject*callable,boost::type* =0) { - + converter::callback_from_pythonconverter; + return converter( + PyEval_CallFunction(callable,const_cast("(" ")"))); } -template -call(PyObject*self,A0 const&a0) - :m_result( - PyEval_CallFunction(self,const_cast("(" "O" ")"), - converter::callback_to_python(a0).get())) +template +typename converter::callback_from_python::result_type call(PyObject*callable,A0 const&a0,boost::type* =0) { - + converter::callback_from_pythonconverter; + return converter( + PyEval_CallFunction(callable,const_cast("(" "O" ")"), + converter::callback_to_python(a0).get())); } -template -call(PyObject*self,A0 const&a0,A1 const&a1) - :m_result( - PyEval_CallFunction(self,const_cast("(" "O" "O" ")"), +template +typename converter::callback_from_python::result_type call(PyObject*callable,A0 const&a0,A1 const&a1,boost::type* =0) +{ + converter::callback_from_pythonconverter; + return converter( + PyEval_CallFunction(callable,const_cast("(" "O" "O" ")"), converter::callback_to_python(a0).get(), - converter::callback_to_python(a1).get())) -{ - + converter::callback_to_python(a1).get())); } -template -call(PyObject*self,A0 const&a0,A1 const&a1,A2 const&a2) - :m_result( - PyEval_CallFunction(self,const_cast("(" "O" "O" "O" ")"), +template +typename converter::callback_from_python::result_type call(PyObject*callable,A0 const&a0,A1 const&a1,A2 const&a2,boost::type* =0) +{ + converter::callback_from_pythonconverter; + return converter( + PyEval_CallFunction(callable,const_cast("(" "O" "O" "O" ")"), converter::callback_to_python(a0).get(), converter::callback_to_python(a1).get(), - converter::callback_to_python(a2).get())) -{ - + converter::callback_to_python(a2).get())); } -template -call(PyObject*self,A0 const&a0,A1 const&a1,A2 const&a2,A3 const&a3) - :m_result( - PyEval_CallFunction(self,const_cast("(" "O" "O" "O" "O" ")"), +template +typename converter::callback_from_python::result_type call(PyObject*callable,A0 const&a0,A1 const&a1,A2 const&a2,A3 const&a3,boost::type* =0) +{ + converter::callback_from_pythonconverter; + return converter( + PyEval_CallFunction(callable,const_cast("(" "O" "O" "O" "O" ")"), converter::callback_to_python(a0).get(), converter::callback_to_python(a1).get(), converter::callback_to_python(a2).get(), - converter::callback_to_python(a3).get())) -{ - + converter::callback_to_python(a3).get())); } -template -call(PyObject*self,A0 const&a0,A1 const&a1,A2 const&a2,A3 const&a3,A4 const&a4) - :m_result( - PyEval_CallFunction(self,const_cast("(" "O" "O" "O" "O" "O" ")"), +template +typename converter::callback_from_python::result_type call(PyObject*callable,A0 const&a0,A1 const&a1,A2 const&a2,A3 const&a3,A4 const&a4,boost::type* =0) +{ + converter::callback_from_pythonconverter; + return converter( + PyEval_CallFunction(callable,const_cast("(" "O" "O" "O" "O" "O" ")"), converter::callback_to_python(a0).get(), converter::callback_to_python(a1).get(), converter::callback_to_python(a2).get(), converter::callback_to_python(a3).get(), - converter::callback_to_python(a4).get())) -{ - + converter::callback_to_python(a4).get())); } -template -call(PyObject*self,A0 const&a0,A1 const&a1,A2 const&a2,A3 const&a3,A4 const&a4,A5 const&a5) - :m_result( - PyEval_CallFunction(self,const_cast("(" "O" "O" "O" "O" "O" "O" ")"), +template +typename converter::callback_from_python::result_type call(PyObject*callable,A0 const&a0,A1 const&a1,A2 const&a2,A3 const&a3,A4 const&a4,A5 const&a5,boost::type* =0) +{ + converter::callback_from_pythonconverter; + return converter( + PyEval_CallFunction(callable,const_cast("(" "O" "O" "O" "O" "O" "O" ")"), converter::callback_to_python(a0).get(), converter::callback_to_python(a1).get(), converter::callback_to_python(a2).get(), converter::callback_to_python(a3).get(), converter::callback_to_python(a4).get(), - converter::callback_to_python(a5).get())) -{ - + converter::callback_to_python(a5).get())); } -template -call(PyObject*self,A0 const&a0,A1 const&a1,A2 const&a2,A3 const&a3,A4 const&a4,A5 const&a5,A6 const&a6) - :m_result( - PyEval_CallFunction(self,const_cast("(" "O" "O" "O" "O" "O" "O" "O" ")"), +template +typename converter::callback_from_python::result_type call(PyObject*callable,A0 const&a0,A1 const&a1,A2 const&a2,A3 const&a3,A4 const&a4,A5 const&a5,A6 const&a6,boost::type* =0) +{ + converter::callback_from_pythonconverter; + return converter( + PyEval_CallFunction(callable,const_cast("(" "O" "O" "O" "O" "O" "O" "O" ")"), converter::callback_to_python(a0).get(), converter::callback_to_python(a1).get(), converter::callback_to_python(a2).get(), converter::callback_to_python(a3).get(), converter::callback_to_python(a4).get(), converter::callback_to_python(a5).get(), - converter::callback_to_python(a6).get())) -{ - + converter::callback_to_python(a6).get())); } -template -call(PyObject*self,A0 const&a0,A1 const&a1,A2 const&a2,A3 const&a3,A4 const&a4,A5 const&a5,A6 const&a6,A7 const&a7) - :m_result( - PyEval_CallFunction(self,const_cast("(" "O" "O" "O" "O" "O" "O" "O" "O" ")"), +template +typename converter::callback_from_python::result_type call(PyObject*callable,A0 const&a0,A1 const&a1,A2 const&a2,A3 const&a3,A4 const&a4,A5 const&a5,A6 const&a6,A7 const&a7,boost::type* =0) +{ + converter::callback_from_pythonconverter; + return converter( + PyEval_CallFunction(callable,const_cast("(" "O" "O" "O" "O" "O" "O" "O" "O" ")"), converter::callback_to_python(a0).get(), converter::callback_to_python(a1).get(), converter::callback_to_python(a2).get(), @@ -100,14 +103,14 @@ call(PyObject*self,A0 const&a0,A1 const&a1,A2 const&a2,A3 const&a3,A4 const&a4,A converter::callback_to_python(a4).get(), converter::callback_to_python(a5).get(), converter::callback_to_python(a6).get(), - converter::callback_to_python(a7).get())) -{ - + converter::callback_to_python(a7).get())); } -template -call(PyObject*self,A0 const&a0,A1 const&a1,A2 const&a2,A3 const&a3,A4 const&a4,A5 const&a5,A6 const&a6,A7 const&a7,A8 const&a8) - :m_result( - PyEval_CallFunction(self,const_cast("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")"), +template +typename converter::callback_from_python::result_type call(PyObject*callable,A0 const&a0,A1 const&a1,A2 const&a2,A3 const&a3,A4 const&a4,A5 const&a5,A6 const&a6,A7 const&a7,A8 const&a8,boost::type* =0) +{ + converter::callback_from_pythonconverter; + return converter( + PyEval_CallFunction(callable,const_cast("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")"), converter::callback_to_python(a0).get(), converter::callback_to_python(a1).get(), converter::callback_to_python(a2).get(), @@ -116,10 +119,8 @@ call(PyObject*self,A0 const&a0,A1 const&a1,A2 const&a2,A3 const&a3,A4 const&a4,A converter::callback_to_python(a5).get(), converter::callback_to_python(a6).get(), converter::callback_to_python(a7).get(), - converter::callback_to_python(a8).get() - )) -{ + converter::callback_to_python(a8).get())); +} + -} - -#endif // CALL_PP_DWA2002411_HPP +#endif//CALL_PP_DWA2002411_HPP diff --git a/include/boost/python/preprocessed/call_method.hpp b/include/boost/python/preprocessed/call_method.hpp new file mode 100644 index 00000000..1e395e4a --- /dev/null +++ b/include/boost/python/preprocessed/call_method.hpp @@ -0,0 +1,147 @@ +//Copyright David Abrahams 2002.Permission to copy,use, +//modify,sell and distribute this software is granted provided this +//copyright notice appears in all copies.This software is provided +//"as is" without express or implied warranty,and with no claim as +//to its suitability for any purpose. +#ifndef CALL_METHOD_PP_DWA2002411_HPP +# define CALL_METHOD_PP_DWA2002411_HPP + +templatetypename +converter::callback_from_python::result_type +call_method(PyObject*self,char const*name,boost::type* =0) +{ + + converter::callback_from_pythonconverter; + return converter( + PyEval_CallMethod(self,const_cast(name),const_cast("(" ")"))); +} +templatetypename +converter::callback_from_python::result_type +call_method(PyObject*self,char const*name,A0 const&a0,boost::type* =0) +{ + + converter::callback_from_pythonconverter; + return converter( + PyEval_CallMethod(self,const_cast(name),const_cast("(" "O" ")"), + converter::callback_to_python(a0).get())); +} +templatetypename +converter::callback_from_python::result_type +call_method(PyObject*self,char const*name,A0 const&a0,A1 const&a1,boost::type* =0) +{ + + converter::callback_from_pythonconverter; + return converter( + PyEval_CallMethod(self,const_cast(name),const_cast("(" "O" "O" ")"), + converter::callback_to_python(a0).get(), + converter::callback_to_python(a1).get())); +} +templatetypename +converter::callback_from_python::result_type +call_method(PyObject*self,char const*name,A0 const&a0,A1 const&a1,A2 const&a2,boost::type* =0) +{ + + converter::callback_from_pythonconverter; + return converter( + PyEval_CallMethod(self,const_cast(name),const_cast("(" "O" "O" "O" ")"), + converter::callback_to_python(a0).get(), + converter::callback_to_python(a1).get(), + converter::callback_to_python(a2).get())); +} +templatetypename +converter::callback_from_python::result_type +call_method(PyObject*self,char const*name,A0 const&a0,A1 const&a1,A2 const&a2,A3 const&a3,boost::type* =0) +{ + + converter::callback_from_pythonconverter; + return converter( + PyEval_CallMethod(self,const_cast(name),const_cast("(" "O" "O" "O" "O" ")"), + converter::callback_to_python(a0).get(), + converter::callback_to_python(a1).get(), + converter::callback_to_python(a2).get(), + converter::callback_to_python(a3).get())); +} +templatetypename +converter::callback_from_python::result_type +call_method(PyObject*self,char const*name,A0 const&a0,A1 const&a1,A2 const&a2,A3 const&a3,A4 const&a4,boost::type* =0) +{ + + converter::callback_from_pythonconverter; + return converter( + PyEval_CallMethod(self,const_cast(name),const_cast("(" "O" "O" "O" "O" "O" ")"), + converter::callback_to_python(a0).get(), + converter::callback_to_python(a1).get(), + converter::callback_to_python(a2).get(), + converter::callback_to_python(a3).get(), + converter::callback_to_python(a4).get())); +} +templatetypename +converter::callback_from_python::result_type +call_method(PyObject*self,char const*name,A0 const&a0,A1 const&a1,A2 const&a2,A3 const&a3,A4 const&a4,A5 const&a5,boost::type* =0) +{ + + converter::callback_from_pythonconverter; + return converter( + PyEval_CallMethod(self,const_cast(name),const_cast("(" "O" "O" "O" "O" "O" "O" ")"), + converter::callback_to_python(a0).get(), + converter::callback_to_python(a1).get(), + converter::callback_to_python(a2).get(), + converter::callback_to_python(a3).get(), + converter::callback_to_python(a4).get(), + converter::callback_to_python(a5).get())); +} +templatetypename +converter::callback_from_python::result_type +call_method(PyObject*self,char const*name,A0 const&a0,A1 const&a1,A2 const&a2,A3 const&a3,A4 const&a4,A5 const&a5,A6 const&a6,boost::type* =0) +{ + + converter::callback_from_pythonconverter; + return converter( + PyEval_CallMethod(self,const_cast(name),const_cast("(" "O" "O" "O" "O" "O" "O" "O" ")"), + converter::callback_to_python(a0).get(), + converter::callback_to_python(a1).get(), + converter::callback_to_python(a2).get(), + converter::callback_to_python(a3).get(), + converter::callback_to_python(a4).get(), + converter::callback_to_python(a5).get(), + converter::callback_to_python(a6).get())); +} +templatetypename +converter::callback_from_python::result_type +call_method(PyObject*self,char const*name,A0 const&a0,A1 const&a1,A2 const&a2,A3 const&a3,A4 const&a4,A5 const&a5,A6 const&a6,A7 const&a7,boost::type* =0) +{ + + converter::callback_from_pythonconverter; + return converter( + PyEval_CallMethod(self,const_cast(name),const_cast("(" "O" "O" "O" "O" "O" "O" "O" "O" ")"), + converter::callback_to_python(a0).get(), + converter::callback_to_python(a1).get(), + converter::callback_to_python(a2).get(), + converter::callback_to_python(a3).get(), + converter::callback_to_python(a4).get(), + converter::callback_to_python(a5).get(), + converter::callback_to_python(a6).get(), + converter::callback_to_python(a7).get())); +} +templatetypename +converter::callback_from_python::result_type +call_method(PyObject*self,char const*name,A0 const&a0,A1 const&a1,A2 const&a2,A3 const&a3,A4 const&a4,A5 const&a5,A6 const&a6,A7 const&a7,A8 const&a8,boost::type* =0) +{ + + converter::callback_from_pythonconverter; + return converter( + PyEval_CallMethod(self,const_cast(name),const_cast("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")"), + converter::callback_to_python(a0).get(), + converter::callback_to_python(a1).get(), + converter::callback_to_python(a2).get(), + converter::callback_to_python(a3).get(), + converter::callback_to_python(a4).get(), + converter::callback_to_python(a5).get(), + converter::callback_to_python(a6).get(), + converter::callback_to_python(a7).get(), + converter::callback_to_python(a8).get())); +} + + +#endif// +CALL_METHOD_PP_DWA2002411_HPP diff --git a/include/boost/python/preprocessed/pointer_holder_back_reference.hpp b/include/boost/python/preprocessed/pointer_holder_back_reference.hpp index b07242cc..9d86a172 100644 --- a/include/boost/python/preprocessed/pointer_holder_back_reference.hpp +++ b/include/boost/python/preprocessed/pointer_holder_back_reference.hpp @@ -1,13 +1,13 @@ -// Copyright David Abrahams 2002. Permission to copy, use, -// modify, sell and distribute this software is granted provided this -// copyright notice appears in all copies. This software is provided -// "as is" without express or implied warranty, and with no claim as -// to its suitability for any purpose. +//Copyright David Abrahams 2002.Permission to copy,use, +//modify,sell and distribute this software is granted provided this +//copyright notice appears in all copies.This software is provided +//"as is" without express or implied warranty,and with no claim as +//to its suitability for any purpose. #ifndef POINTER_HOLDER_BACK_REFERENCE_DWA2002411_HPP -# define POINTER_HOLDER_BACK_REFERENCE_DWA2002411_HPP +#define POINTER_HOLDER_BACK_REFERENCE_DWA2002411_HPP pointer_holder_back_reference(PyObject*p) - :m_p(new held_type(p,)) + :m_p(new held_type(p)) { void const*x=&instance_finder::registration; (void)x; @@ -111,5 +111,6 @@ template::registration; (void)x; } + -#endif // POINTER_HOLDER_BACK_REFERENCE_DWA2002411_HPP +#endif//POINTER_HOLDER_BACK_REFERENCE_DWA2002411_HPP diff --git a/test/callbacks.cpp b/test/callbacks.cpp index 6d1b8fba..2778c7b6 100644 --- a/test/callbacks.cpp +++ b/test/callbacks.cpp @@ -4,23 +4,24 @@ // "as is" without express or implied warranty, and with no claim as // to its suitability for any purpose. #include -#include +//#include #include #include #include #include #include +#include using namespace boost::python; int apply_int_int(PyObject* f, int x) { - return returning::call(f, x); + return call(f, x); } void apply_void_int(PyObject* f, int x) { - returning::call(f, x); + call(f, x); } struct X @@ -42,52 +43,52 @@ struct X X apply_X_X(PyObject* f, X x) { - return returning::call(f, x); + return call(f, x); } void apply_void_X_ref(PyObject* f, X& x) { - returning::call(f, boost::ref(x)); + call(f, boost::ref(x)); } X& apply_X_ref_pyobject(PyObject* f, PyObject* obj) { - return returning::call(f, obj); + return call(f, obj); } X* apply_X_ptr_pyobject(PyObject* f, PyObject* obj) { - return returning::call(f, obj); + return call(f, obj); } void apply_void_X_cref(PyObject* f, X const& x) { - returning::call(f, boost::cref(x)); + call(f, boost::cref(x)); } void apply_void_X_ptr(PyObject* f, X* x) { - returning::call(f, ptr(x)); + call(f, ptr(x)); } void apply_void_X_deep_ptr(PyObject* f, X* x) { - returning::call(f, x); + call(f, x); } char const* apply_cstring_cstring(PyObject* f, char const* s) { - return returning ::call(f, s); + return call(f, s); } char const* apply_cstring_pyobject(PyObject* f, PyObject* s) { - return returning ::call(f, s); + return call(f, s); } char apply_char_char(PyObject* f, char c) { - return returning ::call(f, c); + return call(f, c); } int X::counter; diff --git a/test/virtual_functions.cpp b/test/virtual_functions.cpp index 586048d5..3f516bf7 100644 --- a/test/virtual_functions.cpp +++ b/test/virtual_functions.cpp @@ -5,7 +5,7 @@ // to its suitability for any purpose. #include #include -#include +#include #include #include @@ -55,7 +55,7 @@ struct abstract_callback : abstract int f(Y const& y) { - return returning::call_method(self, "f", boost::ref(y)); + return call_method(self, "f", boost::ref(y)); } PyObject* self; @@ -73,7 +73,7 @@ struct concrete_callback : concrete int f(Y const& y) { - return returning::call_method(self, "f", boost::ref(y)); + return call_method(self, "f", boost::ref(y)); } int f_impl(Y const& y)