Added reference, deep and shallow pointer to_python conversions

dabrahams · dabrahams · commit f271726cd868 · 2002-03-09T21:13:09.000Z
[SVN r13152]
diff --git a/include/boost/python/converter/pointee_to_python_function.hpp b/include/boost/python/converter/pointee_to_python_function.hpp
@@ -0,0 +1,51 @@
+// 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 POINTEE_TO_PYTHON_FUNCTION_DWA2002128_HPP
+# define POINTEE_TO_PYTHON_FUNCTION_DWA2002128_HPP
+
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/type_traits/transform_traits.hpp>
+# include <boost/type_traits/cv_traits.hpp>
+# include <boost/python/converter/type_id.hpp>
+# include <boost/python/converter/registry.hpp>
+# include <boost/python/converter/to_python_function_type.hpp>
+# include <boost/python/converter/pointer_type_id.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+// pointee_to_python_function --
+//
+// essentially a "templated global reference" which holds the
+// converter for converting a type to Python by-value. We "normalize"
+// T by adding "const volatile&" so that fewer global variables and
+// associated static initializations are generated.
+namespace detail
+{
+  template <class T>
+  struct pointee_to_python_function_base
+  {
+      static to_python_function_t const& value;
+  };
+  
+  template <class T>
+  to_python_function_t const&
+  pointee_to_python_function_base<T>::value
+        = converter::registry::get_to_python_function(pointer_type_id<T>());
+}
+
+template <class T>
+struct pointee_to_python_function
+    : detail::pointee_to_python_function_base<
+        typename add_reference<
+          typename add_cv<T>::type
+        >::type
+      >
+{
+};
+
+}}} // namespace boost::python::converter
+
+#endif // POINTEE_TO_PYTHON_FUNCTION_DWA2002128_HPP
diff --git a/src/converter/callback.cpp b/src/converter/callback.cpp
@@ -8,6 +8,7 @@
 #include <boost/python/errors.hpp>
 #include <boost/python/converter/find_from_python.hpp>
 #include <boost/python/reference.hpp>
+#include <boost/python/detail/none.hpp>
 
 namespace boost { namespace python { namespace converter { 
 
@@ -25,7 +26,10 @@ namespace detail
                 , const_cast<char*>("no to_python (by-value) converter found for type"));
             throw error_already_set();
         }
-        return converter(const_cast<void*>(source));
+        
+        return source == 0
+            ? python::detail::none()
+            : converter(const_cast<void*>(source));
     }
   }
   
@@ -45,6 +49,14 @@ namespace detail
           throw error_already_set();
       }
   }
+
+  BOOST_PYTHON_DECL void throw_no_class_registered()
+  {
+      PyErr_SetString(
+          PyExc_TypeError
+          , const_cast<char*>("class not registered for to_python type"));
+      throw error_already_set();
+  }
   
   BOOST_PYTHON_DECL void* convert_rvalue(PyObject* src, rvalue_stage1_data& data, void* storage)
   {
diff --git a/test/callbacks.cpp b/test/callbacks.cpp
@@ -7,6 +7,7 @@
 #include <boost/python/returning.hpp>
 #include <boost/python/class.hpp>
 #include <boost/ref.hpp>
+#include <boost/python/ptr.hpp>
 
 using namespace boost::python;
 
@@ -42,9 +43,24 @@ X apply_X_X(PyObject* f, X x)
     return returning<X>::call(f, x);
 }
 
-void apply_void_X_ref(PyObject* f, X x)
+void apply_void_X_ref(PyObject* f, X& x)
 {
-    returning<X>::call(f, boost::ref(x));
+    returning<void>::call(f, boost::ref(x));
+}
+
+void apply_void_X_cref(PyObject* f, X const& x)
+{
+    returning<void>::call(f, boost::cref(x));
+}
+
+void apply_void_X_ptr(PyObject* f, X* x)
+{
+    returning<void>::call(f, ptr(x));
+}
+
+void apply_void_X_deep_ptr(PyObject* f, X* x)
+{
+    returning<void>::call(f, x);
 }
 
 int X::counter;
@@ -56,6 +72,9 @@ BOOST_PYTHON_MODULE_INIT(callbacks_ext)
         .def("apply_void_int", apply_void_int)
         .def("apply_X_X", apply_X_X)
         .def("apply_void_X_ref", apply_void_X_ref)
+        .def("apply_void_X_cref", apply_void_X_cref)
+        .def("apply_void_X_ptr", apply_void_X_ptr)
+        .def("apply_void_X_deep_ptr", apply_void_X_deep_ptr)
         .add(
             class_<X>("X")
             .def_init(args<int>())
@@ -67,5 +86,4 @@ BOOST_PYTHON_MODULE_INIT(callbacks_ext)
         ;
 }
 
-
-
+#include "module_tail.cpp"
diff --git a/test/callbacks.py b/test/callbacks.py
@@ -27,6 +27,45 @@
 >>> apply_void_X_ref(increment, x)
 >>> x.value()
 43
+
+>>> apply_void_X_cref(increment, x) 
+>>> x.value()  # const-ness is not respected, sorry!
+44
+
+>>> last_x = 1
+>>> def decrement(x):
+...     global last_x
+...     last_x = x
+...     if x is not None:
+...         x.set(x.value() - 1)
+
+>>> apply_void_X_ptr(decrement, x)
+>>> x.value()
+43
+>>> last_x.value()
+43
+>>> increment(last_x)
+>>> x.value()
+44
+>>> last_x.value()
+44
+
+>>> apply_void_X_ptr(decrement, None)
+>>> assert last_x is None
+>>> x.value()
+44
+
+>>> last_x = 1
+>>> apply_void_X_deep_ptr(decrement, None)
+>>> assert last_x is None
+>>> x.value()
+44
+
+>>> apply_void_X_deep_ptr(decrement, x)
+>>> x.value()
+44
+>>> last_x.value()
+43
 '''
 
 def run(args = None):

Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,7 @@`
`8`	`8`	`#include <boost/python/errors.hpp>`
`9`	`9`	`#include <boost/python/converter/find_from_python.hpp>`
`10`	`10`	`#include <boost/python/reference.hpp>`
	`11`	`+#include <boost/python/detail/none.hpp>`
`11`	`12`
`12`	`13`	`namespace boost { namespace python { namespace converter {`
`13`	`14`
`@@ -25,7 +26,10 @@ namespace detail`
`25`	`26`	`, const_cast<char*>("no to_python (by-value) converter found for type"));`
`26`	`27`	`throw error_already_set();`
`27`	`28`	`}`
`28`		`- return converter(const_cast<void*>(source));`
	`29`	`+`
	`30`	`+ return source == 0`
	`31`	`+ ? python::detail::none()`
	`32`	`+ : converter(const_cast<void*>(source));`
`29`	`33`	`}`
`30`	`34`	`}`
`31`	`35`
`@@ -45,6 +49,14 @@ namespace detail`
`45`	`49`	`throw error_already_set();`
`46`	`50`	`}`
`47`	`51`	`}`
	`52`	`+`
	`53`	`+ BOOST_PYTHON_DECL void throw_no_class_registered()`
	`54`	`+ {`
	`55`	`+ PyErr_SetString(`
	`56`	`+ PyExc_TypeError`
	`57`	`+ , const_cast<char*>("class not registered for to_python type"));`
	`58`	`+ throw error_already_set();`
	`59`	`+ }`
`48`	`60`
`49`	`61`	`BOOST_PYTHON_DECL void* convert_rvalue(PyObject* src, rvalue_stage1_data& data, void* storage)`
`50`	`62`	`{`