Add an explicit destructor function argument to registry::push_back()

include/boost/python/converter/constructor_function.hpp

@@ -7,10 +7,11 @@
 
 namespace boost { namespace python { namespace converter { 
 
-// Declares the type of functions used to construct C++ objects for
+// Declares the type of functions used to construct or destruct C++ objects for
 // rvalue from_python conversions.
 struct rvalue_from_python_stage1_data;
 typedef void (*constructor_function)(PyObject* source, rvalue_from_python_stage1_data*);
+typedef void (*destructor_function)(rvalue_from_python_stage1_data*);
 
 }}} // namespace boost::python::converter
 

include/boost/python/converter/implicit.hpp

@@ -39,6 +39,11 @@ struct implicit
         // record successful construction
         data->convertible = storage;
     }
+
+    static void destruct(rvalue_from_python_stage1_data* data)
+    {
+        reinterpret_cast<Target*>(data->convertible)->~Target();
+    }
 };
 
 }}} // namespace boost::python::converter

include/boost/python/converter/registrations.hpp

@@ -27,6 +27,7 @@ struct rvalue_from_python_chain
 {
     convertible_function convertible;
     constructor_function construct;
+    destructor_function destruct;
     PyTypeObject const* (*expected_pytype)();
     rvalue_from_python_chain* next;
 };

include/boost/python/converter/registry.hpp

@@ -36,6 +36,7 @@ namespace registry
   BOOST_PYTHON_DECL void insert(
       convertible_function
       , constructor_function
+      , destructor_function
       , type_info
       , PyTypeObject const* (*expected_pytype)()  = 0
       );
@@ -45,6 +46,7 @@ namespace registry
   BOOST_PYTHON_DECL void push_back(
       convertible_function
       , constructor_function
+      , destructor_function
       , type_info
       , PyTypeObject const* (*expected_pytype)()  = 0
       );

include/boost/python/converter/rvalue_from_python_data.hpp

@@ -62,6 +62,7 @@ struct rvalue_from_python_stage1_data
 {
     void* convertible;
     constructor_function construct;
+    destructor_function destruct;
 };
 
 // Augments rvalue_from_python_stage1_data by adding storage for
@@ -132,7 +133,7 @@ template <class T>
 inline rvalue_from_python_data<T>::~rvalue_from_python_data()
 {
     if (this->stage1.convertible == this->storage.bytes)
-        python::detail::destroy_referent<ref_type>(this->storage.bytes);
+        this->stage1.destruct(&(this->stage1));
 }
 
 }}} // namespace boost::python::converter

include/boost/python/converter/shared_ptr_from_python.hpp

@@ -25,7 +25,7 @@ struct shared_ptr_from_python
 {
   shared_ptr_from_python()
   {
-    converter::registry::insert(&convertible, &construct, type_id<SP<T> >()
+    converter::registry::insert(&convertible, &construct, &destruct, type_id<SP<T> >()
 #ifndef BOOST_PYTHON_NO_PY_SIGNATURES
 				, &converter::expected_from_python_type_direct<T>::get_pytype
 #endif
@@ -58,6 +58,12 @@ struct shared_ptr_from_python
 
     data->convertible = storage;
   }
+
+  static void destruct(rvalue_from_python_stage1_data* data)
+  {
+    typedef SP<T> pointer_type;
+    reinterpret_cast<pointer_type*> (data->convertible)->~pointer_type();
+  }
 };
 
 }}} // namespace boost::python::converter

include/boost/python/enum.hpp

@@ -31,6 +31,7 @@ struct enum_ : public objects::enum_base
     static PyObject* to_python(void const* x);
     static void* convertible_from_python(PyObject* obj);
     static void construct(PyObject* obj, converter::rvalue_from_python_stage1_data* data);
+    static void destruct(converter::rvalue_from_python_stage1_data* data);
 };
 
 template <class T>
@@ -40,6 +41,7 @@ inline enum_<T>::enum_(char const* name, char const* doc )
         , &enum_<T>::to_python
         , &enum_<T>::convertible_from_python
         , &enum_<T>::construct
+        , &enum_<T>::destruct
         , type_id<T>()
         , doc
         )
@@ -89,6 +91,12 @@ void enum_<T>::construct(PyObject* obj, converter::rvalue_from_python_stage1_dat
     data->convertible = storage;
 }
 
