Enable automatic downcasting to registered classes for pointers, references, and smart pointers

[SVN r16673]

include/boost/python/detail/decref_guard.hpp

@@ -0,0 +1,22 @@
+// 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 DECREF_GUARD_DWA20021220_HPP
+# define DECREF_GUARD_DWA20021220_HPP
+
+namespace boost { namespace python { namespace detail { 
+
+struct decref_guard
+{
+    decref_guard(PyObject* o) : obj(o) {}
+    ~decref_guard() { Py_XDECREF(obj); }
+    void cancel() { obj = 0; }
+ private:
+    PyObject* obj;
+};
+
+}}} // namespace boost::python::detail
+
+#endif // DECREF_GUARD_DWA20021220_HPP

include/boost/python/object/make_instance.hpp

@@ -8,42 +8,34 @@
 
 # include <boost/python/object/instance.hpp>
 # include <boost/python/converter/registered.hpp>
+# include <boost/python/detail/decref_guard.hpp>
 
 namespace boost { namespace python { namespace objects { 
 
-struct decref_guard
-{
-    decref_guard(PyObject* o) : obj(o) {}
-    ~decref_guard() { Py_XDECREF(obj); }
-    void cancel() { obj = 0; }
- private:
-    PyObject* obj;
-};
-
-template <class T, class Holder>
-struct make_instance
+template <class T, class Holder, class Derived>
+struct make_instance_impl
 {
     typedef objects::instance<Holder> instance_t;
         
     template <class Arg>
-    static PyObject* execute(Arg& x)
+    static inline PyObject* execute(Arg& x)
     {
         BOOST_STATIC_ASSERT(is_class<T>::value);
-        
-        PyTypeObject* type = converter::registered<T>::converters.get_class_object();
+
+        PyTypeObject* type = Derived::get_class_object(x);
 
         PyObject* raw_result = type->tp_alloc(
             type, objects::additional_instance_size<Holder>::value);
           
         if (raw_result != 0)
         {
-            decref_guard protect(raw_result);
+            python::detail::decref_guard protect(raw_result);
             
             instance_t* instance = (instance_t*)raw_result;
             
             // construct the new C++ object and install the pointer
             // in the Python object.
-            construct(instance, x)->install(raw_result);
+            Derived::construct(&instance->storage, (PyObject*)instance, x)->install(raw_result);
               
             // Note the position of the internally-stored Holder,
             // for the sake of destruction
@@ -54,23 +46,22 @@ struct make_instance
         }
         return raw_result;
     }
+};
     
- private:
-    // Kind of a hack to support code re-use. The first form is used
-    // to construct holders around pointers or smart pointers. The
-    // second form is used to construct holders around by-value
-    // returns. We have to pass a pointer to the owning Python object
-    // to the second form in order to make it forward the 2nd argument
-    // on to the constructor of its embedded T object.
-    template <class Arg>
-    static Holder* construct(instance_t* result, Arg& x)
-    {
-        return new ((void*)&result->storage) Holder(x);
-    }
 
-    static Holder* construct(instance_t* result, reference_wrapper<T const> x)
+template <class T, class Holder>
+struct make_instance
+    : make_instance_impl<T, Holder, make_instance<T,Holder> >
+{
+    template <class U>
+    static inline PyTypeObject* get_class_object(U&)
     {
-        return new ((void*)&result->storage) Holder((PyObject*)result, x);
+        return converter::registered<T>::converters.get_class_object();
+    }
+    
+    static inline Holder* construct(void* storage, PyObject* instance, reference_wrapper<T const> x)
+    {
+        return new (storage) Holder(instance, x);
     }
 };
   

include/boost/python/object/make_ptr_instance.hpp

@@ -0,0 +1,60 @@
+// 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 MAKE_PTR_INSTANCE_DWA200296_HPP
+# define MAKE_PTR_INSTANCE_DWA200296_HPP
+
+# include <boost/python/object/make_instance.hpp>
+# include <boost/python/converter/registry.hpp>
+# include <boost/type_traits/is_polymorphic.hpp>
+# include <boost/get_pointer.hpp>
+# include <typeinfo>
+
+namespace boost { namespace python { namespace objects { 
+
+template <class T, class Holder>
+struct make_ptr_instance
+    : make_instance_impl<T, Holder, make_ptr_instance<T,Holder> >
+{
+    template <class Arg>
+    static inline Holder* construct(void* storage, PyObject*, Arg& x)
+    {
+        return new (storage) Holder(x);
+    }
+    
+    template <class Ptr>
+    static inline PyTypeObject* get_class_object(Ptr const& x)
+    {
+        return get_class_object_impl(get_pointer(x));
+    }
+
+ private:
+    template <class U>
+    static inline PyTypeObject* get_class_object_impl(U const volatile* p)
+    {
+        PyTypeObject* derived = get_derived_class_object(is_polymorphic<U>::type(), p);
+        if (derived)
+            return derived;
+        return converter::registered<T>::converters.get_class_object();
+    }
+    
+    template <class U>
+    static inline PyTypeObject* get_derived_class_object(mpl::true_c, U const volatile* x)
+    {
+        converter::registration const* r = converter::registry::query(type_info(typeid(*x)));
+        return r ? r->m_class_object : 0;
+    }
+    
+    template <class U>
+    static inline PyTypeObject* get_derived_class_object(mpl::false_c, U*)
+    {
+        return 0;
+    }
+};
+  
+
+}}} // namespace boost::python::object
+
+#endif // MAKE_PTR_INSTANCE_DWA200296_HPP

include/boost/python/object/select_holder.hpp

@@ -12,7 +12,7 @@
 # include <boost/python/object/value_holder.hpp>
 # include <boost/python/object/pointer_holder.hpp>
 # include <boost/python/object/class_wrapper.hpp>
-# include <boost/python/object/make_instance.hpp>
+# include <boost/python/object/make_ptr_instance.hpp>
 # include <boost/python/object/instance.hpp>
 # include <boost/python/detail/force_instantiate.hpp>
 # include <boost/type.hpp>
@@ -142,7 +142,7 @@ namespace detail
       static inline void register_(mpl::false_c)
       {
           python::detail::force_instantiate(
-              objects::class_value_wrapper<Ptr, make_instance<T,type> >());
+              objects::class_value_wrapper<Ptr, make_ptr_instance<T,type> >());
       }
   };
 }

