Merge lp:~bcatanzaro-w/pybindgen/shared_ptr into lp:~gjc/pybindgen/trunk

[Bryan Catanzaro]

Adds a memory policy for C++11's std::shared_ptr.
I've added a test to the examples directory, but waf isn't working on my system correctly and I don't have time to figure out why not, so I believe the wscript is likely to fail: to compile this code, one needs to enable C++11, which can require adding some compiler flags (such as -std=c++11 for g++).

[Gustavo Carneiro (gjc)]

This was merged. Thank you!

review: Approve

=== added directory 'examples/std_shared_ptr'
=== added file 'examples/std_shared_ptr/modulegen.py'
--- examples/std_shared_ptr/modulegen.py	1970-01-01 00:00:00 +0000
+++ examples/std_shared_ptr/modulegen.py	2014-08-28 21:12:21 +0000
@@ -0,0 +1,47 @@
+#! /usr/bin/env python
+
+import sys, os
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)),
+                                '..', '..'))
+
+#import pybindgen
+#import pybindgen.utils
+#from pybindgen.typehandlers import base as typehandlers
+from pybindgen import Module, FileCodeSink, param, retval
+#from pybindgen import CppMethod, CppConstructor, CppClass, Enum
+#from pybindgen.function import CustomFunctionWrapper
+#from pybindgen.cppmethod import CustomCppMethodWrapper
+from pybindgen import cppclass
+
+#from pybindgen import param, retval
+
+import pybindgen.settings
+pybindgen.settings.deprecated_virtuals = False
+
+
+def my_module_gen(out_file):
+
+    mod = Module('sp')
+
+    mod.add_include ('"sp.h"')
+
+    Foo = mod.add_class('Foo', memory_policy=cppclass.SharedPtr('::Foo'))
+
+    Foo.add_constructor([param('std::string', 'datum')])
+    Foo.add_constructor([])
+    Foo.add_method('get_datum', retval('const std::string'), [])
+    Foo.add_method('set_datum', None, [param('const std::string', 'datum')])
+
+
+    mod.add_function('function_that_takes_foo', None,
+                     [param('std::shared_ptr<Foo>', 'foo')])
+
+    mod.add_function('function_that_returns_foo', retval('std::shared_ptr<Foo>'), [])
+    
+    ## ---- finally, generate the whole thing ----
+    mod.generate(FileCodeSink(out_file))
+
+
+if __name__ == '__main__':
+    my_module_gen(sys.stdout)
+

=== added file 'examples/std_shared_ptr/sp.cc'
--- examples/std_shared_ptr/sp.cc	1970-01-01 00:00:00 +0000
+++ examples/std_shared_ptr/sp.cc	2014-08-28 21:12:21 +0000
@@ -0,0 +1,16 @@
+#include "sp.h"
+
+std::shared_ptr<Foo> g_foo;
+
+void function_that_takes_foo(std::shared_ptr<Foo> foo)
+{
+    g_foo = foo;
+}
+
+std::shared_ptr<Foo> function_that_returns_foo()
+{
+    return g_foo;
+}
+
+
+

=== added file 'examples/std_shared_ptr/sp.h'
--- examples/std_shared_ptr/sp.h	1970-01-01 00:00:00 +0000
+++ examples/std_shared_ptr/sp.h	2014-08-28 21:12:21 +0000
@@ -0,0 +1,36 @@
+// -*- Mode: C++; c-file-style: "stroustrup"; indent-tabs-mode:nil; -*-
+#ifndef   	SP_H_
+# define   	SP_H_
+
+#include <string>
+#include <iostream>
+#include <memory>
+
+
+class Foo
+{
+    std::string m_datum;
+public:
+
+    Foo () : m_datum ("") {
+        std::cout << "Created empty foo" << std::endl;
+    }
+
+    Foo (std::string const &datum) : m_datum (datum) {
+        std::cout << "Created foo with datum " << datum << std::endl;
+    }
+
+    const std::string get_datum () const { return m_datum; }
+    
+    void set_datum (std::string const &datum) { m_datum = datum; }
+
+    virtual ~Foo() {
+        std::cout << "Destroyed foo with datum " << m_datum << std::endl;
+    }
+
+};
+
+void function_that_takes_foo (std::shared_ptr<Foo> foo);
+std::shared_ptr<Foo> function_that_returns_foo ();
+
+#endif 	    /* !FOO_H_ */

=== added file 'examples/std_shared_ptr/sp_test.py'
--- examples/std_shared_ptr/sp_test.py	1970-01-01 00:00:00 +0000
+++ examples/std_shared_ptr/sp_test.py	2014-08-28 21:12:21 +0000
@@ -0,0 +1,23 @@
+import sys
+import os.path
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)),
+                                '..', '..', 'build', 'examples', 'boost_shared_ptr'))
+
+import sp
+
+def factory():
+    return sp.Foo('factory')
+
+def use():
+    a = factory()
+    print a.get_datum()
+
+use()
+
+f = sp.Foo("hello123")
+sp.function_that_takes_foo(f)
+f1 = sp.function_that_returns_foo()
+print f1.get_datum()
+f.set_datum("xxxx")
+print f1.get_datum()
+