+template <class T>
+void enum_<T>::destruct(converter::rvalue_from_python_stage1_data* data)
+{
+    reinterpret_cast<T*>(data->convertible)->~T();
+}
+
 template <class T>
 inline enum_<T>& enum_<T>::value(char const* name, T x)
 {

include/boost/python/implicit.hpp

@@ -24,6 +24,7 @@ void implicitly_convertible(boost::type<Source>* = 0, boost::type<Target>* = 0)
     converter::registry::push_back(
           &functions::convertible
         , &functions::construct
+        , &functions::destruct
         , type_id<Target>()
 #ifndef BOOST_PYTHON_NO_PY_SIGNATURES
         , &converter::expected_from_python_type_direct<Source>::get_pytype

include/boost/python/object/enum_base.hpp

@@ -21,6 +21,7 @@ struct BOOST_PYTHON_DECL enum_base : python::api::object
         , converter::to_python_function_t
         , converter::convertible_function
         , converter::constructor_function
+        , converter::destructor_function
         , type_info
         , const char *doc = 0
         );

src/converter/builtin_converters.cpp

@@ -64,6 +64,7 @@ namespace
           registry::insert(
               &slot_rvalue_from_python<T,SlotPolicy>::convertible
               , &slot_rvalue_from_python<T,SlotPolicy>::construct
+              , &slot_rvalue_from_python<T,SlotPolicy>::destruct
               , type_id<T>()
               , &SlotPolicy::get_pytype
               );
@@ -96,6 +97,11 @@ namespace
           // record successful construction
           data->convertible = storage;
       }
+
+      static void destruct(rvalue_from_python_stage1_data* data)
+      {
+          reinterpret_cast<T*> (data->convertible)->~T();
+      }
   };
 
   // identity_unaryfunc/py_object_identity -- manufacture a unaryfunc

src/converter/from_python.cpp