include/boost/python/to_python_indirect.hpp

@@ -13,7 +13,7 @@
 # include <boost/python/detail/unwind_type.hpp>
 # include <boost/python/detail/none.hpp>
 # include <boost/shared_ptr.hpp>
-# include <boost/python/object/make_instance.hpp>
+# include <boost/python/object/make_ptr_instance.hpp>
 # include <memory>
 
 namespace boost { namespace python {
@@ -48,7 +48,7 @@ namespace detail
           typedef objects::pointer_holder<smart_pointer, T> holder_t;
 
           smart_pointer ptr(p);
-          return objects::make_instance<T, holder_t>::execute(ptr);
+          return objects::make_ptr_instance<T, holder_t>::execute(ptr);
       }
   };
 
@@ -59,7 +59,7 @@ namespace detail
       static result_type execute(T* p)
       {
           typedef objects::pointer_holder<T*, T> holder_t;
-          return objects::make_instance<T, holder_t>::execute(p);
+          return objects::make_ptr_instance<T, holder_t>::execute(p);
       }
   };
 

test/polymorphism.cpp

@@ -3,7 +3,14 @@
 // 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.
-#include <boost/python.hpp>
+#include <boost/python/module.hpp>
+#include <boost/python/class.hpp>
+#include <boost/python/return_value_policy.hpp>
+#include <boost/python/manage_new_object.hpp>
+#include <boost/python/reference_existing_object.hpp>
+#include <boost/python/call_method.hpp>
+#include <boost/python/def.hpp>
+#include <boost/utility.hpp>
 
 using namespace boost::python;
 
@@ -40,6 +47,11 @@ struct B : A
     virtual std::string f() { return "B::f()"; }
 };
 