=== added file 'examples/std_shared_ptr/wscript'
--- examples/std_shared_ptr/wscript	1970-01-01 00:00:00 +0000
+++ examples/std_shared_ptr/wscript	2014-08-28 21:12:21 +0000
@@ -0,0 +1,22 @@
+## -*- python -*-
+
+def build(bld):
+
+    gen = bld(
+        features='command',
+        source='modulegen.py',
+        target='spmodule.cc',
+        command='${PYTHON} ${SRC[0]} > ${TGT[0]}')
+
+    if bld.env['CXX']:
+        # TODO() ADD -std=c++11 flag so that <memory> 
+        # contains std::shared_ptr
+        obj = bld(features=['cxx', 'cxxshlib', 'pyext'])
+        obj.source = [
+            'sp.cc',
+            'spmodule.cc'
+            ]
+        obj.target = 'sp'
+        obj.install_path = None # do not install
+        obj.includes = '.'
+

=== modified file 'pybindgen/cppclass.py'
--- pybindgen/cppclass.py	2014-08-07 21:08:13 +0000
+++ pybindgen/cppclass.py	2014-08-28 21:12:21 +0000
@@ -222,6 +222,28 @@
     def get_pystruct_init_code(self, cpp_class, obj):
         return "new(&%s->obj) %s;" % (obj, self.pointer_name,)
 
+class SharedPtr(SmartPointerPolicy):
+    def __init__(self, class_name):
+        """
+        Create a memory policy for using std::shared_ptr<> to manage instances of this object.
+
+        :param class_name: the full name of the class, e.g. foo::Bar
+        """
+        self.class_name = class_name
+        self.pointer_name = '::std::shared_ptr< %s >' % (self.class_name,)
+
+    def get_delete_code(self, cpp_class):
+        return "self->obj.~shared_ptr< %s >();" % (self.class_name,)
+
+    def get_pointer_type(self, class_full_name):
+        return self.pointer_name + ' '
+
+    def get_instance_creation_function(self):
+        return std_shared_ptr_instance_creation_function
+
+    def get_pystruct_init_code(self, cpp_class, obj):
+        return "new(&%s->obj) %s;" % (obj, self.pointer_name,)
+
 
 def default_instance_creation_function(cpp_class, code_block, lvalue,
                                        parameters, construct_type_name):
@@ -269,6 +291,28 @@
     code_block.write_code(
         "%s.reset (new %s(%s));" % (lvalue, construct_type_name, parameters))
 
+def std_shared_ptr_instance_creation_function(cpp_class, code_block, lvalue,
+                                              parameters, construct_type_name):
+    """
+    std::shared_ptr "instance creation function"; it is called whenever a new
+    C++ class instance needs to be created
+
+    :param cpp_class: the CppClass object whose instance is to be created
+    :param code_block: CodeBlock object on which the instance creation code should be generated
+    :param lvalue: lvalue expression that should hold the result in the end
+    :param parameters: stringified list of parameters
+    :param construct_type_name: actual name of type to be constructed (it is
+                          not always the class name, sometimes it's
+                          the python helper class)
+    """
+    assert lvalue
+    assert not lvalue.startswith('None')
+    if cpp_class.incomplete_type:
+        raise CodeGenerationError("%s cannot be constructed (incomplete type)"
+                                  % cpp_class.full_name)
+    code_block.write_code(
+        "%s = std::make_shared<%s>(%s);" % (lvalue, construct_type_name, parameters))
+
 
 
 class CppHelperClass(object):
@@ -785,7 +829,7 @@
             except ValueError:
                 pass
 
-            if isinstance(self.memory_policy, BoostSharedPtr): # boost::shared_ptr<Class>
+            if isinstance(self.memory_policy, SmartPointerPolicy): # boost::shared_ptr<Class> or std::shared_ptr<Class>
 
                 class ThisClassSharedPtrParameter(CppClassSharedPtrParameter):
                     """Register this C++ class as pass-by-pointer parameter"""
@@ -1263,8 +1307,9 @@
             return_type_matcher.register(alias, self.ThisClassReturn)
         except ValueError: pass
         
-        if isinstance(self.memory_policy, BoostSharedPtr):
-            alias_ptr = 'boost::shared_ptr< %s >' % alias
+        if isinstance(self.memory_policy, SmartPointerPolicy):
+            alias_ptr = self.memory_policy.__class__(alias).pointer_name
+            #alias_ptr = 'boost::shared_ptr< %s >' % alias
             self.ThisClassSharedPtrParameter.CTYPES.append(alias_ptr)
             try:
                 param_type_matcher.register(alias_ptr, self.ThisClassSharedPtrParameter)