@@ -45,6 +45,7 @@ BOOST_PYTHON_DECL rvalue_from_python_stage1_data rvalue_from_python_stage1(
     // instance, as a special case.
     data.convertible = objects::find_instance_impl(source, converters.target_type, converters.is_shared_ptr);
         data.construct = 0;
+        data.destruct = 0;
     if (!data.convertible)
     {
         for (rvalue_from_python_chain const* chain = converters.rvalue_chain;
@@ -56,6 +57,7 @@ BOOST_PYTHON_DECL rvalue_from_python_stage1_data rvalue_from_python_stage1(
             {
                 data.convertible = r;
                 data.construct = chain->construct;
+                data.destruct = chain->destruct;
                 break;
             }
         }

src/converter/registry.cpp

@@ -239,12 +239,13 @@ namespace registry
       registration->next = found->lvalue_chain;
       found->lvalue_chain = registration;
 
-      insert(convert, 0, key,exp_pytype);
+      insert(convert, 0, 0, key,exp_pytype);
   }
 
   // Insert an rvalue from_python converter
   void insert(convertible_function convertible
               , constructor_function construct
+              , destructor_function destruct
               , type_info key
               , PyTypeObject const* (*exp_pytype)())
   {
@@ -255,6 +256,7 @@ namespace registry
       rvalue_from_python_chain *registration = new rvalue_from_python_chain;
       registration->convertible = convertible;
       registration->construct = construct;
+      registration->destruct = destruct;
       registration->expected_pytype = exp_pytype;
       registration->next = found->rvalue_chain;
       found->rvalue_chain = registration;
@@ -263,6 +265,7 @@ namespace registry
   // Insert an rvalue from_python converter
   void push_back(convertible_function convertible
               , constructor_function construct
+              , destructor_function destruct
               , type_info key
               , PyTypeObject const* (*exp_pytype)())
   {
@@ -276,6 +279,7 @@ namespace registry
       rvalue_from_python_chain *registration = new rvalue_from_python_chain;
       registration->convertible = convertible;
       registration->construct = construct;
+      registration->destruct = destruct;
       registration->expected_pytype = exp_pytype;
       registration->next = 0;
       *found = registration;

src/numpy/dtype.cpp

@@ -176,9 +176,13 @@ class array_scalar_converter
     data->convertible = storage;
   }
 
+  static void destruct(pyconv::rvalue_from_python_stage1_data*)
+  {
+  }
+
   static void declare()
   {
-    pyconv::registry::push_back(&convertible, &convert, python::type_id<T>()
+    pyconv::registry::push_back(&convertible, &convert, &destruct, python::type_id<T>()
 #ifndef BOOST_PYTHON_NO_PY_SIGNATURES
 				, &get_pytype
 #endif

src/object/enum.cpp

@@ -192,6 +192,7 @@ enum_base::enum_base(
     , converter::to_python_function_t to_python
     , converter::convertible_function convertible
     , converter::constructor_function construct
+    , converter::destructor_function destruct
     , type_info id
     , char const *doc
     )
@@ -203,7 +204,7 @@ enum_base::enum_base(
 
     converters.m_class_object = downcast<PyTypeObject>(this->ptr());
     converter::registry::insert(to_python, id);
-    converter::registry::insert(convertible, construct, id);
+    converter::registry::insert(convertible, construct, destruct, id);
 }
 
 void enum_base::add_value(char const* name_, long value)

test/Jamfile

@@ -164,6 +164,7 @@ bpl-test crossmod_opaque
   : crossmod_opaque.py crossmod_opaque_a.cpp crossmod_opaque_b.cpp
 ]
 [ bpl-test opaque ]
+[ bpl-test opaque_ref ]
 [ bpl-test voidptr ]
 
 [ bpl-test pickle1 ]

test/SConscript

@@ -88,6 +88,7 @@ for test in [('injected',),
              ('extract',),
              ('crossmod_opaque', ['crossmod_opaque_a', 'crossmod_opaque_b']),
              ('opaque',),
+             ('opaque_ref',),
 #             ('voidptr',),
              ('pickle1',),
              ('pickle2',),

test/a_map_indexing_suite.cpp

@@ -43,6 +43,7 @@ struct AFromPython
     boost::python::converter::registry::push_back(
         &convertible,
         &construct,
+        &destruct,
         boost::python::type_id< A >());
   }
 
@@ -71,6 +72,11 @@ struct AFromPython
 #endif
     data->convertible = storage;
   }
+
+  static void destruct(boost::python::converter::rvalue_from_python_stage1_data* data)
+  {
+    reinterpret_cast<A*>(data->convertible)->~A();
+  }
 };
 
 void a_map_indexing_suite()

test/opaque_ref.cpp

@@ -0,0 +1,31 @@
+// Copyright David Abrahams and Gottfried Ganssauge 2003.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+# include <boost/python/reference_existing_object.hpp>
+# include <boost/python/def.hpp>
+# include <boost/python/module.hpp>
+# include <boost/python/return_value_policy.hpp>
+
+/* This class is "opaque" in the sense that it is declared, but
+ * we don't define it's members anywhere. */
+struct Opaque
+{
+public:
+    Opaque();
+    ~Opaque();
+};
+
+void use(const Opaque& op)
+{
+    /* do nothing */
+}
+
+namespace bpl = boost::python;
+
+BOOST_PYTHON_MODULE(opaque_ref_ext)
+{
+    bpl::def ("use", &::use);
+}
+
+# include "module_tail.cpp"

test/opaque_ref.py

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+# Copyright Gottfried Ganßauge 2003..2006.  Distributed under the Boost
+# Software License, Version 1.0. (See accompanying
+# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+"""
+>>> from opaque_ref_ext import *
+
+    Don't do anything. The module import is already enough.
+
+"""
+def run(args = None):
+    import sys
+    import doctest
+
+    if args is not None:
+        sys.argv = args
+    return doctest.testmod(sys.modules.get(__name__))
+
+if __name__ == '__main__':
+    print("running...")
+    import sys
+    status = run()[0]
+    if (status == 0): print("Done.")
+    sys.exit(status)

test/pytype_function.cpp

@@ -40,6 +40,7 @@ struct BFromPython
     boost::python::converter::registry::push_back(
         &convertible,
         &construct,
+        &destruct,
         boost::python::type_id< B >()
 #ifndef BOOST_PYTHON_NO_PY_SIGNATURES
         , &converter::expected_from_python_type<A>::get_pytype//convertible to A can be converted to B
@@ -65,6 +66,11 @@ struct BFromPython
     new (storage) B(ex());
     data->convertible = storage;
   }
+
+  static void destruct(boost::python::converter::rvalue_from_python_stage1_data* data)
+  {
+    reinterpret_cast<B*>(data->convertible)->~B();
+  }
 };