+struct C : A
+{
+    virtual std::string f() { return "C::f()"; }
+};
+
 A& getBCppObj ()
 {
     static B b;
@@ -48,6 +60,25 @@ A& getBCppObj ()
 
 std::string call_f(A& a) { return a.f(); }
 
+A* factory(unsigned choice)
+{
+    switch (choice % 3)
+    {
+    case 0: return new A;
+        break;
+    case 1: return new B;
+        break;
+    default: return new C;
+        break;
+    }
+}
+
+C& getCCppObj ()
+{
+    static C c;
+    return c;
+}
+
 BOOST_PYTHON_MODULE_INIT(polymorphism_ext)
 {
     class_<A,boost::noncopyable,ACallback>("A")
@@ -56,6 +87,14 @@ BOOST_PYTHON_MODULE_INIT(polymorphism_ext)
     
     def("getBCppObj", getBCppObj, return_value_policy<reference_existing_object>());
 
+    class_<C,bases<A>,boost::noncopyable>("C")
+        .def("f", &C::f)
+        ;
+    
+    def("getCCppObj", getCCppObj, return_value_policy<reference_existing_object>());
+
+    def("factory", factory, return_value_policy<manage_new_object>());
+
     def("call_f", call_f);
 }
 

test/polymorphism.py

@@ -17,17 +17,31 @@ class PolymorphTest(unittest.TestCase):
       self.failUnlessEqual ('B::f()', a.f())
       self.failUnlessEqual ('B::f()', call_f(a))
       self.failUnlessEqual ('A::f()', call_f(A()))
+
+   def test_references(self):
+      # B is not exposed to Python
+      a = getBCppObj()
+      self.failUnlessEqual(type(a), A)
+
+      # C is exposed to Python
+      c = getCCppObj()
+      self.failUnlessEqual(type(c), C)
       
+   def test_factory(self):
+      self.failUnlessEqual(type(factory(0)), A)
+      self.failUnlessEqual(type(factory(1)), A)
+      self.failUnlessEqual(type(factory(2)), C)
+
    def testReturnPy(self):
 
-      class C(A):
+      class D(A):
          def f(self):
-            return 'C.f'
+            return 'D.f'
 
-      c = C()
+      d = D()
       
-      self.failUnlessEqual ('C.f', c.f())
-      self.failUnlessEqual ('C.f', call_f(c))
+      self.failUnlessEqual ('D.f', d.f())
+      self.failUnlessEqual ('D.f', call_f(d))
 
 if __name__ == "__main__":
    

test/shared_ptr.cpp

@@ -82,6 +82,16 @@ struct ZWrap : Z
     PyObject* m_self;
 };
 
+struct YY : Y
+{
+    YY(int n) : Y(n) {}
+};
+
+shared_ptr<Y> factory(int n)
+{
+    return shared_ptr<Y>(n < 42 ? new Y(n) : new YY(n));
+}
+
 static int stored_v() { return functions<Z>::get()->v(); }
 
 BOOST_PYTHON_MODULE(shared_ptr_ext)
@@ -90,6 +100,8 @@ BOOST_PYTHON_MODULE(shared_ptr_ext)
         .def("value", &X::value)
         ;
 
+    def("factory", factory);
+    
     functions<X>::expose();
     def("x_count", &X::count);
     def("x_release", &functions<X>::release_store);
@@ -99,6 +111,9 @@ BOOST_PYTHON_MODULE(shared_ptr_ext)
         .def("value", &Y::value)
         ;
     
+    class_<YY, bases<Y>, boost::noncopyable>("YY", init<int>())
+        ;
+
     functions<Y>::expose();
     def("y_count", &Y::count);
     def("y_release", &functions<Y>::release_store);

test/shared_ptr.py

@@ -1,5 +1,11 @@
 '''
 >>> from shared_ptr_ext import *
+
+>>> type(factory(3))
+<class 'shared_ptr_ext.Y'>
+>>> type(factory(42))
+<class 'shared_ptr_ext.YY'>
+
 >>> class P(Z):
 ...     def v(self):
 ...         return -Z.v(self);